1 // SPDX-License-Identifier: GPL-2.0
3 * Functions related to setting various queue properties from drivers
5 #include <linux/kernel.h>
6 #include <linux/module.h>
7 #include <linux/init.h>
9 #include <linux/blkdev.h>
10 #include <linux/pagemap.h>
11 #include <linux/backing-dev-defs.h>
12 #include <linux/gcd.h>
13 #include <linux/lcm.h>
14 #include <linux/jiffies.h>
15 #include <linux/gfp.h>
16 #include <linux/dma-mapping.h>
19 #include "blk-rq-qos.h"
22 void blk_queue_rq_timeout(struct request_queue
*q
, unsigned int timeout
)
24 q
->rq_timeout
= timeout
;
26 EXPORT_SYMBOL_GPL(blk_queue_rq_timeout
);
29 * blk_set_default_limits - reset limits to default values
30 * @lim: the queue_limits structure to reset
33 * Returns a queue_limit struct to its default state.
35 void blk_set_default_limits(struct queue_limits
*lim
)
37 lim
->max_segments
= BLK_MAX_SEGMENTS
;
38 lim
->max_discard_segments
= 1;
39 lim
->max_integrity_segments
= 0;
40 lim
->seg_boundary_mask
= BLK_SEG_BOUNDARY_MASK
;
41 lim
->virt_boundary_mask
= 0;
42 lim
->max_segment_size
= BLK_MAX_SEGMENT_SIZE
;
43 lim
->max_sectors
= lim
->max_hw_sectors
= BLK_SAFE_MAX_SECTORS
;
44 lim
->max_user_sectors
= lim
->max_dev_sectors
= 0;
45 lim
->chunk_sectors
= 0;
46 lim
->max_write_zeroes_sectors
= 0;
47 lim
->max_zone_append_sectors
= 0;
48 lim
->max_discard_sectors
= 0;
49 lim
->max_hw_discard_sectors
= 0;
50 lim
->max_secure_erase_sectors
= 0;
51 lim
->discard_granularity
= 0;
52 lim
->discard_alignment
= 0;
53 lim
->discard_misaligned
= 0;
54 lim
->logical_block_size
= lim
->physical_block_size
= lim
->io_min
= 512;
55 lim
->bounce
= BLK_BOUNCE_NONE
;
56 lim
->alignment_offset
= 0;
59 lim
->zoned
= BLK_ZONED_NONE
;
60 lim
->zone_write_granularity
= 0;
61 lim
->dma_alignment
= 511;
65 * blk_set_stacking_limits - set default limits for stacking devices
66 * @lim: the queue_limits structure to reset
69 * Returns a queue_limit struct to its default state. Should be used
70 * by stacking drivers like DM that have no internal limits.
72 void blk_set_stacking_limits(struct queue_limits
*lim
)
74 blk_set_default_limits(lim
);
76 /* Inherit limits from component devices */
77 lim
->max_segments
= USHRT_MAX
;
78 lim
->max_discard_segments
= USHRT_MAX
;
79 lim
->max_hw_sectors
= UINT_MAX
;
80 lim
->max_segment_size
= UINT_MAX
;
81 lim
->max_sectors
= UINT_MAX
;
82 lim
->max_dev_sectors
= UINT_MAX
;
83 lim
->max_write_zeroes_sectors
= UINT_MAX
;
84 lim
->max_zone_append_sectors
= UINT_MAX
;
86 EXPORT_SYMBOL(blk_set_stacking_limits
);
89 * blk_queue_bounce_limit - set bounce buffer limit for queue
90 * @q: the request queue for the device
91 * @bounce: bounce limit to enforce
94 * Force bouncing for ISA DMA ranges or highmem.
96 * DEPRECATED, don't use in new code.
98 void blk_queue_bounce_limit(struct request_queue
*q
, enum blk_bounce bounce
)
100 q
->limits
.bounce
= bounce
;
102 EXPORT_SYMBOL(blk_queue_bounce_limit
);
105 * blk_queue_max_hw_sectors - set max sectors for a request for this queue
106 * @q: the request queue for the device
107 * @max_hw_sectors: max hardware sectors in the usual 512b unit
110 * Enables a low level driver to set a hard upper limit,
111 * max_hw_sectors, on the size of requests. max_hw_sectors is set by
112 * the device driver based upon the capabilities of the I/O
115 * max_dev_sectors is a hard limit imposed by the storage device for
116 * READ/WRITE requests. It is set by the disk driver.
118 * max_sectors is a soft limit imposed by the block layer for
119 * filesystem type requests. This value can be overridden on a
120 * per-device basis in /sys/block/<device>/queue/max_sectors_kb.
121 * The soft limit can not exceed max_hw_sectors.
123 void blk_queue_max_hw_sectors(struct request_queue
*q
, unsigned int max_hw_sectors
)
125 struct queue_limits
*limits
= &q
->limits
;
126 unsigned int max_sectors
;
128 if ((max_hw_sectors
<< 9) < PAGE_SIZE
) {
129 max_hw_sectors
= 1 << (PAGE_SHIFT
- 9);
130 printk(KERN_INFO
"%s: set to minimum %d\n",
131 __func__
, max_hw_sectors
);
134 max_hw_sectors
= round_down(max_hw_sectors
,
135 limits
->logical_block_size
>> SECTOR_SHIFT
);
136 limits
->max_hw_sectors
= max_hw_sectors
;
138 max_sectors
= min_not_zero(max_hw_sectors
, limits
->max_dev_sectors
);
140 if (limits
->max_user_sectors
)
141 max_sectors
= min(max_sectors
, limits
->max_user_sectors
);
143 max_sectors
= min(max_sectors
, BLK_DEF_MAX_SECTORS
);
145 max_sectors
= round_down(max_sectors
,
146 limits
->logical_block_size
>> SECTOR_SHIFT
);
147 limits
->max_sectors
= max_sectors
;
151 q
->disk
->bdi
->io_pages
= max_sectors
>> (PAGE_SHIFT
- 9);
153 EXPORT_SYMBOL(blk_queue_max_hw_sectors
);
156 * blk_queue_chunk_sectors - set size of the chunk for this queue
157 * @q: the request queue for the device
158 * @chunk_sectors: chunk sectors in the usual 512b unit
161 * If a driver doesn't want IOs to cross a given chunk size, it can set
162 * this limit and prevent merging across chunks. Note that the block layer
163 * must accept a page worth of data at any offset. So if the crossing of
164 * chunks is a hard limitation in the driver, it must still be prepared
165 * to split single page bios.
167 void blk_queue_chunk_sectors(struct request_queue
*q
, unsigned int chunk_sectors
)
169 q
->limits
.chunk_sectors
= chunk_sectors
;
171 EXPORT_SYMBOL(blk_queue_chunk_sectors
);
174 * blk_queue_max_discard_sectors - set max sectors for a single discard
175 * @q: the request queue for the device
176 * @max_discard_sectors: maximum number of sectors to discard
178 void blk_queue_max_discard_sectors(struct request_queue
*q
,
179 unsigned int max_discard_sectors
)
181 q
->limits
.max_hw_discard_sectors
= max_discard_sectors
;
182 q
->limits
.max_discard_sectors
= max_discard_sectors
;
184 EXPORT_SYMBOL(blk_queue_max_discard_sectors
);
187 * blk_queue_max_secure_erase_sectors - set max sectors for a secure erase
188 * @q: the request queue for the device
189 * @max_sectors: maximum number of sectors to secure_erase
191 void blk_queue_max_secure_erase_sectors(struct request_queue
*q
,
192 unsigned int max_sectors
)
194 q
->limits
.max_secure_erase_sectors
= max_sectors
;
196 EXPORT_SYMBOL(blk_queue_max_secure_erase_sectors
);
199 * blk_queue_max_write_zeroes_sectors - set max sectors for a single
201 * @q: the request queue for the device
202 * @max_write_zeroes_sectors: maximum number of sectors to write per command
204 void blk_queue_max_write_zeroes_sectors(struct request_queue
*q
,
205 unsigned int max_write_zeroes_sectors
)
207 q
->limits
.max_write_zeroes_sectors
= max_write_zeroes_sectors
;
209 EXPORT_SYMBOL(blk_queue_max_write_zeroes_sectors
);
212 * blk_queue_max_zone_append_sectors - set max sectors for a single zone append
213 * @q: the request queue for the device
214 * @max_zone_append_sectors: maximum number of sectors to write per command
216 void blk_queue_max_zone_append_sectors(struct request_queue
*q
,
217 unsigned int max_zone_append_sectors
)
219 unsigned int max_sectors
;
221 if (WARN_ON(!blk_queue_is_zoned(q
)))
224 max_sectors
= min(q
->limits
.max_hw_sectors
, max_zone_append_sectors
);
225 max_sectors
= min(q
->limits
.chunk_sectors
, max_sectors
);
228 * Signal eventual driver bugs resulting in the max_zone_append sectors limit
229 * being 0 due to a 0 argument, the chunk_sectors limit (zone size) not set,
230 * or the max_hw_sectors limit not set.
232 WARN_ON(!max_sectors
);
234 q
->limits
.max_zone_append_sectors
= max_sectors
;
236 EXPORT_SYMBOL_GPL(blk_queue_max_zone_append_sectors
);
239 * blk_queue_max_segments - set max hw segments for a request for this queue
240 * @q: the request queue for the device
241 * @max_segments: max number of segments
244 * Enables a low level driver to set an upper limit on the number of
245 * hw data segments in a request.
247 void blk_queue_max_segments(struct request_queue
*q
, unsigned short max_segments
)
251 printk(KERN_INFO
"%s: set to minimum %d\n",
252 __func__
, max_segments
);
255 q
->limits
.max_segments
= max_segments
;
257 EXPORT_SYMBOL(blk_queue_max_segments
);
260 * blk_queue_max_discard_segments - set max segments for discard requests
261 * @q: the request queue for the device
262 * @max_segments: max number of segments
265 * Enables a low level driver to set an upper limit on the number of
266 * segments in a discard request.
268 void blk_queue_max_discard_segments(struct request_queue
*q
,
269 unsigned short max_segments
)
271 q
->limits
.max_discard_segments
= max_segments
;
273 EXPORT_SYMBOL_GPL(blk_queue_max_discard_segments
);
276 * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
277 * @q: the request queue for the device
278 * @max_size: max size of segment in bytes
281 * Enables a low level driver to set an upper limit on the size of a
284 void blk_queue_max_segment_size(struct request_queue
*q
, unsigned int max_size
)
286 if (max_size
< PAGE_SIZE
) {
287 max_size
= PAGE_SIZE
;
288 printk(KERN_INFO
"%s: set to minimum %d\n",
292 /* see blk_queue_virt_boundary() for the explanation */
293 WARN_ON_ONCE(q
->limits
.virt_boundary_mask
);
295 q
->limits
.max_segment_size
= max_size
;
297 EXPORT_SYMBOL(blk_queue_max_segment_size
);
300 * blk_queue_logical_block_size - set logical block size for the queue
301 * @q: the request queue for the device
302 * @size: the logical block size, in bytes
305 * This should be set to the lowest possible block size that the
306 * storage device can address. The default of 512 covers most
309 void blk_queue_logical_block_size(struct request_queue
*q
, unsigned int size
)
311 struct queue_limits
*limits
= &q
->limits
;
313 limits
->logical_block_size
= size
;
315 if (limits
->physical_block_size
< size
)
316 limits
->physical_block_size
= size
;
318 if (limits
->io_min
< limits
->physical_block_size
)
319 limits
->io_min
= limits
->physical_block_size
;
321 limits
->max_hw_sectors
=
322 round_down(limits
->max_hw_sectors
, size
>> SECTOR_SHIFT
);
323 limits
->max_sectors
=
324 round_down(limits
->max_sectors
, size
>> SECTOR_SHIFT
);
326 EXPORT_SYMBOL(blk_queue_logical_block_size
);
329 * blk_queue_physical_block_size - set physical block size for the queue
330 * @q: the request queue for the device
331 * @size: the physical block size, in bytes
334 * This should be set to the lowest possible sector size that the
335 * hardware can operate on without reverting to read-modify-write
338 void blk_queue_physical_block_size(struct request_queue
*q
, unsigned int size
)
340 q
->limits
.physical_block_size
= size
;
342 if (q
->limits
.physical_block_size
< q
->limits
.logical_block_size
)
343 q
->limits
.physical_block_size
= q
->limits
.logical_block_size
;
345 if (q
->limits
.io_min
< q
->limits
.physical_block_size
)
346 q
->limits
.io_min
= q
->limits
.physical_block_size
;
348 EXPORT_SYMBOL(blk_queue_physical_block_size
);
351 * blk_queue_zone_write_granularity - set zone write granularity for the queue
352 * @q: the request queue for the zoned device
353 * @size: the zone write granularity size, in bytes
356 * This should be set to the lowest possible size allowing to write in
357 * sequential zones of a zoned block device.
359 void blk_queue_zone_write_granularity(struct request_queue
*q
,
362 if (WARN_ON_ONCE(!blk_queue_is_zoned(q
)))
365 q
->limits
.zone_write_granularity
= size
;
367 if (q
->limits
.zone_write_granularity
< q
->limits
.logical_block_size
)
368 q
->limits
.zone_write_granularity
= q
->limits
.logical_block_size
;
370 EXPORT_SYMBOL_GPL(blk_queue_zone_write_granularity
);
373 * blk_queue_alignment_offset - set physical block alignment offset
374 * @q: the request queue for the device
375 * @offset: alignment offset in bytes
378 * Some devices are naturally misaligned to compensate for things like
379 * the legacy DOS partition table 63-sector offset. Low-level drivers
380 * should call this function for devices whose first sector is not
383 void blk_queue_alignment_offset(struct request_queue
*q
, unsigned int offset
)
385 q
->limits
.alignment_offset
=
386 offset
& (q
->limits
.physical_block_size
- 1);
387 q
->limits
.misaligned
= 0;
389 EXPORT_SYMBOL(blk_queue_alignment_offset
);
391 void disk_update_readahead(struct gendisk
*disk
)
393 struct request_queue
*q
= disk
->queue
;
396 * For read-ahead of large files to be effective, we need to read ahead
397 * at least twice the optimal I/O size.
399 disk
->bdi
->ra_pages
=
400 max(queue_io_opt(q
) * 2 / PAGE_SIZE
, VM_READAHEAD_PAGES
);
401 disk
->bdi
->io_pages
= queue_max_sectors(q
) >> (PAGE_SHIFT
- 9);
403 EXPORT_SYMBOL_GPL(disk_update_readahead
);
406 * blk_limits_io_min - set minimum request size for a device
407 * @limits: the queue limits
408 * @min: smallest I/O size in bytes
411 * Some devices have an internal block size bigger than the reported
412 * hardware sector size. This function can be used to signal the
413 * smallest I/O the device can perform without incurring a performance
416 void blk_limits_io_min(struct queue_limits
*limits
, unsigned int min
)
418 limits
->io_min
= min
;
420 if (limits
->io_min
< limits
->logical_block_size
)
421 limits
->io_min
= limits
->logical_block_size
;
423 if (limits
->io_min
< limits
->physical_block_size
)
424 limits
->io_min
= limits
->physical_block_size
;
426 EXPORT_SYMBOL(blk_limits_io_min
);
429 * blk_queue_io_min - set minimum request size for the queue
430 * @q: the request queue for the device
431 * @min: smallest I/O size in bytes
434 * Storage devices may report a granularity or preferred minimum I/O
435 * size which is the smallest request the device can perform without
436 * incurring a performance penalty. For disk drives this is often the
437 * physical block size. For RAID arrays it is often the stripe chunk
438 * size. A properly aligned multiple of minimum_io_size is the
439 * preferred request size for workloads where a high number of I/O
440 * operations is desired.
442 void blk_queue_io_min(struct request_queue
*q
, unsigned int min
)
444 blk_limits_io_min(&q
->limits
, min
);
446 EXPORT_SYMBOL(blk_queue_io_min
);
449 * blk_limits_io_opt - set optimal request size for a device
450 * @limits: the queue limits
451 * @opt: smallest I/O size in bytes
454 * Storage devices may report an optimal I/O size, which is the
455 * device's preferred unit for sustained I/O. This is rarely reported
456 * for disk drives. For RAID arrays it is usually the stripe width or
457 * the internal track size. A properly aligned multiple of
458 * optimal_io_size is the preferred request size for workloads where
459 * sustained throughput is desired.
461 void blk_limits_io_opt(struct queue_limits
*limits
, unsigned int opt
)
463 limits
->io_opt
= opt
;
465 EXPORT_SYMBOL(blk_limits_io_opt
);
468 * blk_queue_io_opt - set optimal request size for the queue
469 * @q: the request queue for the device
470 * @opt: optimal request size in bytes
473 * Storage devices may report an optimal I/O size, which is the
474 * device's preferred unit for sustained I/O. This is rarely reported
475 * for disk drives. For RAID arrays it is usually the stripe width or
476 * the internal track size. A properly aligned multiple of
477 * optimal_io_size is the preferred request size for workloads where
478 * sustained throughput is desired.
480 void blk_queue_io_opt(struct request_queue
*q
, unsigned int opt
)
482 blk_limits_io_opt(&q
->limits
, opt
);
485 q
->disk
->bdi
->ra_pages
=
486 max(queue_io_opt(q
) * 2 / PAGE_SIZE
, VM_READAHEAD_PAGES
);
488 EXPORT_SYMBOL(blk_queue_io_opt
);
490 static int queue_limit_alignment_offset(const struct queue_limits
*lim
,
493 unsigned int granularity
= max(lim
->physical_block_size
, lim
->io_min
);
494 unsigned int alignment
= sector_div(sector
, granularity
>> SECTOR_SHIFT
)
497 return (granularity
+ lim
->alignment_offset
- alignment
) % granularity
;
500 static unsigned int queue_limit_discard_alignment(
501 const struct queue_limits
*lim
, sector_t sector
)
503 unsigned int alignment
, granularity
, offset
;
505 if (!lim
->max_discard_sectors
)
508 /* Why are these in bytes, not sectors? */
509 alignment
= lim
->discard_alignment
>> SECTOR_SHIFT
;
510 granularity
= lim
->discard_granularity
>> SECTOR_SHIFT
;
514 /* Offset of the partition start in 'granularity' sectors */
515 offset
= sector_div(sector
, granularity
);
517 /* And why do we do this modulus *again* in blkdev_issue_discard()? */
518 offset
= (granularity
+ alignment
- offset
) % granularity
;
520 /* Turn it back into bytes, gaah */
521 return offset
<< SECTOR_SHIFT
;
524 static unsigned int blk_round_down_sectors(unsigned int sectors
, unsigned int lbs
)
526 sectors
= round_down(sectors
, lbs
>> SECTOR_SHIFT
);
527 if (sectors
< PAGE_SIZE
>> SECTOR_SHIFT
)
528 sectors
= PAGE_SIZE
>> SECTOR_SHIFT
;
533 * blk_stack_limits - adjust queue_limits for stacked devices
534 * @t: the stacking driver limits (top device)
535 * @b: the underlying queue limits (bottom, component device)
536 * @start: first data sector within component device
539 * This function is used by stacking drivers like MD and DM to ensure
540 * that all component devices have compatible block sizes and
541 * alignments. The stacking driver must provide a queue_limits
542 * struct (top) and then iteratively call the stacking function for
543 * all component (bottom) devices. The stacking function will
544 * attempt to combine the values and ensure proper alignment.
546 * Returns 0 if the top and bottom queue_limits are compatible. The
547 * top device's block sizes and alignment offsets may be adjusted to
548 * ensure alignment with the bottom device. If no compatible sizes
549 * and alignments exist, -1 is returned and the resulting top
550 * queue_limits will have the misaligned flag set to indicate that
551 * the alignment_offset is undefined.
553 int blk_stack_limits(struct queue_limits
*t
, struct queue_limits
*b
,
556 unsigned int top
, bottom
, alignment
, ret
= 0;
558 t
->max_sectors
= min_not_zero(t
->max_sectors
, b
->max_sectors
);
559 t
->max_hw_sectors
= min_not_zero(t
->max_hw_sectors
, b
->max_hw_sectors
);
560 t
->max_dev_sectors
= min_not_zero(t
->max_dev_sectors
, b
->max_dev_sectors
);
561 t
->max_write_zeroes_sectors
= min(t
->max_write_zeroes_sectors
,
562 b
->max_write_zeroes_sectors
);
563 t
->max_zone_append_sectors
= min(t
->max_zone_append_sectors
,
564 b
->max_zone_append_sectors
);
565 t
->bounce
= max(t
->bounce
, b
->bounce
);
567 t
->seg_boundary_mask
= min_not_zero(t
->seg_boundary_mask
,
568 b
->seg_boundary_mask
);
569 t
->virt_boundary_mask
= min_not_zero(t
->virt_boundary_mask
,
570 b
->virt_boundary_mask
);
572 t
->max_segments
= min_not_zero(t
->max_segments
, b
->max_segments
);
573 t
->max_discard_segments
= min_not_zero(t
->max_discard_segments
,
574 b
->max_discard_segments
);
575 t
->max_integrity_segments
= min_not_zero(t
->max_integrity_segments
,
576 b
->max_integrity_segments
);
578 t
->max_segment_size
= min_not_zero(t
->max_segment_size
,
579 b
->max_segment_size
);
581 t
->misaligned
|= b
->misaligned
;
583 alignment
= queue_limit_alignment_offset(b
, start
);
585 /* Bottom device has different alignment. Check that it is
586 * compatible with the current top alignment.
588 if (t
->alignment_offset
!= alignment
) {
590 top
= max(t
->physical_block_size
, t
->io_min
)
591 + t
->alignment_offset
;
592 bottom
= max(b
->physical_block_size
, b
->io_min
) + alignment
;
594 /* Verify that top and bottom intervals line up */
595 if (max(top
, bottom
) % min(top
, bottom
)) {
601 t
->logical_block_size
= max(t
->logical_block_size
,
602 b
->logical_block_size
);
604 t
->physical_block_size
= max(t
->physical_block_size
,
605 b
->physical_block_size
);
607 t
->io_min
= max(t
->io_min
, b
->io_min
);
608 t
->io_opt
= lcm_not_zero(t
->io_opt
, b
->io_opt
);
609 t
->dma_alignment
= max(t
->dma_alignment
, b
->dma_alignment
);
611 /* Set non-power-of-2 compatible chunk_sectors boundary */
612 if (b
->chunk_sectors
)
613 t
->chunk_sectors
= gcd(t
->chunk_sectors
, b
->chunk_sectors
);
615 /* Physical block size a multiple of the logical block size? */
616 if (t
->physical_block_size
& (t
->logical_block_size
- 1)) {
617 t
->physical_block_size
= t
->logical_block_size
;
622 /* Minimum I/O a multiple of the physical block size? */
623 if (t
->io_min
& (t
->physical_block_size
- 1)) {
624 t
->io_min
= t
->physical_block_size
;
629 /* Optimal I/O a multiple of the physical block size? */
630 if (t
->io_opt
& (t
->physical_block_size
- 1)) {
636 /* chunk_sectors a multiple of the physical block size? */
637 if ((t
->chunk_sectors
<< 9) & (t
->physical_block_size
- 1)) {
638 t
->chunk_sectors
= 0;
643 t
->raid_partial_stripes_expensive
=
644 max(t
->raid_partial_stripes_expensive
,
645 b
->raid_partial_stripes_expensive
);
647 /* Find lowest common alignment_offset */
648 t
->alignment_offset
= lcm_not_zero(t
->alignment_offset
, alignment
)
649 % max(t
->physical_block_size
, t
->io_min
);
651 /* Verify that new alignment_offset is on a logical block boundary */
652 if (t
->alignment_offset
& (t
->logical_block_size
- 1)) {
657 t
->max_sectors
= blk_round_down_sectors(t
->max_sectors
, t
->logical_block_size
);
658 t
->max_hw_sectors
= blk_round_down_sectors(t
->max_hw_sectors
, t
->logical_block_size
);
659 t
->max_dev_sectors
= blk_round_down_sectors(t
->max_dev_sectors
, t
->logical_block_size
);
661 /* Discard alignment and granularity */
662 if (b
->discard_granularity
) {
663 alignment
= queue_limit_discard_alignment(b
, start
);
665 if (t
->discard_granularity
!= 0 &&
666 t
->discard_alignment
!= alignment
) {
667 top
= t
->discard_granularity
+ t
->discard_alignment
;
668 bottom
= b
->discard_granularity
+ alignment
;
670 /* Verify that top and bottom intervals line up */
671 if ((max(top
, bottom
) % min(top
, bottom
)) != 0)
672 t
->discard_misaligned
= 1;
675 t
->max_discard_sectors
= min_not_zero(t
->max_discard_sectors
,
676 b
->max_discard_sectors
);
677 t
->max_hw_discard_sectors
= min_not_zero(t
->max_hw_discard_sectors
,
678 b
->max_hw_discard_sectors
);
679 t
->discard_granularity
= max(t
->discard_granularity
,
680 b
->discard_granularity
);
681 t
->discard_alignment
= lcm_not_zero(t
->discard_alignment
, alignment
) %
682 t
->discard_granularity
;
684 t
->max_secure_erase_sectors
= min_not_zero(t
->max_secure_erase_sectors
,
685 b
->max_secure_erase_sectors
);
686 t
->zone_write_granularity
= max(t
->zone_write_granularity
,
687 b
->zone_write_granularity
);
688 t
->zoned
= max(t
->zoned
, b
->zoned
);
691 EXPORT_SYMBOL(blk_stack_limits
);
694 * disk_stack_limits - adjust queue limits for stacked drivers
695 * @disk: MD/DM gendisk (top)
696 * @bdev: the underlying block device (bottom)
697 * @offset: offset to beginning of data within component device
700 * Merges the limits for a top level gendisk and a bottom level
703 void disk_stack_limits(struct gendisk
*disk
, struct block_device
*bdev
,
706 struct request_queue
*t
= disk
->queue
;
708 if (blk_stack_limits(&t
->limits
, &bdev_get_queue(bdev
)->limits
,
709 get_start_sect(bdev
) + (offset
>> 9)) < 0)
710 pr_notice("%s: Warning: Device %pg is misaligned\n",
711 disk
->disk_name
, bdev
);
713 disk_update_readahead(disk
);
715 EXPORT_SYMBOL(disk_stack_limits
);
718 * blk_queue_update_dma_pad - update pad mask
719 * @q: the request queue for the device
722 * Update dma pad mask.
724 * Appending pad buffer to a request modifies the last entry of a
725 * scatter list such that it includes the pad buffer.
727 void blk_queue_update_dma_pad(struct request_queue
*q
, unsigned int mask
)
729 if (mask
> q
->dma_pad_mask
)
730 q
->dma_pad_mask
= mask
;
732 EXPORT_SYMBOL(blk_queue_update_dma_pad
);
735 * blk_queue_segment_boundary - set boundary rules for segment merging
736 * @q: the request queue for the device
737 * @mask: the memory boundary mask
739 void blk_queue_segment_boundary(struct request_queue
*q
, unsigned long mask
)
741 if (mask
< PAGE_SIZE
- 1) {
742 mask
= PAGE_SIZE
- 1;
743 printk(KERN_INFO
"%s: set to minimum %lx\n",
747 q
->limits
.seg_boundary_mask
= mask
;
749 EXPORT_SYMBOL(blk_queue_segment_boundary
);
752 * blk_queue_virt_boundary - set boundary rules for bio merging
753 * @q: the request queue for the device
754 * @mask: the memory boundary mask
756 void blk_queue_virt_boundary(struct request_queue
*q
, unsigned long mask
)
758 q
->limits
.virt_boundary_mask
= mask
;
761 * Devices that require a virtual boundary do not support scatter/gather
762 * I/O natively, but instead require a descriptor list entry for each
763 * page (which might not be idential to the Linux PAGE_SIZE). Because
764 * of that they are not limited by our notion of "segment size".
767 q
->limits
.max_segment_size
= UINT_MAX
;
769 EXPORT_SYMBOL(blk_queue_virt_boundary
);
772 * blk_queue_dma_alignment - set dma length and memory alignment
773 * @q: the request queue for the device
774 * @mask: alignment mask
777 * set required memory and length alignment for direct dma transactions.
778 * this is used when building direct io requests for the queue.
781 void blk_queue_dma_alignment(struct request_queue
*q
, int mask
)
783 q
->limits
.dma_alignment
= mask
;
785 EXPORT_SYMBOL(blk_queue_dma_alignment
);
788 * blk_queue_update_dma_alignment - update dma length and memory alignment
789 * @q: the request queue for the device
790 * @mask: alignment mask
793 * update required memory and length alignment for direct dma transactions.
794 * If the requested alignment is larger than the current alignment, then
795 * the current queue alignment is updated to the new value, otherwise it
796 * is left alone. The design of this is to allow multiple objects
797 * (driver, device, transport etc) to set their respective
798 * alignments without having them interfere.
801 void blk_queue_update_dma_alignment(struct request_queue
*q
, int mask
)
803 BUG_ON(mask
> PAGE_SIZE
);
805 if (mask
> q
->limits
.dma_alignment
)
806 q
->limits
.dma_alignment
= mask
;
808 EXPORT_SYMBOL(blk_queue_update_dma_alignment
);
811 * blk_set_queue_depth - tell the block layer about the device queue depth
812 * @q: the request queue for the device
813 * @depth: queue depth
816 void blk_set_queue_depth(struct request_queue
*q
, unsigned int depth
)
818 q
->queue_depth
= depth
;
819 rq_qos_queue_depth_changed(q
);
821 EXPORT_SYMBOL(blk_set_queue_depth
);
824 * blk_queue_write_cache - configure queue's write cache
825 * @q: the request queue for the device
826 * @wc: write back cache on or off
827 * @fua: device supports FUA writes, if true
829 * Tell the block layer about the write cache of @q.
831 void blk_queue_write_cache(struct request_queue
*q
, bool wc
, bool fua
)
834 blk_queue_flag_set(QUEUE_FLAG_HW_WC
, q
);
835 blk_queue_flag_set(QUEUE_FLAG_WC
, q
);
837 blk_queue_flag_clear(QUEUE_FLAG_HW_WC
, q
);
838 blk_queue_flag_clear(QUEUE_FLAG_WC
, q
);
841 blk_queue_flag_set(QUEUE_FLAG_FUA
, q
);
843 blk_queue_flag_clear(QUEUE_FLAG_FUA
, q
);
845 wbt_set_write_cache(q
, test_bit(QUEUE_FLAG_WC
, &q
->queue_flags
));
847 EXPORT_SYMBOL_GPL(blk_queue_write_cache
);
850 * blk_queue_required_elevator_features - Set a queue required elevator features
851 * @q: the request queue for the target device
852 * @features: Required elevator features OR'ed together
854 * Tell the block layer that for the device controlled through @q, only the
855 * only elevators that can be used are those that implement at least the set of
856 * features specified by @features.
858 void blk_queue_required_elevator_features(struct request_queue
*q
,
859 unsigned int features
)
861 q
->required_elevator_features
= features
;
863 EXPORT_SYMBOL_GPL(blk_queue_required_elevator_features
);
866 * blk_queue_can_use_dma_map_merging - configure queue for merging segments.
867 * @q: the request queue for the device
868 * @dev: the device pointer for dma
870 * Tell the block layer about merging the segments by dma map of @q.
872 bool blk_queue_can_use_dma_map_merging(struct request_queue
*q
,
875 unsigned long boundary
= dma_get_merge_boundary(dev
);
880 /* No need to update max_segment_size. see blk_queue_virt_boundary() */
881 blk_queue_virt_boundary(q
, boundary
);
885 EXPORT_SYMBOL_GPL(blk_queue_can_use_dma_map_merging
);
887 static bool disk_has_partitions(struct gendisk
*disk
)
890 struct block_device
*part
;
894 xa_for_each(&disk
->part_tbl
, idx
, part
) {
895 if (bdev_is_partition(part
)) {
906 * disk_set_zoned - configure the zoned model for a disk
907 * @disk: the gendisk of the queue to configure
908 * @model: the zoned model to set
910 * Set the zoned model of @disk to @model.
912 * When @model is BLK_ZONED_HM (host managed), this should be called only
913 * if zoned block device support is enabled (CONFIG_BLK_DEV_ZONED option).
914 * If @model specifies BLK_ZONED_HA (host aware), the effective model used
915 * depends on CONFIG_BLK_DEV_ZONED settings and on the existence of partitions
918 void disk_set_zoned(struct gendisk
*disk
, enum blk_zoned_model model
)
920 struct request_queue
*q
= disk
->queue
;
921 unsigned int old_model
= q
->limits
.zoned
;
926 * Host managed devices are supported only if
927 * CONFIG_BLK_DEV_ZONED is enabled.
929 WARN_ON_ONCE(!IS_ENABLED(CONFIG_BLK_DEV_ZONED
));
933 * Host aware devices can be treated either as regular block
934 * devices (similar to drive managed devices) or as zoned block
935 * devices to take advantage of the zone command set, similarly
936 * to host managed devices. We try the latter if there are no
937 * partitions and zoned block device support is enabled, else
938 * we do nothing special as far as the block layer is concerned.
940 if (!IS_ENABLED(CONFIG_BLK_DEV_ZONED
) ||
941 disk_has_partitions(disk
))
942 model
= BLK_ZONED_NONE
;
946 if (WARN_ON_ONCE(model
!= BLK_ZONED_NONE
))
947 model
= BLK_ZONED_NONE
;
951 q
->limits
.zoned
= model
;
952 if (model
!= BLK_ZONED_NONE
) {
954 * Set the zone write granularity to the device logical block
955 * size by default. The driver can change this value if needed.
957 blk_queue_zone_write_granularity(q
,
958 queue_logical_block_size(q
));
959 } else if (old_model
!= BLK_ZONED_NONE
) {
960 disk_clear_zone_settings(disk
);
963 EXPORT_SYMBOL_GPL(disk_set_zoned
);
965 int bdev_alignment_offset(struct block_device
*bdev
)
967 struct request_queue
*q
= bdev_get_queue(bdev
);
969 if (q
->limits
.misaligned
)
971 if (bdev_is_partition(bdev
))
972 return queue_limit_alignment_offset(&q
->limits
,
973 bdev
->bd_start_sect
);
974 return q
->limits
.alignment_offset
;
976 EXPORT_SYMBOL_GPL(bdev_alignment_offset
);
978 unsigned int bdev_discard_alignment(struct block_device
*bdev
)
980 struct request_queue
*q
= bdev_get_queue(bdev
);
982 if (bdev_is_partition(bdev
))
983 return queue_limit_discard_alignment(&q
->limits
,
984 bdev
->bd_start_sect
);
985 return q
->limits
.discard_alignment
;
987 EXPORT_SYMBOL_GPL(bdev_discard_alignment
);