Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 70dd5bf3b99964d52862ad2810c24cc32a553535

Authored by Martin K. Petersen
Committed by Jens Axboe
1 parent 7c958e3264
Exists in master and in 39 other branches 8mp-imx_5.4.70_2.3.0, 8qm-imx_5.4.70_2.3.0, emb_imx_lf-5.15.y, emb_lf-6.1.y, imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, imx_4.1.15_1.0.0_ga, pitx_8mp_lf-5.10.y, rt-smarc-imx_4.1.15_1.0.0_ga, rt_linux_5.15.71, smarc-8m-android-11.0.0_2.0.0, smarc-imx6_4.14.98_2.0.0_ga, smarc-imx6_4.9.88_2.0.0_ga, smarc-imx7_4.14.98_2.0.0_ga, smarc-imx7_4.9.11_1.0.0_ga, smarc-imx7_4.9.88_2.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-imx_4.1.15_1.0.0_ga, smarc-imx_4.9.11_1.0.0_ga, smarc-imx_4.9.51_imx8m_ga, smarc-imx_4.9.88_2.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_1.2.0_ga, smarc_8m_00d0_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.14.78_1.0.0_ga, smarc_8m_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.19.35_1.1.0, smarc_8mm_imx_4.14.78_1.0.0_ga, smarc_8mm_imx_4.14.98_2.0.0_ga, smarc_8mm_imx_4.19.35_1.1.0, smarc_8mm_imx_5.4.24_2.1.0, smarc_8mp_lf-5.10.y, smarc_8mq_imx_5.4.24_2.1.0, smarc_8mq_lf-5.10.y, smarc_imx_lf-5.15.y

block: Stack optimal I/O size 

When stacking block devices ensure that optimal I/O size is scaled
accordingly.

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Reviewed-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

Showing 1 changed file with 11 additions and 0 deletions Inline Diff

