2 * Functions related to setting various queue properties from drivers
4 #include <linux/kernel.h>
5 #include <linux/module.h>
6 #include <linux/init.h>
8 #include <linux/blkdev.h>
9 #include <linux/bootmem.h> /* for max_pfn/max_low_pfn */
10 #include <linux/gcd.h>
11 #include <linux/lcm.h>
12 #include <linux/jiffies.h>
13 #include <linux/gfp.h>
18 unsigned long blk_max_low_pfn
;
19 EXPORT_SYMBOL(blk_max_low_pfn
);
21 unsigned long blk_max_pfn
;
24 * blk_queue_prep_rq - set a prepare_request function for queue
26 * @pfn: prepare_request function
28 * It's possible for a queue to register a prepare_request callback which
29 * is invoked before the request is handed to the request_fn. The goal of
30 * the function is to prepare a request for I/O, it can be used to build a
31 * cdb from the request data for instance.
34 void blk_queue_prep_rq(struct request_queue
*q
, prep_rq_fn
*pfn
)
38 EXPORT_SYMBOL(blk_queue_prep_rq
);
41 * blk_queue_unprep_rq - set an unprepare_request function for queue
43 * @ufn: unprepare_request function
45 * It's possible for a queue to register an unprepare_request callback
46 * which is invoked before the request is finally completed. The goal
47 * of the function is to deallocate any data that was allocated in the
48 * prepare_request callback.
51 void blk_queue_unprep_rq(struct request_queue
*q
, unprep_rq_fn
*ufn
)
53 q
->unprep_rq_fn
= ufn
;
55 EXPORT_SYMBOL(blk_queue_unprep_rq
);
57 void blk_queue_softirq_done(struct request_queue
*q
, softirq_done_fn
*fn
)
59 q
->softirq_done_fn
= fn
;
61 EXPORT_SYMBOL(blk_queue_softirq_done
);
63 void blk_queue_rq_timeout(struct request_queue
*q
, unsigned int timeout
)
65 q
->rq_timeout
= timeout
;
67 EXPORT_SYMBOL_GPL(blk_queue_rq_timeout
);
69 void blk_queue_rq_timed_out(struct request_queue
*q
, rq_timed_out_fn
*fn
)
71 WARN_ON_ONCE(q
->mq_ops
);
72 q
->rq_timed_out_fn
= fn
;
74 EXPORT_SYMBOL_GPL(blk_queue_rq_timed_out
);
76 void blk_queue_lld_busy(struct request_queue
*q
, lld_busy_fn
*fn
)
80 EXPORT_SYMBOL_GPL(blk_queue_lld_busy
);
83 * blk_set_default_limits - reset limits to default values
84 * @lim: the queue_limits structure to reset
87 * Returns a queue_limit struct to its default state.
89 void blk_set_default_limits(struct queue_limits
*lim
)
91 lim
->max_segments
= BLK_MAX_SEGMENTS
;
92 lim
->max_discard_segments
= 1;
93 lim
->max_integrity_segments
= 0;
94 lim
->seg_boundary_mask
= BLK_SEG_BOUNDARY_MASK
;
95 lim
->virt_boundary_mask
= 0;
96 lim
->max_segment_size
= BLK_MAX_SEGMENT_SIZE
;
97 lim
->max_sectors
= lim
->max_hw_sectors
= BLK_SAFE_MAX_SECTORS
;
98 lim
->max_dev_sectors
= 0;
99 lim
->chunk_sectors
= 0;
100 lim
->max_write_same_sectors
= 0;
101 lim
->max_write_zeroes_sectors
= 0;
102 lim
->max_discard_sectors
= 0;
103 lim
->max_hw_discard_sectors
= 0;
104 lim
->discard_granularity
= 0;
105 lim
->discard_alignment
= 0;
106 lim
->discard_misaligned
= 0;
107 lim
->logical_block_size
= lim
->physical_block_size
= lim
->io_min
= 512;
108 lim
->bounce_pfn
= (unsigned long)(BLK_BOUNCE_ANY
>> PAGE_SHIFT
);
109 lim
->alignment_offset
= 0;
113 lim
->zoned
= BLK_ZONED_NONE
;
115 EXPORT_SYMBOL(blk_set_default_limits
);
118 * blk_set_stacking_limits - set default limits for stacking devices
119 * @lim: the queue_limits structure to reset
122 * Returns a queue_limit struct to its default state. Should be used
123 * by stacking drivers like DM that have no internal limits.
125 void blk_set_stacking_limits(struct queue_limits
*lim
)
127 blk_set_default_limits(lim
);
129 /* Inherit limits from component devices */
130 lim
->max_segments
= USHRT_MAX
;
131 lim
->max_discard_segments
= USHRT_MAX
;
132 lim
->max_hw_sectors
= UINT_MAX
;
133 lim
->max_segment_size
= UINT_MAX
;
134 lim
->max_sectors
= UINT_MAX
;
135 lim
->max_dev_sectors
= UINT_MAX
;
136 lim
->max_write_same_sectors
= UINT_MAX
;
137 lim
->max_write_zeroes_sectors
= UINT_MAX
;
139 EXPORT_SYMBOL(blk_set_stacking_limits
);
142 * blk_queue_make_request - define an alternate make_request function for a device
143 * @q: the request queue for the device to be affected
144 * @mfn: the alternate make_request function
147 * The normal way for &struct bios to be passed to a device
148 * driver is for them to be collected into requests on a request
149 * queue, and then to allow the device driver to select requests
150 * off that queue when it is ready. This works well for many block
151 * devices. However some block devices (typically virtual devices
152 * such as md or lvm) do not benefit from the processing on the
153 * request queue, and are served best by having the requests passed
154 * directly to them. This can be achieved by providing a function
155 * to blk_queue_make_request().
158 * The driver that does this *must* be able to deal appropriately
159 * with buffers in "highmemory". This can be accomplished by either calling
160 * __bio_kmap_atomic() to get a temporary kernel mapping, or by calling
161 * blk_queue_bounce() to create a buffer in normal memory.
163 void blk_queue_make_request(struct request_queue
*q
, make_request_fn
*mfn
)
168 q
->nr_requests
= BLKDEV_MAX_RQ
;
170 q
->make_request_fn
= mfn
;
171 blk_queue_dma_alignment(q
, 511);
172 blk_queue_congestion_threshold(q
);
173 q
->nr_batching
= BLK_BATCH_REQ
;
175 blk_set_default_limits(&q
->limits
);
177 EXPORT_SYMBOL(blk_queue_make_request
);
180 * blk_queue_bounce_limit - set bounce buffer limit for queue
181 * @q: the request queue for the device
182 * @max_addr: the maximum address the device can handle
185 * Different hardware can have different requirements as to what pages
186 * it can do I/O directly to. A low level driver can call
187 * blk_queue_bounce_limit to have lower memory pages allocated as bounce
188 * buffers for doing I/O to pages residing above @max_addr.
190 void blk_queue_bounce_limit(struct request_queue
*q
, u64 max_addr
)
192 unsigned long b_pfn
= max_addr
>> PAGE_SHIFT
;
195 q
->bounce_gfp
= GFP_NOIO
;
196 #if BITS_PER_LONG == 64
198 * Assume anything <= 4GB can be handled by IOMMU. Actually
199 * some IOMMUs can handle everything, but I don't know of a
200 * way to test this here.
202 if (b_pfn
< (min_t(u64
, 0xffffffffUL
, BLK_BOUNCE_HIGH
) >> PAGE_SHIFT
))
204 q
->limits
.bounce_pfn
= max(max_low_pfn
, b_pfn
);
206 if (b_pfn
< blk_max_low_pfn
)
208 q
->limits
.bounce_pfn
= b_pfn
;
211 init_emergency_isa_pool();
212 q
->bounce_gfp
= GFP_NOIO
| GFP_DMA
;
213 q
->limits
.bounce_pfn
= b_pfn
;
216 EXPORT_SYMBOL(blk_queue_bounce_limit
);
219 * blk_queue_max_hw_sectors - set max sectors for a request for this queue
220 * @q: the request queue for the device
221 * @max_hw_sectors: max hardware sectors in the usual 512b unit
224 * Enables a low level driver to set a hard upper limit,
225 * max_hw_sectors, on the size of requests. max_hw_sectors is set by
226 * the device driver based upon the capabilities of the I/O
229 * max_dev_sectors is a hard limit imposed by the storage device for
230 * READ/WRITE requests. It is set by the disk driver.
232 * max_sectors is a soft limit imposed by the block layer for
233 * filesystem type requests. This value can be overridden on a
234 * per-device basis in /sys/block/<device>/queue/max_sectors_kb.
235 * The soft limit can not exceed max_hw_sectors.
237 void blk_queue_max_hw_sectors(struct request_queue
*q
, unsigned int max_hw_sectors
)
239 struct queue_limits
*limits
= &q
->limits
;
240 unsigned int max_sectors
;
242 if ((max_hw_sectors
<< 9) < PAGE_SIZE
) {
243 max_hw_sectors
= 1 << (PAGE_SHIFT
- 9);
244 printk(KERN_INFO
"%s: set to minimum %d\n",
245 __func__
, max_hw_sectors
);
248 limits
->max_hw_sectors
= max_hw_sectors
;
249 max_sectors
= min_not_zero(max_hw_sectors
, limits
->max_dev_sectors
);
250 max_sectors
= min_t(unsigned int, max_sectors
, BLK_DEF_MAX_SECTORS
);
251 limits
->max_sectors
= max_sectors
;
252 q
->backing_dev_info
->io_pages
= max_sectors
>> (PAGE_SHIFT
- 9);
254 EXPORT_SYMBOL(blk_queue_max_hw_sectors
);
257 * blk_queue_chunk_sectors - set size of the chunk for this queue
258 * @q: the request queue for the device
259 * @chunk_sectors: chunk sectors in the usual 512b unit
262 * If a driver doesn't want IOs to cross a given chunk size, it can set
263 * this limit and prevent merging across chunks. Note that the chunk size
264 * must currently be a power-of-2 in sectors. Also note that the block
265 * layer must accept a page worth of data at any offset. So if the
266 * crossing of chunks is a hard limitation in the driver, it must still be
267 * prepared to split single page bios.
269 void blk_queue_chunk_sectors(struct request_queue
*q
, unsigned int chunk_sectors
)
271 BUG_ON(!is_power_of_2(chunk_sectors
));
272 q
->limits
.chunk_sectors
= chunk_sectors
;
274 EXPORT_SYMBOL(blk_queue_chunk_sectors
);
277 * blk_queue_max_discard_sectors - set max sectors for a single discard
278 * @q: the request queue for the device
279 * @max_discard_sectors: maximum number of sectors to discard
281 void blk_queue_max_discard_sectors(struct request_queue
*q
,
282 unsigned int max_discard_sectors
)
284 q
->limits
.max_hw_discard_sectors
= max_discard_sectors
;
285 q
->limits
.max_discard_sectors
= max_discard_sectors
;
287 EXPORT_SYMBOL(blk_queue_max_discard_sectors
);
290 * blk_queue_max_write_same_sectors - set max sectors for a single write same
291 * @q: the request queue for the device
292 * @max_write_same_sectors: maximum number of sectors to write per command
294 void blk_queue_max_write_same_sectors(struct request_queue
*q
,
295 unsigned int max_write_same_sectors
)
297 q
->limits
.max_write_same_sectors
= max_write_same_sectors
;
299 EXPORT_SYMBOL(blk_queue_max_write_same_sectors
);
302 * blk_queue_max_write_zeroes_sectors - set max sectors for a single
304 * @q: the request queue for the device
305 * @max_write_zeroes_sectors: maximum number of sectors to write per command
307 void blk_queue_max_write_zeroes_sectors(struct request_queue
*q
,
308 unsigned int max_write_zeroes_sectors
)
310 q
->limits
.max_write_zeroes_sectors
= max_write_zeroes_sectors
;
312 EXPORT_SYMBOL(blk_queue_max_write_zeroes_sectors
);
315 * blk_queue_max_segments - set max hw segments for a request for this queue
316 * @q: the request queue for the device
317 * @max_segments: max number of segments
320 * Enables a low level driver to set an upper limit on the number of
321 * hw data segments in a request.
323 void blk_queue_max_segments(struct request_queue
*q
, unsigned short max_segments
)
327 printk(KERN_INFO
"%s: set to minimum %d\n",
328 __func__
, max_segments
);
331 q
->limits
.max_segments
= max_segments
;
333 EXPORT_SYMBOL(blk_queue_max_segments
);
336 * blk_queue_max_discard_segments - set max segments for discard requests
337 * @q: the request queue for the device
338 * @max_segments: max number of segments
341 * Enables a low level driver to set an upper limit on the number of
342 * segments in a discard request.
344 void blk_queue_max_discard_segments(struct request_queue
*q
,
345 unsigned short max_segments
)
347 q
->limits
.max_discard_segments
= max_segments
;
349 EXPORT_SYMBOL_GPL(blk_queue_max_discard_segments
);
352 * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
353 * @q: the request queue for the device
354 * @max_size: max size of segment in bytes
357 * Enables a low level driver to set an upper limit on the size of a
360 void blk_queue_max_segment_size(struct request_queue
*q
, unsigned int max_size
)
362 if (max_size
< PAGE_SIZE
) {
363 max_size
= PAGE_SIZE
;
364 printk(KERN_INFO
"%s: set to minimum %d\n",
368 q
->limits
.max_segment_size
= max_size
;
370 EXPORT_SYMBOL(blk_queue_max_segment_size
);
373 * blk_queue_logical_block_size - set logical block size for the queue
374 * @q: the request queue for the device
375 * @size: the logical block size, in bytes
378 * This should be set to the lowest possible block size that the
379 * storage device can address. The default of 512 covers most
382 void blk_queue_logical_block_size(struct request_queue
*q
, unsigned short size
)
384 q
->limits
.logical_block_size
= size
;
386 if (q
->limits
.physical_block_size
< size
)
387 q
->limits
.physical_block_size
= size
;
389 if (q
->limits
.io_min
< q
->limits
.physical_block_size
)
390 q
->limits
.io_min
= q
->limits
.physical_block_size
;
392 EXPORT_SYMBOL(blk_queue_logical_block_size
);
395 * blk_queue_physical_block_size - set physical block size for the queue
396 * @q: the request queue for the device
397 * @size: the physical block size, in bytes
400 * This should be set to the lowest possible sector size that the
401 * hardware can operate on without reverting to read-modify-write
404 void blk_queue_physical_block_size(struct request_queue
*q
, unsigned int size
)
406 q
->limits
.physical_block_size
= size
;
408 if (q
->limits
.physical_block_size
< q
->limits
.logical_block_size
)
409 q
->limits
.physical_block_size
= q
->limits
.logical_block_size
;
411 if (q
->limits
.io_min
< q
->limits
.physical_block_size
)
412 q
->limits
.io_min
= q
->limits
.physical_block_size
;
414 EXPORT_SYMBOL(blk_queue_physical_block_size
);
417 * blk_queue_alignment_offset - set physical block alignment offset
418 * @q: the request queue for the device
419 * @offset: alignment offset in bytes
422 * Some devices are naturally misaligned to compensate for things like
423 * the legacy DOS partition table 63-sector offset. Low-level drivers
424 * should call this function for devices whose first sector is not
427 void blk_queue_alignment_offset(struct request_queue
*q
, unsigned int offset
)
429 q
->limits
.alignment_offset
=
430 offset
& (q
->limits
.physical_block_size
- 1);
431 q
->limits
.misaligned
= 0;
433 EXPORT_SYMBOL(blk_queue_alignment_offset
);
436 * blk_limits_io_min - set minimum request size for a device
437 * @limits: the queue limits
438 * @min: smallest I/O size in bytes
441 * Some devices have an internal block size bigger than the reported
442 * hardware sector size. This function can be used to signal the
443 * smallest I/O the device can perform without incurring a performance
446 void blk_limits_io_min(struct queue_limits
*limits
, unsigned int min
)
448 limits
->io_min
= min
;
450 if (limits
->io_min
< limits
->logical_block_size
)
451 limits
->io_min
= limits
->logical_block_size
;
453 if (limits
->io_min
< limits
->physical_block_size
)
454 limits
->io_min
= limits
->physical_block_size
;
456 EXPORT_SYMBOL(blk_limits_io_min
);
459 * blk_queue_io_min - set minimum request size for the queue
460 * @q: the request queue for the device
461 * @min: smallest I/O size in bytes
464 * Storage devices may report a granularity or preferred minimum I/O
465 * size which is the smallest request the device can perform without
466 * incurring a performance penalty. For disk drives this is often the
467 * physical block size. For RAID arrays it is often the stripe chunk
468 * size. A properly aligned multiple of minimum_io_size is the
469 * preferred request size for workloads where a high number of I/O
470 * operations is desired.
472 void blk_queue_io_min(struct request_queue
*q
, unsigned int min
)
474 blk_limits_io_min(&q
->limits
, min
);
476 EXPORT_SYMBOL(blk_queue_io_min
);
479 * blk_limits_io_opt - set optimal request size for a device
480 * @limits: the queue limits
481 * @opt: smallest I/O size in bytes
484 * Storage devices may report an optimal I/O size, which is the
485 * device's preferred unit for sustained I/O. This is rarely reported
486 * for disk drives. For RAID arrays it is usually the stripe width or
487 * the internal track size. A properly aligned multiple of
488 * optimal_io_size is the preferred request size for workloads where
489 * sustained throughput is desired.
491 void blk_limits_io_opt(struct queue_limits
*limits
, unsigned int opt
)
493 limits
->io_opt
= opt
;
495 EXPORT_SYMBOL(blk_limits_io_opt
);
498 * blk_queue_io_opt - set optimal request size for the queue
499 * @q: the request queue for the device
500 * @opt: optimal request size in bytes
503 * Storage devices may report an optimal I/O size, which is the
504 * device's preferred unit for sustained I/O. This is rarely reported
505 * for disk drives. For RAID arrays it is usually the stripe width or
506 * the internal track size. A properly aligned multiple of
507 * optimal_io_size is the preferred request size for workloads where
508 * sustained throughput is desired.
510 void blk_queue_io_opt(struct request_queue
*q
, unsigned int opt
)
512 blk_limits_io_opt(&q
->limits
, opt
);
514 EXPORT_SYMBOL(blk_queue_io_opt
);
517 * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers
518 * @t: the stacking driver (top)
519 * @b: the underlying device (bottom)
521 void blk_queue_stack_limits(struct request_queue
*t
, struct request_queue
*b
)
523 blk_stack_limits(&t
->limits
, &b
->limits
, 0);
525 EXPORT_SYMBOL(blk_queue_stack_limits
);
528 * blk_stack_limits - adjust queue_limits for stacked devices
529 * @t: the stacking driver limits (top device)
530 * @b: the underlying queue limits (bottom, component device)
531 * @start: first data sector within component device
534 * This function is used by stacking drivers like MD and DM to ensure
535 * that all component devices have compatible block sizes and
536 * alignments. The stacking driver must provide a queue_limits
537 * struct (top) and then iteratively call the stacking function for
538 * all component (bottom) devices. The stacking function will
539 * attempt to combine the values and ensure proper alignment.
541 * Returns 0 if the top and bottom queue_limits are compatible. The
542 * top device's block sizes and alignment offsets may be adjusted to
543 * ensure alignment with the bottom device. If no compatible sizes
544 * and alignments exist, -1 is returned and the resulting top
545 * queue_limits will have the misaligned flag set to indicate that
546 * the alignment_offset is undefined.
548 int blk_stack_limits(struct queue_limits
*t
, struct queue_limits
*b
,
551 unsigned int top
, bottom
, alignment
, ret
= 0;
553 t
->max_sectors
= min_not_zero(t
->max_sectors
, b
->max_sectors
);
554 t
->max_hw_sectors
= min_not_zero(t
->max_hw_sectors
, b
->max_hw_sectors
);
555 t
->max_dev_sectors
= min_not_zero(t
->max_dev_sectors
, b
->max_dev_sectors
);
556 t
->max_write_same_sectors
= min(t
->max_write_same_sectors
,
557 b
->max_write_same_sectors
);
558 t
->max_write_zeroes_sectors
= min(t
->max_write_zeroes_sectors
,
559 b
->max_write_zeroes_sectors
);
560 t
->bounce_pfn
= min_not_zero(t
->bounce_pfn
, b
->bounce_pfn
);
562 t
->seg_boundary_mask
= min_not_zero(t
->seg_boundary_mask
,
563 b
->seg_boundary_mask
);
564 t
->virt_boundary_mask
= min_not_zero(t
->virt_boundary_mask
,
565 b
->virt_boundary_mask
);
567 t
->max_segments
= min_not_zero(t
->max_segments
, b
->max_segments
);
568 t
->max_discard_segments
= min_not_zero(t
->max_discard_segments
,
569 b
->max_discard_segments
);
570 t
->max_integrity_segments
= min_not_zero(t
->max_integrity_segments
,
571 b
->max_integrity_segments
);
573 t
->max_segment_size
= min_not_zero(t
->max_segment_size
,
574 b
->max_segment_size
);
576 t
->misaligned
|= b
->misaligned
;
578 alignment
= queue_limit_alignment_offset(b
, start
);
580 /* Bottom device has different alignment. Check that it is
581 * compatible with the current top alignment.
583 if (t
->alignment_offset
!= alignment
) {
585 top
= max(t
->physical_block_size
, t
->io_min
)
586 + t
->alignment_offset
;
587 bottom
= max(b
->physical_block_size
, b
->io_min
) + alignment
;
589 /* Verify that top and bottom intervals line up */
590 if (max(top
, bottom
) % min(top
, bottom
)) {
596 t
->logical_block_size
= max(t
->logical_block_size
,
597 b
->logical_block_size
);
599 t
->physical_block_size
= max(t
->physical_block_size
,
600 b
->physical_block_size
);
602 t
->io_min
= max(t
->io_min
, b
->io_min
);
603 t
->io_opt
= lcm_not_zero(t
->io_opt
, b
->io_opt
);
605 t
->cluster
&= b
->cluster
;
607 /* Physical block size a multiple of the logical block size? */
608 if (t
->physical_block_size
& (t
->logical_block_size
- 1)) {
609 t
->physical_block_size
= t
->logical_block_size
;
614 /* Minimum I/O a multiple of the physical block size? */
615 if (t
->io_min
& (t
->physical_block_size
- 1)) {
616 t
->io_min
= t
->physical_block_size
;
621 /* Optimal I/O a multiple of the physical block size? */
622 if (t
->io_opt
& (t
->physical_block_size
- 1)) {
628 t
->raid_partial_stripes_expensive
=
629 max(t
->raid_partial_stripes_expensive
,
630 b
->raid_partial_stripes_expensive
);
632 /* Find lowest common alignment_offset */
633 t
->alignment_offset
= lcm_not_zero(t
->alignment_offset
, alignment
)
634 % max(t
->physical_block_size
, t
->io_min
);
636 /* Verify that new alignment_offset is on a logical block boundary */
637 if (t
->alignment_offset
& (t
->logical_block_size
- 1)) {
642 /* Discard alignment and granularity */
643 if (b
->discard_granularity
) {
644 alignment
= queue_limit_discard_alignment(b
, start
);
646 if (t
->discard_granularity
!= 0 &&
647 t
->discard_alignment
!= alignment
) {
648 top
= t
->discard_granularity
+ t
->discard_alignment
;
649 bottom
= b
->discard_granularity
+ alignment
;
651 /* Verify that top and bottom intervals line up */
652 if ((max(top
, bottom
) % min(top
, bottom
)) != 0)
653 t
->discard_misaligned
= 1;
656 t
->max_discard_sectors
= min_not_zero(t
->max_discard_sectors
,
657 b
->max_discard_sectors
);
658 t
->max_hw_discard_sectors
= min_not_zero(t
->max_hw_discard_sectors
,
659 b
->max_hw_discard_sectors
);
660 t
->discard_granularity
= max(t
->discard_granularity
,
661 b
->discard_granularity
);
662 t
->discard_alignment
= lcm_not_zero(t
->discard_alignment
, alignment
) %
663 t
->discard_granularity
;
666 if (b
->chunk_sectors
)
667 t
->chunk_sectors
= min_not_zero(t
->chunk_sectors
,
672 EXPORT_SYMBOL(blk_stack_limits
);
675 * bdev_stack_limits - adjust queue limits for stacked drivers
676 * @t: the stacking driver limits (top device)
677 * @bdev: the component block_device (bottom)
678 * @start: first data sector within component device
681 * Merges queue limits for a top device and a block_device. Returns
682 * 0 if alignment didn't change. Returns -1 if adding the bottom
683 * device caused misalignment.
685 int bdev_stack_limits(struct queue_limits
*t
, struct block_device
*bdev
,
688 struct request_queue
*bq
= bdev_get_queue(bdev
);
690 start
+= get_start_sect(bdev
);
692 return blk_stack_limits(t
, &bq
->limits
, start
);
694 EXPORT_SYMBOL(bdev_stack_limits
);
697 * disk_stack_limits - adjust queue limits for stacked drivers
698 * @disk: MD/DM gendisk (top)
699 * @bdev: the underlying block device (bottom)
700 * @offset: offset to beginning of data within component device
703 * Merges the limits for a top level gendisk and a bottom level
706 void disk_stack_limits(struct gendisk
*disk
, struct block_device
*bdev
,
709 struct request_queue
*t
= disk
->queue
;
711 if (bdev_stack_limits(&t
->limits
, bdev
, offset
>> 9) < 0) {
712 char top
[BDEVNAME_SIZE
], bottom
[BDEVNAME_SIZE
];
714 disk_name(disk
, 0, top
);
715 bdevname(bdev
, bottom
);
717 printk(KERN_NOTICE
"%s: Warning: Device %s is misaligned\n",
721 EXPORT_SYMBOL(disk_stack_limits
);
724 * blk_queue_dma_pad - set pad mask
725 * @q: the request queue for the device
730 * Appending pad buffer to a request modifies the last entry of a
731 * scatter list such that it includes the pad buffer.
733 void blk_queue_dma_pad(struct request_queue
*q
, unsigned int mask
)
735 q
->dma_pad_mask
= mask
;
737 EXPORT_SYMBOL(blk_queue_dma_pad
);
740 * blk_queue_update_dma_pad - update pad mask
741 * @q: the request queue for the device
744 * Update dma pad mask.
746 * Appending pad buffer to a request modifies the last entry of a
747 * scatter list such that it includes the pad buffer.
749 void blk_queue_update_dma_pad(struct request_queue
*q
, unsigned int mask
)
751 if (mask
> q
->dma_pad_mask
)
752 q
->dma_pad_mask
= mask
;
754 EXPORT_SYMBOL(blk_queue_update_dma_pad
);
757 * blk_queue_dma_drain - Set up a drain buffer for excess dma.
758 * @q: the request queue for the device
759 * @dma_drain_needed: fn which returns non-zero if drain is necessary
760 * @buf: physically contiguous buffer
761 * @size: size of the buffer in bytes
763 * Some devices have excess DMA problems and can't simply discard (or
764 * zero fill) the unwanted piece of the transfer. They have to have a
765 * real area of memory to transfer it into. The use case for this is
766 * ATAPI devices in DMA mode. If the packet command causes a transfer
767 * bigger than the transfer size some HBAs will lock up if there
768 * aren't DMA elements to contain the excess transfer. What this API
769 * does is adjust the queue so that the buf is always appended
770 * silently to the scatterlist.
772 * Note: This routine adjusts max_hw_segments to make room for appending
773 * the drain buffer. If you call blk_queue_max_segments() after calling
774 * this routine, you must set the limit to one fewer than your device
775 * can support otherwise there won't be room for the drain buffer.
777 int blk_queue_dma_drain(struct request_queue
*q
,
778 dma_drain_needed_fn
*dma_drain_needed
,
779 void *buf
, unsigned int size
)
781 if (queue_max_segments(q
) < 2)
783 /* make room for appending the drain */
784 blk_queue_max_segments(q
, queue_max_segments(q
) - 1);
785 q
->dma_drain_needed
= dma_drain_needed
;
786 q
->dma_drain_buffer
= buf
;
787 q
->dma_drain_size
= size
;
791 EXPORT_SYMBOL_GPL(blk_queue_dma_drain
);
794 * blk_queue_segment_boundary - set boundary rules for segment merging
795 * @q: the request queue for the device
796 * @mask: the memory boundary mask
798 void blk_queue_segment_boundary(struct request_queue
*q
, unsigned long mask
)
800 if (mask
< PAGE_SIZE
- 1) {
801 mask
= PAGE_SIZE
- 1;
802 printk(KERN_INFO
"%s: set to minimum %lx\n",
806 q
->limits
.seg_boundary_mask
= mask
;
808 EXPORT_SYMBOL(blk_queue_segment_boundary
);
811 * blk_queue_virt_boundary - set boundary rules for bio merging
812 * @q: the request queue for the device
813 * @mask: the memory boundary mask
815 void blk_queue_virt_boundary(struct request_queue
*q
, unsigned long mask
)
817 q
->limits
.virt_boundary_mask
= mask
;
819 EXPORT_SYMBOL(blk_queue_virt_boundary
);
822 * blk_queue_dma_alignment - set dma length and memory alignment
823 * @q: the request queue for the device
824 * @mask: alignment mask
827 * set required memory and length alignment for direct dma transactions.
828 * this is used when building direct io requests for the queue.
831 void blk_queue_dma_alignment(struct request_queue
*q
, int mask
)
833 q
->dma_alignment
= mask
;
835 EXPORT_SYMBOL(blk_queue_dma_alignment
);
838 * blk_queue_update_dma_alignment - update dma length and memory alignment
839 * @q: the request queue for the device
840 * @mask: alignment mask
843 * update required memory and length alignment for direct dma transactions.
844 * If the requested alignment is larger than the current alignment, then
845 * the current queue alignment is updated to the new value, otherwise it
846 * is left alone. The design of this is to allow multiple objects
847 * (driver, device, transport etc) to set their respective
848 * alignments without having them interfere.
851 void blk_queue_update_dma_alignment(struct request_queue
*q
, int mask
)
853 BUG_ON(mask
> PAGE_SIZE
);
855 if (mask
> q
->dma_alignment
)
856 q
->dma_alignment
= mask
;
858 EXPORT_SYMBOL(blk_queue_update_dma_alignment
);
860 void blk_queue_flush_queueable(struct request_queue
*q
, bool queueable
)
862 spin_lock_irq(q
->queue_lock
);
864 clear_bit(QUEUE_FLAG_FLUSH_NQ
, &q
->queue_flags
);
866 set_bit(QUEUE_FLAG_FLUSH_NQ
, &q
->queue_flags
);
867 spin_unlock_irq(q
->queue_lock
);
869 EXPORT_SYMBOL_GPL(blk_queue_flush_queueable
);
872 * blk_set_queue_depth - tell the block layer about the device queue depth
873 * @q: the request queue for the device
874 * @depth: queue depth
877 void blk_set_queue_depth(struct request_queue
*q
, unsigned int depth
)
879 q
->queue_depth
= depth
;
880 wbt_set_queue_depth(q
->rq_wb
, depth
);
882 EXPORT_SYMBOL(blk_set_queue_depth
);
885 * blk_queue_write_cache - configure queue's write cache
886 * @q: the request queue for the device
887 * @wc: write back cache on or off
888 * @fua: device supports FUA writes, if true
890 * Tell the block layer about the write cache of @q.
892 void blk_queue_write_cache(struct request_queue
*q
, bool wc
, bool fua
)
894 spin_lock_irq(q
->queue_lock
);
896 queue_flag_set(QUEUE_FLAG_WC
, q
);
898 queue_flag_clear(QUEUE_FLAG_WC
, q
);
900 queue_flag_set(QUEUE_FLAG_FUA
, q
);
902 queue_flag_clear(QUEUE_FLAG_FUA
, q
);
903 spin_unlock_irq(q
->queue_lock
);
905 wbt_set_write_cache(q
->rq_wb
, test_bit(QUEUE_FLAG_WC
, &q
->queue_flags
));
907 EXPORT_SYMBOL_GPL(blk_queue_write_cache
);
909 static int __init
blk_settings_init(void)
911 blk_max_low_pfn
= max_low_pfn
- 1;
912 blk_max_pfn
= max_pfn
- 1;
915 subsys_initcall(blk_settings_init
);