block/blk-settings.c
Diff comments   View file @ 70dd5bf
1 /* 1 /*
2 * Functions related to setting various queue properties from drivers 2 * Functions related to setting various queue properties from drivers
3 */ 3 */
4 #include <linux/kernel.h> 4 #include <linux/kernel.h>
5 #include <linux/module.h> 5 #include <linux/module.h>
6 #include <linux/init.h> 6 #include <linux/init.h>
7 #include <linux/bio.h> 7 #include <linux/bio.h>
8 #include <linux/blkdev.h> 8 #include <linux/blkdev.h>
9 #include <linux/bootmem.h> /* for max_pfn/max_low_pfn */ 9 #include <linux/bootmem.h> /* for max_pfn/max_low_pfn */
10 #include <linux/gcd.h>
10 11
11 #include "blk.h" 12 #include "blk.h"
12 13
13 unsigned long blk_max_low_pfn; 14 unsigned long blk_max_low_pfn;
14 EXPORT_SYMBOL(blk_max_low_pfn); 15 EXPORT_SYMBOL(blk_max_low_pfn);
15 16
16 unsigned long blk_max_pfn; 17 unsigned long blk_max_pfn;
17 18
18 /** 19 /**
19 * blk_queue_prep_rq - set a prepare_request function for queue 20 * blk_queue_prep_rq - set a prepare_request function for queue
20 * @q: queue 21 * @q: queue
21 * @pfn: prepare_request function 22 * @pfn: prepare_request function
22 * 23 *
23 * It's possible for a queue to register a prepare_request callback which 24 * It's possible for a queue to register a prepare_request callback which
24 * is invoked before the request is handed to the request_fn. The goal of 25 * is invoked before the request is handed to the request_fn. The goal of
25 * the function is to prepare a request for I/O, it can be used to build a 26 * the function is to prepare a request for I/O, it can be used to build a
26 * cdb from the request data for instance. 27 * cdb from the request data for instance.
27 * 28 *
28 */ 29 */
29 void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn) 30 void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn)
30 { 31 {
31 q->prep_rq_fn = pfn; 32 q->prep_rq_fn = pfn;
32 } 33 }
33 EXPORT_SYMBOL(blk_queue_prep_rq); 34 EXPORT_SYMBOL(blk_queue_prep_rq);
34 35
35 /** 36 /**
36 * blk_queue_set_discard - set a discard_sectors function for queue 37 * blk_queue_set_discard - set a discard_sectors function for queue
37 * @q: queue 38 * @q: queue
38 * @dfn: prepare_discard function 39 * @dfn: prepare_discard function
39 * 40 *
40 * It's possible for a queue to register a discard callback which is used 41 * It's possible for a queue to register a discard callback which is used
41 * to transform a discard request into the appropriate type for the 42 * to transform a discard request into the appropriate type for the
42 * hardware. If none is registered, then discard requests are failed 43 * hardware. If none is registered, then discard requests are failed
43 * with %EOPNOTSUPP. 44 * with %EOPNOTSUPP.
44 * 45 *
45 */ 46 */
46 void blk_queue_set_discard(struct request_queue *q, prepare_discard_fn *dfn) 47 void blk_queue_set_discard(struct request_queue *q, prepare_discard_fn *dfn)
47 { 48 {
48 q->prepare_discard_fn = dfn; 49 q->prepare_discard_fn = dfn;
49 } 50 }
50 EXPORT_SYMBOL(blk_queue_set_discard); 51 EXPORT_SYMBOL(blk_queue_set_discard);
51 52
52 /** 53 /**
53 * blk_queue_merge_bvec - set a merge_bvec function for queue 54 * blk_queue_merge_bvec - set a merge_bvec function for queue
54 * @q: queue 55 * @q: queue
55 * @mbfn: merge_bvec_fn 56 * @mbfn: merge_bvec_fn
56 * 57 *
57 * Usually queues have static limitations on the max sectors or segments that 58 * Usually queues have static limitations on the max sectors or segments that
58 * we can put in a request. Stacking drivers may have some settings that 59 * we can put in a request. Stacking drivers may have some settings that
59 * are dynamic, and thus we have to query the queue whether it is ok to 60 * are dynamic, and thus we have to query the queue whether it is ok to
60 * add a new bio_vec to a bio at a given offset or not. If the block device 61 * add a new bio_vec to a bio at a given offset or not. If the block device
61 * has such limitations, it needs to register a merge_bvec_fn to control 62 * has such limitations, it needs to register a merge_bvec_fn to control
62 * the size of bio's sent to it. Note that a block device *must* allow a 63 * the size of bio's sent to it. Note that a block device *must* allow a
63 * single page to be added to an empty bio. The block device driver may want 64 * single page to be added to an empty bio. The block device driver may want
64 * to use the bio_split() function to deal with these bio's. By default 65 * to use the bio_split() function to deal with these bio's. By default
65 * no merge_bvec_fn is defined for a queue, and only the fixed limits are 66 * no merge_bvec_fn is defined for a queue, and only the fixed limits are
66 * honored. 67 * honored.
67 */ 68 */
68 void blk_queue_merge_bvec(struct request_queue *q, merge_bvec_fn *mbfn) 69 void blk_queue_merge_bvec(struct request_queue *q, merge_bvec_fn *mbfn)
69 { 70 {
70 q->merge_bvec_fn = mbfn; 71 q->merge_bvec_fn = mbfn;
71 } 72 }
72 EXPORT_SYMBOL(blk_queue_merge_bvec); 73 EXPORT_SYMBOL(blk_queue_merge_bvec);
73 74
74 void blk_queue_softirq_done(struct request_queue *q, softirq_done_fn *fn) 75 void blk_queue_softirq_done(struct request_queue *q, softirq_done_fn *fn)
75 { 76 {
76 q->softirq_done_fn = fn; 77 q->softirq_done_fn = fn;
77 } 78 }
78 EXPORT_SYMBOL(blk_queue_softirq_done); 79 EXPORT_SYMBOL(blk_queue_softirq_done);
79 80
80 void blk_queue_rq_timeout(struct request_queue *q, unsigned int timeout) 81 void blk_queue_rq_timeout(struct request_queue *q, unsigned int timeout)
81 { 82 {
82 q->rq_timeout = timeout; 83 q->rq_timeout = timeout;
83 } 84 }
84 EXPORT_SYMBOL_GPL(blk_queue_rq_timeout); 85 EXPORT_SYMBOL_GPL(blk_queue_rq_timeout);
85 86
86 void blk_queue_rq_timed_out(struct request_queue *q, rq_timed_out_fn *fn) 87 void blk_queue_rq_timed_out(struct request_queue *q, rq_timed_out_fn *fn)
87 { 88 {
88 q->rq_timed_out_fn = fn; 89 q->rq_timed_out_fn = fn;
89 } 90 }
90 EXPORT_SYMBOL_GPL(blk_queue_rq_timed_out); 91 EXPORT_SYMBOL_GPL(blk_queue_rq_timed_out);
91 92
92 void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn) 93 void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn)
93 { 94 {
94 q->lld_busy_fn = fn; 95 q->lld_busy_fn = fn;
95 } 96 }
96 EXPORT_SYMBOL_GPL(blk_queue_lld_busy); 97 EXPORT_SYMBOL_GPL(blk_queue_lld_busy);
97 98
98 /** 99 /**
99 * blk_set_default_limits - reset limits to default values 100 * blk_set_default_limits - reset limits to default values
100 * @lim: the queue_limits structure to reset 101 * @lim: the queue_limits structure to reset
101 * 102 *
102 * Description: 103 * Description:
103 * Returns a queue_limit struct to its default state. Can be used by 104 * Returns a queue_limit struct to its default state. Can be used by
104 * stacking drivers like DM that stage table swaps and reuse an 105 * stacking drivers like DM that stage table swaps and reuse an
105 * existing device queue. 106 * existing device queue.
106 */ 107 */
107 void blk_set_default_limits(struct queue_limits *lim) 108 void blk_set_default_limits(struct queue_limits *lim)
108 { 109 {
109 lim->max_phys_segments = MAX_PHYS_SEGMENTS; 110 lim->max_phys_segments = MAX_PHYS_SEGMENTS;
110 lim->max_hw_segments = MAX_HW_SEGMENTS; 111 lim->max_hw_segments = MAX_HW_SEGMENTS;
111 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; 112 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
112 lim->max_segment_size = MAX_SEGMENT_SIZE; 113 lim->max_segment_size = MAX_SEGMENT_SIZE;
113 lim->max_sectors = lim->max_hw_sectors = SAFE_MAX_SECTORS; 114 lim->max_sectors = lim->max_hw_sectors = SAFE_MAX_SECTORS;
114 lim->logical_block_size = lim->physical_block_size = lim->io_min = 512; 115 lim->logical_block_size = lim->physical_block_size = lim->io_min = 512;
115 lim->bounce_pfn = (unsigned long)(BLK_BOUNCE_ANY >> PAGE_SHIFT); 116 lim->bounce_pfn = (unsigned long)(BLK_BOUNCE_ANY >> PAGE_SHIFT);
116 lim->alignment_offset = 0; 117 lim->alignment_offset = 0;
117 lim->io_opt = 0; 118 lim->io_opt = 0;
118 lim->misaligned = 0; 119 lim->misaligned = 0;
119 lim->no_cluster = 0; 120 lim->no_cluster = 0;
120 } 121 }
121 EXPORT_SYMBOL(blk_set_default_limits); 122 EXPORT_SYMBOL(blk_set_default_limits);
122 123
123 /** 124 /**
124 * blk_queue_make_request - define an alternate make_request function for a device 125 * blk_queue_make_request - define an alternate make_request function for a device
125 * @q: the request queue for the device to be affected 126 * @q: the request queue for the device to be affected
126 * @mfn: the alternate make_request function 127 * @mfn: the alternate make_request function
127 * 128 *
128 * Description: 129 * Description:
129 * The normal way for &struct bios to be passed to a device 130 * The normal way for &struct bios to be passed to a device
130 * driver is for them to be collected into requests on a request 131 * driver is for them to be collected into requests on a request
131 * queue, and then to allow the device driver to select requests 132 * queue, and then to allow the device driver to select requests
132 * off that queue when it is ready. This works well for many block 133 * off that queue when it is ready. This works well for many block
133 * devices. However some block devices (typically virtual devices 134 * devices. However some block devices (typically virtual devices
134 * such as md or lvm) do not benefit from the processing on the 135 * such as md or lvm) do not benefit from the processing on the
135 * request queue, and are served best by having the requests passed 136 * request queue, and are served best by having the requests passed
136 * directly to them. This can be achieved by providing a function 137 * directly to them. This can be achieved by providing a function
137 * to blk_queue_make_request(). 138 * to blk_queue_make_request().
138 * 139 *
139 * Caveat: 140 * Caveat:
140 * The driver that does this *must* be able to deal appropriately 141 * The driver that does this *must* be able to deal appropriately
141 * with buffers in "highmemory". This can be accomplished by either calling 142 * with buffers in "highmemory". This can be accomplished by either calling
142 * __bio_kmap_atomic() to get a temporary kernel mapping, or by calling 143 * __bio_kmap_atomic() to get a temporary kernel mapping, or by calling
143 * blk_queue_bounce() to create a buffer in normal memory. 144 * blk_queue_bounce() to create a buffer in normal memory.
144 **/ 145 **/
145 void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn) 146 void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
146 { 147 {
147 /* 148 /*
148 * set defaults 149 * set defaults
149 */ 150 */
150 q->nr_requests = BLKDEV_MAX_RQ; 151 q->nr_requests = BLKDEV_MAX_RQ;
151 152
152 q->make_request_fn = mfn; 153 q->make_request_fn = mfn;
153 blk_queue_dma_alignment(q, 511); 154 blk_queue_dma_alignment(q, 511);
154 blk_queue_congestion_threshold(q); 155 blk_queue_congestion_threshold(q);
155 q->nr_batching = BLK_BATCH_REQ; 156 q->nr_batching = BLK_BATCH_REQ;
156 157
157 q->unplug_thresh = 4; /* hmm */ 158 q->unplug_thresh = 4; /* hmm */
158 q->unplug_delay = (3 * HZ) / 1000; /* 3 milliseconds */ 159 q->unplug_delay = (3 * HZ) / 1000; /* 3 milliseconds */
159 if (q->unplug_delay == 0) 160 if (q->unplug_delay == 0)
160 q->unplug_delay = 1; 161 q->unplug_delay = 1;
161 162
162 q->unplug_timer.function = blk_unplug_timeout; 163 q->unplug_timer.function = blk_unplug_timeout;
163 q->unplug_timer.data = (unsigned long)q; 164 q->unplug_timer.data = (unsigned long)q;
164 165
165 blk_set_default_limits(&q->limits); 166 blk_set_default_limits(&q->limits);
166 167
167 /* 168 /*
168 * If the caller didn't supply a lock, fall back to our embedded 169 * If the caller didn't supply a lock, fall back to our embedded
169 * per-queue locks 170 * per-queue locks
170 */ 171 */
171 if (!q->queue_lock) 172 if (!q->queue_lock)
172 q->queue_lock = &q->__queue_lock; 173 q->queue_lock = &q->__queue_lock;
173 174
174 /* 175 /*
175 * by default assume old behaviour and bounce for any highmem page 176 * by default assume old behaviour and bounce for any highmem page
176 */ 177 */
177 blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH); 178 blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
178 } 179 }
179 EXPORT_SYMBOL(blk_queue_make_request); 180 EXPORT_SYMBOL(blk_queue_make_request);
180 181
181 /** 182 /**
182 * blk_queue_bounce_limit - set bounce buffer limit for queue 183 * blk_queue_bounce_limit - set bounce buffer limit for queue
183 * @q: the request queue for the device 184 * @q: the request queue for the device
184 * @dma_mask: the maximum address the device can handle 185 * @dma_mask: the maximum address the device can handle
185 * 186 *
186 * Description: 187 * Description:
187 * Different hardware can have different requirements as to what pages 188 * Different hardware can have different requirements as to what pages
188 * it can do I/O directly to. A low level driver can call 189 * it can do I/O directly to. A low level driver can call
189 * blk_queue_bounce_limit to have lower memory pages allocated as bounce 190 * blk_queue_bounce_limit to have lower memory pages allocated as bounce
190 * buffers for doing I/O to pages residing above @dma_mask. 191 * buffers for doing I/O to pages residing above @dma_mask.
191 **/ 192 **/
192 void blk_queue_bounce_limit(struct request_queue *q, u64 dma_mask) 193 void blk_queue_bounce_limit(struct request_queue *q, u64 dma_mask)
193 { 194 {
194 unsigned long b_pfn = dma_mask >> PAGE_SHIFT; 195 unsigned long b_pfn = dma_mask >> PAGE_SHIFT;
195 int dma = 0; 196 int dma = 0;
196 197
197 q->bounce_gfp = GFP_NOIO; 198 q->bounce_gfp = GFP_NOIO;
198 #if BITS_PER_LONG == 64 199 #if BITS_PER_LONG == 64
199 /* 200 /*
200 * Assume anything <= 4GB can be handled by IOMMU. Actually 201 * Assume anything <= 4GB can be handled by IOMMU. Actually
201 * some IOMMUs can handle everything, but I don't know of a 202 * some IOMMUs can handle everything, but I don't know of a
202 * way to test this here. 203 * way to test this here.
203 */ 204 */
204 if (b_pfn < (min_t(u64, 0xffffffffUL, BLK_BOUNCE_HIGH) >> PAGE_SHIFT)) 205 if (b_pfn < (min_t(u64, 0xffffffffUL, BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
205 dma = 1; 206 dma = 1;
206 q->limits.bounce_pfn = max_low_pfn; 207 q->limits.bounce_pfn = max_low_pfn;
207 #else 208 #else
208 if (b_pfn < blk_max_low_pfn) 209 if (b_pfn < blk_max_low_pfn)
209 dma = 1; 210 dma = 1;
210 q->limits.bounce_pfn = b_pfn; 211 q->limits.bounce_pfn = b_pfn;
211 #endif 212 #endif
212 if (dma) { 213 if (dma) {
213 init_emergency_isa_pool(); 214 init_emergency_isa_pool();
214 q->bounce_gfp = GFP_NOIO | GFP_DMA; 215 q->bounce_gfp = GFP_NOIO | GFP_DMA;
215 q->limits.bounce_pfn = b_pfn; 216 q->limits.bounce_pfn = b_pfn;
216 } 217 }
217 } 218 }
218 EXPORT_SYMBOL(blk_queue_bounce_limit); 219 EXPORT_SYMBOL(blk_queue_bounce_limit);
219 220
220 /** 221 /**
221 * blk_queue_max_sectors - set max sectors for a request for this queue 222 * blk_queue_max_sectors - set max sectors for a request for this queue
222 * @q: the request queue for the device 223 * @q: the request queue for the device
223 * @max_sectors: max sectors in the usual 512b unit 224 * @max_sectors: max sectors in the usual 512b unit
224 * 225 *
225 * Description: 226 * Description:
226 * Enables a low level driver to set an upper limit on the size of 227 * Enables a low level driver to set an upper limit on the size of
227 * received requests. 228 * received requests.
228 **/ 229 **/
229 void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors) 230 void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors)
230 { 231 {
231 if ((max_sectors << 9) < PAGE_CACHE_SIZE) { 232 if ((max_sectors << 9) < PAGE_CACHE_SIZE) {
232 max_sectors = 1 << (PAGE_CACHE_SHIFT - 9); 233 max_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
233 printk(KERN_INFO "%s: set to minimum %d\n", 234 printk(KERN_INFO "%s: set to minimum %d\n",
234 __func__, max_sectors); 235 __func__, max_sectors);
235 } 236 }
236 237
237 if (BLK_DEF_MAX_SECTORS > max_sectors) 238 if (BLK_DEF_MAX_SECTORS > max_sectors)
238 q->limits.max_hw_sectors = q->limits.max_sectors = max_sectors; 239 q->limits.max_hw_sectors = q->limits.max_sectors = max_sectors;
239 else { 240 else {
240 q->limits.max_sectors = BLK_DEF_MAX_SECTORS; 241 q->limits.max_sectors = BLK_DEF_MAX_SECTORS;
241 q->limits.max_hw_sectors = max_sectors; 242 q->limits.max_hw_sectors = max_sectors;
242 } 243 }
243 } 244 }
244 EXPORT_SYMBOL(blk_queue_max_sectors); 245 EXPORT_SYMBOL(blk_queue_max_sectors);
245 246
246 void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_sectors) 247 void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_sectors)
247 { 248 {
248 if (BLK_DEF_MAX_SECTORS > max_sectors) 249 if (BLK_DEF_MAX_SECTORS > max_sectors)
249 q->limits.max_hw_sectors = BLK_DEF_MAX_SECTORS; 250 q->limits.max_hw_sectors = BLK_DEF_MAX_SECTORS;
250 else 251 else
251 q->limits.max_hw_sectors = max_sectors; 252 q->limits.max_hw_sectors = max_sectors;
252 } 253 }
253 EXPORT_SYMBOL(blk_queue_max_hw_sectors); 254 EXPORT_SYMBOL(blk_queue_max_hw_sectors);
254 255
255 /** 256 /**
256 * blk_queue_max_phys_segments - set max phys segments for a request for this queue 257 * blk_queue_max_phys_segments - set max phys segments for a request for this queue
257 * @q: the request queue for the device 258 * @q: the request queue for the device
258 * @max_segments: max number of segments 259 * @max_segments: max number of segments
259 * 260 *
260 * Description: 261 * Description:
261 * Enables a low level driver to set an upper limit on the number of 262 * Enables a low level driver to set an upper limit on the number of
262 * physical data segments in a request. This would be the largest sized 263 * physical data segments in a request. This would be the largest sized
263 * scatter list the driver could handle. 264 * scatter list the driver could handle.
264 **/ 265 **/
265 void blk_queue_max_phys_segments(struct request_queue *q, 266 void blk_queue_max_phys_segments(struct request_queue *q,
266 unsigned short max_segments) 267 unsigned short max_segments)
267 { 268 {
268 if (!max_segments) { 269 if (!max_segments) {
269 max_segments = 1; 270 max_segments = 1;
270 printk(KERN_INFO "%s: set to minimum %d\n", 271 printk(KERN_INFO "%s: set to minimum %d\n",
271 __func__, max_segments); 272 __func__, max_segments);
272 } 273 }
273 274
274 q->limits.max_phys_segments = max_segments; 275 q->limits.max_phys_segments = max_segments;
275 } 276 }
276 EXPORT_SYMBOL(blk_queue_max_phys_segments); 277 EXPORT_SYMBOL(blk_queue_max_phys_segments);
277 278
278 /** 279 /**
279 * blk_queue_max_hw_segments - set max hw segments for a request for this queue 280 * blk_queue_max_hw_segments - set max hw segments for a request for this queue
280 * @q: the request queue for the device 281 * @q: the request queue for the device
281 * @max_segments: max number of segments 282 * @max_segments: max number of segments
282 * 283 *
283 * Description: 284 * Description:
284 * Enables a low level driver to set an upper limit on the number of 285 * Enables a low level driver to set an upper limit on the number of
285 * hw data segments in a request. This would be the largest number of 286 * hw data segments in a request. This would be the largest number of
286 * address/length pairs the host adapter can actually give at once 287 * address/length pairs the host adapter can actually give at once
287 * to the device. 288 * to the device.
288 **/ 289 **/
289 void blk_queue_max_hw_segments(struct request_queue *q, 290 void blk_queue_max_hw_segments(struct request_queue *q,
290 unsigned short max_segments) 291 unsigned short max_segments)
291 { 292 {
292 if (!max_segments) { 293 if (!max_segments) {
293 max_segments = 1; 294 max_segments = 1;
294 printk(KERN_INFO "%s: set to minimum %d\n", 295 printk(KERN_INFO "%s: set to minimum %d\n",
295 __func__, max_segments); 296 __func__, max_segments);
296 } 297 }
297 298
298 q->limits.max_hw_segments = max_segments; 299 q->limits.max_hw_segments = max_segments;
299 } 300 }
300 EXPORT_SYMBOL(blk_queue_max_hw_segments); 301 EXPORT_SYMBOL(blk_queue_max_hw_segments);
301 302
302 /** 303 /**
303 * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg 304 * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
304 * @q: the request queue for the device 305 * @q: the request queue for the device
305 * @max_size: max size of segment in bytes 306 * @max_size: max size of segment in bytes
306 * 307 *
307 * Description: 308 * Description:
308 * Enables a low level driver to set an upper limit on the size of a 309 * Enables a low level driver to set an upper limit on the size of a
309 * coalesced segment 310 * coalesced segment
310 **/ 311 **/
311 void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size) 312 void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
312 { 313 {
313 if (max_size < PAGE_CACHE_SIZE) { 314 if (max_size < PAGE_CACHE_SIZE) {
314 max_size = PAGE_CACHE_SIZE; 315 max_size = PAGE_CACHE_SIZE;
315 printk(KERN_INFO "%s: set to minimum %d\n", 316 printk(KERN_INFO "%s: set to minimum %d\n",
316 __func__, max_size); 317 __func__, max_size);
317 } 318 }
318 319
319 q->limits.max_segment_size = max_size; 320 q->limits.max_segment_size = max_size;
320 } 321 }
321 EXPORT_SYMBOL(blk_queue_max_segment_size); 322 EXPORT_SYMBOL(blk_queue_max_segment_size);
322 323
323 /** 324 /**
324 * blk_queue_logical_block_size - set logical block size for the queue 325 * blk_queue_logical_block_size - set logical block size for the queue
325 * @q: the request queue for the device 326 * @q: the request queue for the device
326 * @size: the logical block size, in bytes 327 * @size: the logical block size, in bytes
327 * 328 *
328 * Description: 329 * Description:
329 * This should be set to the lowest possible block size that the 330 * This should be set to the lowest possible block size that the
330 * storage device can address. The default of 512 covers most 331 * storage device can address. The default of 512 covers most
331 * hardware. 332 * hardware.
332 **/ 333 **/
333 void blk_queue_logical_block_size(struct request_queue *q, unsigned short size) 334 void blk_queue_logical_block_size(struct request_queue *q, unsigned short size)
334 { 335 {
335 q->limits.logical_block_size = size; 336 q->limits.logical_block_size = size;
336 337
337 if (q->limits.physical_block_size < size) 338 if (q->limits.physical_block_size < size)
338 q->limits.physical_block_size = size; 339 q->limits.physical_block_size = size;
339 340
340 if (q->limits.io_min < q->limits.physical_block_size) 341 if (q->limits.io_min < q->limits.physical_block_size)
341 q->limits.io_min = q->limits.physical_block_size; 342 q->limits.io_min = q->limits.physical_block_size;
342 } 343 }
343 EXPORT_SYMBOL(blk_queue_logical_block_size); 344 EXPORT_SYMBOL(blk_queue_logical_block_size);
344 345
345 /** 346 /**
346 * blk_queue_physical_block_size - set physical block size for the queue 347 * blk_queue_physical_block_size - set physical block size for the queue
347 * @q: the request queue for the device 348 * @q: the request queue for the device
348 * @size: the physical block size, in bytes 349 * @size: the physical block size, in bytes
349 * 350 *
350 * Description: 351 * Description:
351 * This should be set to the lowest possible sector size that the 352 * This should be set to the lowest possible sector size that the
352 * hardware can operate on without reverting to read-modify-write 353 * hardware can operate on without reverting to read-modify-write
353 * operations. 354 * operations.
354 */ 355 */
355 void blk_queue_physical_block_size(struct request_queue *q, unsigned short size) 356 void blk_queue_physical_block_size(struct request_queue *q, unsigned short size)
356 { 357 {
357 q->limits.physical_block_size = size; 358 q->limits.physical_block_size = size;
358 359
359 if (q->limits.physical_block_size < q->limits.logical_block_size) 360 if (q->limits.physical_block_size < q->limits.logical_block_size)
360 q->limits.physical_block_size = q->limits.logical_block_size; 361 q->limits.physical_block_size = q->limits.logical_block_size;
361 362
362 if (q->limits.io_min < q->limits.physical_block_size) 363 if (q->limits.io_min < q->limits.physical_block_size)
363 q->limits.io_min = q->limits.physical_block_size; 364 q->limits.io_min = q->limits.physical_block_size;
364 } 365 }
365 EXPORT_SYMBOL(blk_queue_physical_block_size); 366 EXPORT_SYMBOL(blk_queue_physical_block_size);
366 367
367 /** 368 /**
368 * blk_queue_alignment_offset - set physical block alignment offset 369 * blk_queue_alignment_offset - set physical block alignment offset
369 * @q: the request queue for the device 370 * @q: the request queue for the device
370 * @offset: alignment offset in bytes 371 * @offset: alignment offset in bytes
371 * 372 *
372 * Description: 373 * Description:
373 * Some devices are naturally misaligned to compensate for things like 374 * Some devices are naturally misaligned to compensate for things like
374 * the legacy DOS partition table 63-sector offset. Low-level drivers 375 * the legacy DOS partition table 63-sector offset. Low-level drivers
375 * should call this function for devices whose first sector is not 376 * should call this function for devices whose first sector is not
376 * naturally aligned. 377 * naturally aligned.
377 */ 378 */
378 void blk_queue_alignment_offset(struct request_queue *q, unsigned int offset) 379 void blk_queue_alignment_offset(struct request_queue *q, unsigned int offset)
379 { 380 {
380 q->limits.alignment_offset = 381 q->limits.alignment_offset =
381 offset & (q->limits.physical_block_size - 1); 382 offset & (q->limits.physical_block_size - 1);
382 q->limits.misaligned = 0; 383 q->limits.misaligned = 0;
383 } 384 }
384 EXPORT_SYMBOL(blk_queue_alignment_offset); 385 EXPORT_SYMBOL(blk_queue_alignment_offset);
385 386
386 /** 387 /**
387 * blk_limits_io_min - set minimum request size for a device 388 * blk_limits_io_min - set minimum request size for a device
388 * @limits: the queue limits 389 * @limits: the queue limits
389 * @min: smallest I/O size in bytes 390 * @min: smallest I/O size in bytes
390 * 391 *
391 * Description: 392 * Description:
392 * Some devices have an internal block size bigger than the reported 393 * Some devices have an internal block size bigger than the reported
393 * hardware sector size. This function can be used to signal the 394 * hardware sector size. This function can be used to signal the
394 * smallest I/O the device can perform without incurring a performance 395 * smallest I/O the device can perform without incurring a performance
395 * penalty. 396 * penalty.
396 */ 397 */
397 void blk_limits_io_min(struct queue_limits *limits, unsigned int min) 398 void blk_limits_io_min(struct queue_limits *limits, unsigned int min)
398 { 399 {
399 limits->io_min = min; 400 limits->io_min = min;
400 401
401 if (limits->io_min < limits->logical_block_size) 402 if (limits->io_min < limits->logical_block_size)
402 limits->io_min = limits->logical_block_size; 403 limits->io_min = limits->logical_block_size;
403 404
404 if (limits->io_min < limits->physical_block_size) 405 if (limits->io_min < limits->physical_block_size)
405 limits->io_min = limits->physical_block_size; 406 limits->io_min = limits->physical_block_size;
406 } 407 }
407 EXPORT_SYMBOL(blk_limits_io_min); 408 EXPORT_SYMBOL(blk_limits_io_min);
408 409
409 /** 410 /**
410 * blk_queue_io_min - set minimum request size for the queue 411 * blk_queue_io_min - set minimum request size for the queue
411 * @q: the request queue for the device 412 * @q: the request queue for the device
412 * @min: smallest I/O size in bytes 413 * @min: smallest I/O size in bytes
413 * 414 *
414 * Description: 415 * Description:
415 * Some devices have an internal block size bigger than the reported 416 * Some devices have an internal block size bigger than the reported
416 * hardware sector size. This function can be used to signal the 417 * hardware sector size. This function can be used to signal the
417 * smallest I/O the device can perform without incurring a performance 418 * smallest I/O the device can perform without incurring a performance
418 * penalty. 419 * penalty.
419 */ 420 */
420 void blk_queue_io_min(struct request_queue *q, unsigned int min) 421 void blk_queue_io_min(struct request_queue *q, unsigned int min)
421 { 422 {
422 blk_limits_io_min(&q->limits, min); 423 blk_limits_io_min(&q->limits, min);
423 } 424 }
424 EXPORT_SYMBOL(blk_queue_io_min); 425 EXPORT_SYMBOL(blk_queue_io_min);
425 426
426 /** 427 /**
427 * blk_queue_io_opt - set optimal request size for the queue 428 * blk_queue_io_opt - set optimal request size for the queue
428 * @q: the request queue for the device 429 * @q: the request queue for the device
429 * @opt: optimal request size in bytes 430 * @opt: optimal request size in bytes
430 * 431 *
431 * Description: 432 * Description:
432 * Drivers can call this function to set the preferred I/O request 433 * Drivers can call this function to set the preferred I/O request
433 * size for devices that report such a value. 434 * size for devices that report such a value.
434 */ 435 */
435 void blk_queue_io_opt(struct request_queue *q, unsigned int opt) 436 void blk_queue_io_opt(struct request_queue *q, unsigned int opt)
436 { 437 {
437 q->limits.io_opt = opt; 438 q->limits.io_opt = opt;
438 } 439 }
439 EXPORT_SYMBOL(blk_queue_io_opt); 440 EXPORT_SYMBOL(blk_queue_io_opt);
440 441
441 /* 442 /*
442 * Returns the minimum that is _not_ zero, unless both are zero. 443 * Returns the minimum that is _not_ zero, unless both are zero.
443 */ 444 */
444 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r)) 445 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
445 446
446 /** 447 /**
447 * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers 448 * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers
448 * @t: the stacking driver (top) 449 * @t: the stacking driver (top)
449 * @b: the underlying device (bottom) 450 * @b: the underlying device (bottom)
450 **/ 451 **/
451 void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b) 452 void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
452 { 453 {
453 blk_stack_limits(&t->limits, &b->limits, 0); 454 blk_stack_limits(&t->limits, &b->limits, 0);
454 455
455 if (!t->queue_lock) 456 if (!t->queue_lock)
456 WARN_ON_ONCE(1); 457 WARN_ON_ONCE(1);
457 else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) { 458 else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
458 unsigned long flags; 459 unsigned long flags;
459 spin_lock_irqsave(t->queue_lock, flags); 460 spin_lock_irqsave(t->queue_lock, flags);
460 queue_flag_clear(QUEUE_FLAG_CLUSTER, t); 461 queue_flag_clear(QUEUE_FLAG_CLUSTER, t);
461 spin_unlock_irqrestore(t->queue_lock, flags); 462 spin_unlock_irqrestore(t->queue_lock, flags);
462 } 463 }
463 } 464 }
464 EXPORT_SYMBOL(blk_queue_stack_limits); 465 EXPORT_SYMBOL(blk_queue_stack_limits);
465 466
466 /** 467 /**
467 * blk_stack_limits - adjust queue_limits for stacked devices 468 * blk_stack_limits - adjust queue_limits for stacked devices
468 * @t: the stacking driver limits (top) 469 * @t: the stacking driver limits (top)
469 * @b: the underlying queue limits (bottom) 470 * @b: the underlying queue limits (bottom)
470 * @offset: offset to beginning of data within component device 471 * @offset: offset to beginning of data within component device
471 * 472 *
472 * Description: 473 * Description:
473 * Merges two queue_limit structs. Returns 0 if alignment didn't 474 * Merges two queue_limit structs. Returns 0 if alignment didn't
474 * change. Returns -1 if adding the bottom device caused 475 * change. Returns -1 if adding the bottom device caused
475 * misalignment. 476 * misalignment.
476 */ 477 */
477 int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, 478 int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
478 sector_t offset) 479 sector_t offset)
479 { 480 {
480 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors); 481 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
481 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors); 482 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
482 t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn); 483 t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn);
483 484
484 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, 485 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask,
485 b->seg_boundary_mask); 486 b->seg_boundary_mask);
486 487
487 t->max_phys_segments = min_not_zero(t->max_phys_segments, 488 t->max_phys_segments = min_not_zero(t->max_phys_segments,
488 b->max_phys_segments); 489 b->max_phys_segments);
489 490
490 t->max_hw_segments = min_not_zero(t->max_hw_segments, 491 t->max_hw_segments = min_not_zero(t->max_hw_segments,
491 b->max_hw_segments); 492 b->max_hw_segments);
492 493
493 t->max_segment_size = min_not_zero(t->max_segment_size, 494 t->max_segment_size = min_not_zero(t->max_segment_size,
494 b->max_segment_size); 495 b->max_segment_size);
495 496
496 t->logical_block_size = max(t->logical_block_size, 497 t->logical_block_size = max(t->logical_block_size,
497 b->logical_block_size); 498 b->logical_block_size);
498 499
499 t->physical_block_size = max(t->physical_block_size, 500 t->physical_block_size = max(t->physical_block_size,
500 b->physical_block_size); 501 b->physical_block_size);
501 502
502 t->io_min = max(t->io_min, b->io_min); 503 t->io_min = max(t->io_min, b->io_min);
503 t->no_cluster |= b->no_cluster; 504 t->no_cluster |= b->no_cluster;
504 505
505 /* Bottom device offset aligned? */ 506 /* Bottom device offset aligned? */
506 if (offset && 507 if (offset &&
507 (offset & (b->physical_block_size - 1)) != b->alignment_offset) { 508 (offset & (b->physical_block_size - 1)) != b->alignment_offset) {
508 t->misaligned = 1; 509 t->misaligned = 1;
509 return -1; 510 return -1;
510 } 511 }
511 512
512 /* If top has no alignment offset, inherit from bottom */ 513 /* If top has no alignment offset, inherit from bottom */
513 if (!t->alignment_offset) 514 if (!t->alignment_offset)
514 t->alignment_offset = 515 t->alignment_offset =
515 b->alignment_offset & (b->physical_block_size - 1); 516 b->alignment_offset & (b->physical_block_size - 1);
516 517
517 /* Top device aligned on logical block boundary? */ 518 /* Top device aligned on logical block boundary? */
518 if (t->alignment_offset & (t->logical_block_size - 1)) { 519 if (t->alignment_offset & (t->logical_block_size - 1)) {
519 t->misaligned = 1; 520 t->misaligned = 1;
520 return -1; 521 return -1;
521 } 522 }
523
524 /* Find lcm() of optimal I/O size */
525 if (t->io_opt && b->io_opt)
526 t->io_opt = (t->io_opt * b->io_opt) / gcd(t->io_opt, b->io_opt);
527 else if (b->io_opt)
528 t->io_opt = b->io_opt;
529
530 /* Verify that optimal I/O size is a multiple of io_min */
531 if (t->io_min && t->io_opt % t->io_min)
532 return -1;
522 533
523 return 0; 534 return 0;
524 } 535 }
525 EXPORT_SYMBOL(blk_stack_limits); 536 EXPORT_SYMBOL(blk_stack_limits);
526 537
527 /** 538 /**
528 * disk_stack_limits - adjust queue limits for stacked drivers 539 * disk_stack_limits - adjust queue limits for stacked drivers
529 * @disk: MD/DM gendisk (top) 540 * @disk: MD/DM gendisk (top)
530 * @bdev: the underlying block device (bottom) 541 * @bdev: the underlying block device (bottom)
531 * @offset: offset to beginning of data within component device 542 * @offset: offset to beginning of data within component device
532 * 543 *
533 * Description: 544 * Description:
534 * Merges the limits for two queues. Returns 0 if alignment 545 * Merges the limits for two queues. Returns 0 if alignment
535 * didn't change. Returns -1 if adding the bottom device caused 546 * didn't change. Returns -1 if adding the bottom device caused
536 * misalignment. 547 * misalignment.
537 */ 548 */
538 void disk_stack_limits(struct gendisk *disk, struct block_device *bdev, 549 void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
539 sector_t offset) 550 sector_t offset)
540 { 551 {
541 struct request_queue *t = disk->queue; 552 struct request_queue *t = disk->queue;
542 struct request_queue *b = bdev_get_queue(bdev); 553 struct request_queue *b = bdev_get_queue(bdev);
543 554
544 offset += get_start_sect(bdev) << 9; 555 offset += get_start_sect(bdev) << 9;
545 556
546 if (blk_stack_limits(&t->limits, &b->limits, offset) < 0) { 557 if (blk_stack_limits(&t->limits, &b->limits, offset) < 0) {
547 char top[BDEVNAME_SIZE], bottom[BDEVNAME_SIZE]; 558 char top[BDEVNAME_SIZE], bottom[BDEVNAME_SIZE];
548 559
549 disk_name(disk, 0, top); 560 disk_name(disk, 0, top);
550 bdevname(bdev, bottom); 561 bdevname(bdev, bottom);
551 562
552 printk(KERN_NOTICE "%s: Warning: Device %s is misaligned\n", 563 printk(KERN_NOTICE "%s: Warning: Device %s is misaligned\n",
553 top, bottom); 564 top, bottom);
554 } 565 }
555 566
556 if (!t->queue_lock) 567 if (!t->queue_lock)
557 WARN_ON_ONCE(1); 568 WARN_ON_ONCE(1);
558 else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) { 569 else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
559 unsigned long flags; 570 unsigned long flags;
560 571
561 spin_lock_irqsave(t->queue_lock, flags); 572 spin_lock_irqsave(t->queue_lock, flags);
562 if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) 573 if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags))
563 queue_flag_clear(QUEUE_FLAG_CLUSTER, t); 574 queue_flag_clear(QUEUE_FLAG_CLUSTER, t);
564 spin_unlock_irqrestore(t->queue_lock, flags); 575 spin_unlock_irqrestore(t->queue_lock, flags);
565 } 576 }
566 } 577 }
567 EXPORT_SYMBOL(disk_stack_limits); 578 EXPORT_SYMBOL(disk_stack_limits);
568 579
569 /** 580 /**
570 * blk_queue_dma_pad - set pad mask 581 * blk_queue_dma_pad - set pad mask
571 * @q: the request queue for the device 582 * @q: the request queue for the device
572 * @mask: pad mask 583 * @mask: pad mask
573 * 584 *
574 * Set dma pad mask. 585 * Set dma pad mask.
575 * 586 *
576 * Appending pad buffer to a request modifies the last entry of a 587 * Appending pad buffer to a request modifies the last entry of a
577 * scatter list such that it includes the pad buffer. 588 * scatter list such that it includes the pad buffer.
578 **/ 589 **/
579 void blk_queue_dma_pad(struct request_queue *q, unsigned int mask) 590 void blk_queue_dma_pad(struct request_queue *q, unsigned int mask)
580 { 591 {
581 q->dma_pad_mask = mask; 592 q->dma_pad_mask = mask;
582 } 593 }
583 EXPORT_SYMBOL(blk_queue_dma_pad); 594 EXPORT_SYMBOL(blk_queue_dma_pad);
584 595
585 /** 596 /**
586 * blk_queue_update_dma_pad - update pad mask 597 * blk_queue_update_dma_pad - update pad mask
587 * @q: the request queue for the device 598 * @q: the request queue for the device
588 * @mask: pad mask 599 * @mask: pad mask
589 * 600 *
590 * Update dma pad mask. 601 * Update dma pad mask.
591 * 602 *
592 * Appending pad buffer to a request modifies the last entry of a 603 * Appending pad buffer to a request modifies the last entry of a
593 * scatter list such that it includes the pad buffer. 604 * scatter list such that it includes the pad buffer.
594 **/ 605 **/
595 void blk_queue_update_dma_pad(struct request_queue *q, unsigned int mask) 606 void blk_queue_update_dma_pad(struct request_queue *q, unsigned int mask)
596 { 607 {
597 if (mask > q->dma_pad_mask) 608 if (mask > q->dma_pad_mask)
598 q->dma_pad_mask = mask; 609 q->dma_pad_mask = mask;
599 } 610 }
600 EXPORT_SYMBOL(blk_queue_update_dma_pad); 611 EXPORT_SYMBOL(blk_queue_update_dma_pad);
601 612
602 /** 613 /**
603 * blk_queue_dma_drain - Set up a drain buffer for excess dma. 614 * blk_queue_dma_drain - Set up a drain buffer for excess dma.
604 * @q: the request queue for the device 615 * @q: the request queue for the device
605 * @dma_drain_needed: fn which returns non-zero if drain is necessary 616 * @dma_drain_needed: fn which returns non-zero if drain is necessary
606 * @buf: physically contiguous buffer 617 * @buf: physically contiguous buffer
607 * @size: size of the buffer in bytes 618 * @size: size of the buffer in bytes
608 * 619 *
609 * Some devices have excess DMA problems and can't simply discard (or 620 * Some devices have excess DMA problems and can't simply discard (or
610 * zero fill) the unwanted piece of the transfer. They have to have a 621 * zero fill) the unwanted piece of the transfer. They have to have a
611 * real area of memory to transfer it into. The use case for this is 622 * real area of memory to transfer it into. The use case for this is
612 * ATAPI devices in DMA mode. If the packet command causes a transfer 623 * ATAPI devices in DMA mode. If the packet command causes a transfer
613 * bigger than the transfer size some HBAs will lock up if there 624 * bigger than the transfer size some HBAs will lock up if there
614 * aren't DMA elements to contain the excess transfer. What this API 625 * aren't DMA elements to contain the excess transfer. What this API
615 * does is adjust the queue so that the buf is always appended 626 * does is adjust the queue so that the buf is always appended
616 * silently to the scatterlist. 627 * silently to the scatterlist.
617 * 628 *
618 * Note: This routine adjusts max_hw_segments to make room for 629 * Note: This routine adjusts max_hw_segments to make room for
619 * appending the drain buffer. If you call 630 * appending the drain buffer. If you call
620 * blk_queue_max_hw_segments() or blk_queue_max_phys_segments() after 631 * blk_queue_max_hw_segments() or blk_queue_max_phys_segments() after
621 * calling this routine, you must set the limit to one fewer than your 632 * calling this routine, you must set the limit to one fewer than your
622 * device can support otherwise there won't be room for the drain 633 * device can support otherwise there won't be room for the drain
623 * buffer. 634 * buffer.
624 */ 635 */
625 int blk_queue_dma_drain(struct request_queue *q, 636 int blk_queue_dma_drain(struct request_queue *q,
626 dma_drain_needed_fn *dma_drain_needed, 637 dma_drain_needed_fn *dma_drain_needed,
627 void *buf, unsigned int size) 638 void *buf, unsigned int size)
628 { 639 {
629 if (queue_max_hw_segments(q) < 2 || queue_max_phys_segments(q) < 2) 640 if (queue_max_hw_segments(q) < 2 || queue_max_phys_segments(q) < 2)
630 return -EINVAL; 641 return -EINVAL;
631 /* make room for appending the drain */ 642 /* make room for appending the drain */
632 blk_queue_max_hw_segments(q, queue_max_hw_segments(q) - 1); 643 blk_queue_max_hw_segments(q, queue_max_hw_segments(q) - 1);
633 blk_queue_max_phys_segments(q, queue_max_phys_segments(q) - 1); 644 blk_queue_max_phys_segments(q, queue_max_phys_segments(q) - 1);
634 q->dma_drain_needed = dma_drain_needed; 645 q->dma_drain_needed = dma_drain_needed;
635 q->dma_drain_buffer = buf; 646 q->dma_drain_buffer = buf;
636 q->dma_drain_size = size; 647 q->dma_drain_size = size;
637 648
638 return 0; 649 return 0;
639 } 650 }
640 EXPORT_SYMBOL_GPL(blk_queue_dma_drain); 651 EXPORT_SYMBOL_GPL(blk_queue_dma_drain);
641 652
642 /** 653 /**
643 * blk_queue_segment_boundary - set boundary rules for segment merging 654 * blk_queue_segment_boundary - set boundary rules for segment merging
644 * @q: the request queue for the device 655 * @q: the request queue for the device
645 * @mask: the memory boundary mask 656 * @mask: the memory boundary mask
646 **/ 657 **/
647 void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask) 658 void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
648 { 659 {
649 if (mask < PAGE_CACHE_SIZE - 1) { 660 if (mask < PAGE_CACHE_SIZE - 1) {
650 mask = PAGE_CACHE_SIZE - 1; 661 mask = PAGE_CACHE_SIZE - 1;
651 printk(KERN_INFO "%s: set to minimum %lx\n", 662 printk(KERN_INFO "%s: set to minimum %lx\n",
652 __func__, mask); 663 __func__, mask);
653 } 664 }
654 665
655 q->limits.seg_boundary_mask = mask; 666 q->limits.seg_boundary_mask = mask;
656 } 667 }
657 EXPORT_SYMBOL(blk_queue_segment_boundary); 668 EXPORT_SYMBOL(blk_queue_segment_boundary);
658 669
659 /** 670 /**
660 * blk_queue_dma_alignment - set dma length and memory alignment 671 * blk_queue_dma_alignment - set dma length and memory alignment
661 * @q: the request queue for the device 672 * @q: the request queue for the device
662 * @mask: alignment mask 673 * @mask: alignment mask
663 * 674 *
664 * description: 675 * description:
665 * set required memory and length alignment for direct dma transactions. 676 * set required memory and length alignment for direct dma transactions.
666 * this is used when building direct io requests for the queue. 677 * this is used when building direct io requests for the queue.
667 * 678 *
668 **/ 679 **/
669 void blk_queue_dma_alignment(struct request_queue *q, int mask) 680 void blk_queue_dma_alignment(struct request_queue *q, int mask)
670 { 681 {
671 q->dma_alignment = mask; 682 q->dma_alignment = mask;
672 } 683 }
673 EXPORT_SYMBOL(blk_queue_dma_alignment); 684 EXPORT_SYMBOL(blk_queue_dma_alignment);
674 685
675 /** 686 /**
676 * blk_queue_update_dma_alignment - update dma length and memory alignment 687 * blk_queue_update_dma_alignment - update dma length and memory alignment
677 * @q: the request queue for the device 688 * @q: the request queue for the device
678 * @mask: alignment mask 689 * @mask: alignment mask
679 * 690 *
680 * description: 691 * description:
681 * update required memory and length alignment for direct dma transactions. 692 * update required memory and length alignment for direct dma transactions.
682 * If the requested alignment is larger than the current alignment, then 693 * If the requested alignment is larger than the current alignment, then
683 * the current queue alignment is updated to the new value, otherwise it 694 * the current queue alignment is updated to the new value, otherwise it
684 * is left alone. The design of this is to allow multiple objects 695 * is left alone. The design of this is to allow multiple objects
685 * (driver, device, transport etc) to set their respective 696 * (driver, device, transport etc) to set their respective
686 * alignments without having them interfere. 697 * alignments without having them interfere.
687 * 698 *
688 **/ 699 **/
689 void blk_queue_update_dma_alignment(struct request_queue *q, int mask) 700 void blk_queue_update_dma_alignment(struct request_queue *q, int mask)
690 { 701 {
691 BUG_ON(mask > PAGE_SIZE); 702 BUG_ON(mask > PAGE_SIZE);
692 703
693 if (mask > q->dma_alignment) 704 if (mask > q->dma_alignment)
694 q->dma_alignment = mask; 705 q->dma_alignment = mask;
695 } 706 }
696 EXPORT_SYMBOL(blk_queue_update_dma_alignment); 707 EXPORT_SYMBOL(blk_queue_update_dma_alignment);
697 708
698 static int __init blk_settings_init(void) 709 static int __init blk_settings_init(void)
699 { 710 {
700 blk_max_low_pfn = max_low_pfn - 1; 711 blk_max_low_pfn = max_low_pfn - 1;
701 blk_max_pfn = max_pfn - 1; 712 blk_max_pfn = max_pfn - 1;
702 return 0; 713 return 0;
703 } 714 }
704 subsys_initcall(blk_settings_init); 715 subsys_initcall(blk_settings_init);
705 716