Lines Matching +full:layer +full:- +full:depth
1 // SPDX-License-Identifier: GPL-2.0
9 #include <linux/blk-integrity.h>
11 #include <linux/backing-dev-defs.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/t10-pi.h>
21 #include "blk-rq-qos.h"
22 #include "blk-wbt.h"
26 WRITE_ONCE(q->rq_timeout, timeout); in blk_queue_rq_timeout()
31 * blk_set_stacking_limits - set default limits for stacking devices
40 lim->logical_block_size = SECTOR_SIZE; in blk_set_stacking_limits()
41 lim->physical_block_size = SECTOR_SIZE; in blk_set_stacking_limits()
42 lim->io_min = SECTOR_SIZE; in blk_set_stacking_limits()
43 lim->discard_granularity = SECTOR_SIZE; in blk_set_stacking_limits()
44 lim->dma_alignment = SECTOR_SIZE - 1; in blk_set_stacking_limits()
45 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; in blk_set_stacking_limits()
48 lim->max_segments = USHRT_MAX; in blk_set_stacking_limits()
49 lim->max_discard_segments = USHRT_MAX; in blk_set_stacking_limits()
50 lim->max_hw_sectors = UINT_MAX; in blk_set_stacking_limits()
51 lim->max_segment_size = UINT_MAX; in blk_set_stacking_limits()
52 lim->max_sectors = UINT_MAX; in blk_set_stacking_limits()
53 lim->max_dev_sectors = UINT_MAX; in blk_set_stacking_limits()
54 lim->max_write_zeroes_sectors = UINT_MAX; in blk_set_stacking_limits()
55 lim->max_hw_wzeroes_unmap_sectors = UINT_MAX; in blk_set_stacking_limits()
56 lim->max_user_wzeroes_unmap_sectors = UINT_MAX; in blk_set_stacking_limits()
57 lim->max_hw_zone_append_sectors = UINT_MAX; in blk_set_stacking_limits()
58 lim->max_user_discard_sectors = UINT_MAX; in blk_set_stacking_limits()
59 lim->atomic_write_hw_max = UINT_MAX; in blk_set_stacking_limits()
66 u64 io_opt = lim->io_opt; in blk_apply_bdi_limits()
69 * For read-ahead of large files to be effective, we need to read ahead in blk_apply_bdi_limits()
73 * read-ahead size. in blk_apply_bdi_limits()
75 * There is no hardware limitation for the read-ahead size and the user in blk_apply_bdi_limits()
76 * might have increased the read-ahead size through sysfs, so don't ever in blk_apply_bdi_limits()
79 if (!io_opt && (lim->features & BLK_FEAT_ROTATIONAL)) in blk_apply_bdi_limits()
80 io_opt = (u64)lim->max_sectors << SECTOR_SHIFT; in blk_apply_bdi_limits()
82 bdi->ra_pages = max3(bdi->ra_pages, in blk_apply_bdi_limits()
85 bdi->io_pages = lim->max_sectors >> PAGE_SECTORS_SHIFT; in blk_apply_bdi_limits()
90 if (!(lim->features & BLK_FEAT_ZONED)) { in blk_validate_zoned_limits()
91 if (WARN_ON_ONCE(lim->max_open_zones) || in blk_validate_zoned_limits()
92 WARN_ON_ONCE(lim->max_active_zones) || in blk_validate_zoned_limits()
93 WARN_ON_ONCE(lim->zone_write_granularity) || in blk_validate_zoned_limits()
94 WARN_ON_ONCE(lim->max_zone_append_sectors)) in blk_validate_zoned_limits()
95 return -EINVAL; in blk_validate_zoned_limits()
100 return -EINVAL; in blk_validate_zoned_limits()
106 if (lim->max_active_zones && in blk_validate_zoned_limits()
107 lim->max_open_zones > lim->max_active_zones) in blk_validate_zoned_limits()
108 return -EINVAL; in blk_validate_zoned_limits()
110 if (lim->zone_write_granularity < lim->logical_block_size) in blk_validate_zoned_limits()
111 lim->zone_write_granularity = lim->logical_block_size; in blk_validate_zoned_limits()
117 * If no max_hw_zone_append_sectors limit is provided, the block layer in blk_validate_zoned_limits()
120 lim->max_zone_append_sectors = in blk_validate_zoned_limits()
121 min_not_zero(lim->max_hw_zone_append_sectors, in blk_validate_zoned_limits()
122 min(lim->chunk_sectors, lim->max_hw_sectors)); in blk_validate_zoned_limits()
127 * Maximum size of I/O that needs a block layer integrity buffer. Limited
134 return min_t(unsigned int, lim->max_segment_size, in max_integrity_io_size()
135 (BLK_INTEGRITY_MAX_SIZE / lim->integrity.metadata_size) << in max_integrity_io_size()
136 lim->integrity.interval_exp); in max_integrity_io_size()
141 struct blk_integrity *bi = &lim->integrity; in blk_validate_integrity_limits()
143 if (!bi->metadata_size) { in blk_validate_integrity_limits()
144 if (bi->csum_type != BLK_INTEGRITY_CSUM_NONE || in blk_validate_integrity_limits()
145 bi->tag_size || ((bi->flags & BLK_INTEGRITY_REF_TAG))) { in blk_validate_integrity_limits()
147 return -EINVAL; in blk_validate_integrity_limits()
149 bi->flags |= BLK_INTEGRITY_NOGENERATE | BLK_INTEGRITY_NOVERIFY; in blk_validate_integrity_limits()
155 return -EINVAL; in blk_validate_integrity_limits()
158 if (bi->csum_type == BLK_INTEGRITY_CSUM_NONE && in blk_validate_integrity_limits()
159 (bi->flags & BLK_INTEGRITY_REF_TAG)) { in blk_validate_integrity_limits()
161 return -EINVAL; in blk_validate_integrity_limits()
164 if (bi->pi_tuple_size > bi->metadata_size) { in blk_validate_integrity_limits()
166 bi->pi_tuple_size, in blk_validate_integrity_limits()
167 bi->metadata_size); in blk_validate_integrity_limits()
168 return -EINVAL; in blk_validate_integrity_limits()
171 switch (bi->csum_type) { in blk_validate_integrity_limits()
173 if (bi->pi_tuple_size) { in blk_validate_integrity_limits()
175 return -EINVAL; in blk_validate_integrity_limits()
180 if (bi->pi_tuple_size != sizeof(struct t10_pi_tuple)) { in blk_validate_integrity_limits()
183 bi->pi_tuple_size); in blk_validate_integrity_limits()
184 return -EINVAL; in blk_validate_integrity_limits()
188 if (bi->pi_tuple_size != sizeof(struct crc64_pi_tuple)) { in blk_validate_integrity_limits()
191 bi->pi_tuple_size); in blk_validate_integrity_limits()
192 return -EINVAL; in blk_validate_integrity_limits()
197 if (!bi->interval_exp) in blk_validate_integrity_limits()
198 bi->interval_exp = ilog2(lim->logical_block_size); in blk_validate_integrity_limits()
205 if (bi->csum_type) { in blk_validate_integrity_limits()
206 lim->dma_alignment = max(lim->dma_alignment, in blk_validate_integrity_limits()
207 (1U << bi->interval_exp) - 1); in blk_validate_integrity_limits()
211 * The block layer automatically adds integrity data for bios that don't in blk_validate_integrity_limits()
215 lim->max_sectors = min(lim->max_sectors, in blk_validate_integrity_limits()
230 unsigned int max_segments = min(BIO_MAX_VECS, lim->max_segments); in blk_queue_max_guaranteed_bio()
233 length = min(max_segments, 2) * lim->logical_block_size; in blk_queue_max_guaranteed_bio()
235 length += (max_segments - 2) * PAGE_SIZE; in blk_queue_max_guaranteed_bio()
242 unsigned int unit_limit = min(lim->max_hw_sectors << SECTOR_SHIFT, in blk_atomic_writes_update_limits()
247 lim->atomic_write_max_sectors = in blk_atomic_writes_update_limits()
248 min(lim->atomic_write_hw_max >> SECTOR_SHIFT, in blk_atomic_writes_update_limits()
249 lim->max_hw_sectors); in blk_atomic_writes_update_limits()
250 lim->atomic_write_unit_min = in blk_atomic_writes_update_limits()
251 min(lim->atomic_write_hw_unit_min, unit_limit); in blk_atomic_writes_update_limits()
252 lim->atomic_write_unit_max = in blk_atomic_writes_update_limits()
253 min(lim->atomic_write_hw_unit_max, unit_limit); in blk_atomic_writes_update_limits()
254 lim->atomic_write_boundary_sectors = in blk_atomic_writes_update_limits()
255 lim->atomic_write_hw_boundary >> SECTOR_SHIFT; in blk_atomic_writes_update_limits()
260 * devices store any stripe size in t->chunk_sectors.
283 lim->atomic_write_hw_max >> SECTOR_SHIFT; in blk_validate_atomic_write_limits()
285 if (!(lim->features & BLK_FEAT_ATOMIC_WRITES)) in blk_validate_atomic_write_limits()
289 if (lim->atomic_write_hw_max == UINT_MAX) in blk_validate_atomic_write_limits()
292 if (!lim->atomic_write_hw_max) in blk_validate_atomic_write_limits()
295 if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_min))) in blk_validate_atomic_write_limits()
298 if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_max))) in blk_validate_atomic_write_limits()
301 if (WARN_ON_ONCE(lim->atomic_write_hw_unit_min > in blk_validate_atomic_write_limits()
302 lim->atomic_write_hw_unit_max)) in blk_validate_atomic_write_limits()
305 if (WARN_ON_ONCE(lim->atomic_write_hw_unit_max > in blk_validate_atomic_write_limits()
306 lim->atomic_write_hw_max)) in blk_validate_atomic_write_limits()
309 if (WARN_ON_ONCE(lim->chunk_sectors && in blk_validate_atomic_write_limits()
310 atomic_write_hw_max_sectors > lim->chunk_sectors)) in blk_validate_atomic_write_limits()
313 boundary_sectors = lim->atomic_write_hw_boundary >> SECTOR_SHIFT; in blk_validate_atomic_write_limits()
316 if (WARN_ON_ONCE(lim->atomic_write_hw_max > in blk_validate_atomic_write_limits()
317 lim->atomic_write_hw_boundary)) in blk_validate_atomic_write_limits()
321 lim->chunk_sectors, boundary_sectors))) in blk_validate_atomic_write_limits()
326 * (and not necessarily a power-of-2), so this following check in blk_validate_atomic_write_limits()
329 * that it is compliant with a !power-of-2 boundary. in blk_validate_atomic_write_limits()
339 lim->atomic_write_max_sectors = 0; in blk_validate_atomic_write_limits()
340 lim->atomic_write_boundary_sectors = 0; in blk_validate_atomic_write_limits()
341 lim->atomic_write_unit_min = 0; in blk_validate_atomic_write_limits()
342 lim->atomic_write_unit_max = 0; in blk_validate_atomic_write_limits()
360 if (!lim->logical_block_size) in blk_validate_limits()
361 lim->logical_block_size = SECTOR_SIZE; in blk_validate_limits()
362 else if (blk_validate_block_size(lim->logical_block_size)) { in blk_validate_limits()
363 pr_warn("Invalid logical block size (%d)\n", lim->logical_block_size); in blk_validate_limits()
364 return -EINVAL; in blk_validate_limits()
366 if (lim->physical_block_size < lim->logical_block_size) { in blk_validate_limits()
367 lim->physical_block_size = lim->logical_block_size; in blk_validate_limits()
368 } else if (!is_power_of_2(lim->physical_block_size)) { in blk_validate_limits()
369 pr_warn("Invalid physical block size (%d)\n", lim->physical_block_size); in blk_validate_limits()
370 return -EINVAL; in blk_validate_limits()
377 if (lim->io_min < lim->physical_block_size) in blk_validate_limits()
378 lim->io_min = lim->physical_block_size; in blk_validate_limits()
385 lim->io_opt = round_down(lim->io_opt, lim->physical_block_size); in blk_validate_limits()
392 * The block layer relies on the fact that every driver can in blk_validate_limits()
396 if (!lim->max_hw_sectors) in blk_validate_limits()
397 lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS; in blk_validate_limits()
398 if (WARN_ON_ONCE(lim->max_hw_sectors < PAGE_SECTORS)) in blk_validate_limits()
399 return -EINVAL; in blk_validate_limits()
400 logical_block_sectors = lim->logical_block_size >> SECTOR_SHIFT; in blk_validate_limits()
401 if (WARN_ON_ONCE(logical_block_sectors > lim->max_hw_sectors)) in blk_validate_limits()
402 return -EINVAL; in blk_validate_limits()
403 lim->max_hw_sectors = round_down(lim->max_hw_sectors, in blk_validate_limits()
409 * value into account. The ->max_sectors value is always calculated in blk_validate_limits()
412 max_hw_sectors = min_not_zero(lim->max_hw_sectors, in blk_validate_limits()
413 lim->max_dev_sectors); in blk_validate_limits()
414 if (lim->max_user_sectors) { in blk_validate_limits()
415 if (lim->max_user_sectors < BLK_MIN_SEGMENT_SIZE / SECTOR_SIZE) in blk_validate_limits()
416 return -EINVAL; in blk_validate_limits()
417 lim->max_sectors = min(max_hw_sectors, lim->max_user_sectors); in blk_validate_limits()
418 } else if (lim->io_opt > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) { in blk_validate_limits()
419 lim->max_sectors = in blk_validate_limits()
420 min(max_hw_sectors, lim->io_opt >> SECTOR_SHIFT); in blk_validate_limits()
421 } else if (lim->io_min > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) { in blk_validate_limits()
422 lim->max_sectors = in blk_validate_limits()
423 min(max_hw_sectors, lim->io_min >> SECTOR_SHIFT); in blk_validate_limits()
425 lim->max_sectors = min(max_hw_sectors, BLK_DEF_MAX_SECTORS_CAP); in blk_validate_limits()
427 lim->max_sectors = round_down(lim->max_sectors, in blk_validate_limits()
434 if (!lim->max_segments) in blk_validate_limits()
435 lim->max_segments = BLK_MAX_SEGMENTS; in blk_validate_limits()
437 if (lim->max_hw_wzeroes_unmap_sectors && in blk_validate_limits()
438 lim->max_hw_wzeroes_unmap_sectors != lim->max_write_zeroes_sectors) in blk_validate_limits()
439 return -EINVAL; in blk_validate_limits()
440 lim->max_wzeroes_unmap_sectors = min(lim->max_hw_wzeroes_unmap_sectors, in blk_validate_limits()
441 lim->max_user_wzeroes_unmap_sectors); in blk_validate_limits()
443 lim->max_discard_sectors = in blk_validate_limits()
444 min(lim->max_hw_discard_sectors, lim->max_user_discard_sectors); in blk_validate_limits()
450 if (lim->max_discard_sectors) in blk_validate_limits()
451 lim->discard_granularity = in blk_validate_limits()
452 max(lim->discard_granularity, lim->physical_block_size); in blk_validate_limits()
454 lim->discard_granularity = 0; in blk_validate_limits()
456 if (!lim->max_discard_segments) in blk_validate_limits()
457 lim->max_discard_segments = 1; in blk_validate_limits()
464 if (!lim->seg_boundary_mask) in blk_validate_limits()
465 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; in blk_validate_limits()
466 if (WARN_ON_ONCE(lim->seg_boundary_mask < BLK_MIN_SEGMENT_SIZE - 1)) in blk_validate_limits()
467 return -EINVAL; in blk_validate_limits()
471 * size limit, so allow this setting now, and long-term the two in blk_validate_limits()
473 * bvec and lower layer bio splitting is supposed to handle the two in blk_validate_limits()
476 if (lim->virt_boundary_mask) { in blk_validate_limits()
477 if (!lim->max_segment_size) in blk_validate_limits()
478 lim->max_segment_size = UINT_MAX; in blk_validate_limits()
485 if (!lim->max_segment_size) in blk_validate_limits()
486 lim->max_segment_size = BLK_MAX_SEGMENT_SIZE; in blk_validate_limits()
487 if (WARN_ON_ONCE(lim->max_segment_size < BLK_MIN_SEGMENT_SIZE)) in blk_validate_limits()
488 return -EINVAL; in blk_validate_limits()
492 if (lim->seg_boundary_mask > lim->max_segment_size - 1) in blk_validate_limits()
493 seg_size = lim->max_segment_size; in blk_validate_limits()
495 seg_size = lim->seg_boundary_mask + 1; in blk_validate_limits()
496 lim->max_fast_segment_size = min_t(unsigned int, seg_size, PAGE_SIZE); in blk_validate_limits()
504 if (!lim->dma_alignment) in blk_validate_limits()
505 lim->dma_alignment = SECTOR_SIZE - 1; in blk_validate_limits()
506 if (WARN_ON_ONCE(lim->dma_alignment > PAGE_SIZE)) in blk_validate_limits()
507 return -EINVAL; in blk_validate_limits()
509 if (lim->alignment_offset) { in blk_validate_limits()
510 lim->alignment_offset &= (lim->physical_block_size - 1); in blk_validate_limits()
511 lim->flags &= ~BLK_FLAG_MISALIGNED; in blk_validate_limits()
514 if (!(lim->features & BLK_FEAT_WRITE_CACHE)) in blk_validate_limits()
515 lim->features &= ~BLK_FEAT_FUA; in blk_validate_limits()
538 lim->max_user_discard_sectors = UINT_MAX; in blk_set_default_limits()
539 lim->max_user_wzeroes_unmap_sectors = UINT_MAX; in blk_set_default_limits()
544 * queue_limits_commit_update - commit an atomic update of queue limits
559 lockdep_assert_held(&q->limits_lock); in queue_limits_commit_update()
566 if (q->crypto_profile && lim->integrity.tag_size) { in queue_limits_commit_update()
567 pr_warn("blk-integrity: Integrity and hardware inline encryption are not supported together.\n"); in queue_limits_commit_update()
568 error = -EINVAL; in queue_limits_commit_update()
573 q->limits = *lim; in queue_limits_commit_update()
574 if (q->disk) in queue_limits_commit_update()
575 blk_apply_bdi_limits(q->disk->bdi, lim); in queue_limits_commit_update()
577 mutex_unlock(&q->limits_lock); in queue_limits_commit_update()
583 * queue_limits_commit_update_frozen - commit an atomic update of queue limits
608 * queue_limits_set - apply queue limits to queue
620 mutex_lock(&q->limits_lock); in queue_limits_set()
628 unsigned int granularity = max(lim->physical_block_size, lim->io_min); in queue_limit_alignment_offset()
632 return (granularity + lim->alignment_offset - alignment) % granularity; in queue_limit_alignment_offset()
640 if (!lim->max_discard_sectors) in queue_limit_discard_alignment()
644 alignment = lim->discard_alignment >> SECTOR_SHIFT; in queue_limit_discard_alignment()
645 granularity = lim->discard_granularity >> SECTOR_SHIFT; in queue_limit_discard_alignment()
651 offset = (granularity + alignment - offset) % granularity; in queue_limit_discard_alignment()
670 if (t->atomic_write_hw_boundary != b->atomic_write_hw_boundary) in blk_stack_atomic_writes_tail()
674 if (t->atomic_write_hw_unit_min > b->atomic_write_hw_unit_max) in blk_stack_atomic_writes_tail()
678 if (t->atomic_write_hw_unit_max < b->atomic_write_hw_unit_min) in blk_stack_atomic_writes_tail()
681 t->atomic_write_hw_max = min(t->atomic_write_hw_max, in blk_stack_atomic_writes_tail()
682 b->atomic_write_hw_max); in blk_stack_atomic_writes_tail()
683 t->atomic_write_hw_unit_min = max(t->atomic_write_hw_unit_min, in blk_stack_atomic_writes_tail()
684 b->atomic_write_hw_unit_min); in blk_stack_atomic_writes_tail()
685 t->atomic_write_hw_unit_max = min(t->atomic_write_hw_unit_max, in blk_stack_atomic_writes_tail()
686 b->atomic_write_hw_unit_max); in blk_stack_atomic_writes_tail()
694 if (!t->chunk_sectors) in blk_stack_atomic_writes_chunk_sectors()
702 if (check_shl_overflow(t->chunk_sectors, SECTOR_SHIFT, &chunk_bytes)) in blk_stack_atomic_writes_chunk_sectors()
703 chunk_bytes = t->chunk_sectors; in blk_stack_atomic_writes_chunk_sectors()
707 * b->atomic_write_hw_unit_{min, max} may not be aligned with chunk in blk_stack_atomic_writes_chunk_sectors()
708 * size, as the chunk size is not restricted to a power-of-2. in blk_stack_atomic_writes_chunk_sectors()
709 * So we need to find highest power-of-2 which works for the chunk in blk_stack_atomic_writes_chunk_sectors()
711 * As an example scenario, we could have t->unit_max = 16K and in blk_stack_atomic_writes_chunk_sectors()
712 * t->chunk_sectors = 24KB. For this case, reduce t->unit_max to a in blk_stack_atomic_writes_chunk_sectors()
715 t->atomic_write_hw_unit_max = min(t->atomic_write_hw_unit_max, in blk_stack_atomic_writes_chunk_sectors()
718 t->atomic_write_hw_unit_min = min(t->atomic_write_hw_unit_min, in blk_stack_atomic_writes_chunk_sectors()
719 t->atomic_write_hw_unit_max); in blk_stack_atomic_writes_chunk_sectors()
720 t->atomic_write_hw_max = min(t->atomic_write_hw_max, chunk_bytes); in blk_stack_atomic_writes_chunk_sectors()
727 if (!blk_valid_atomic_writes_boundary(t->chunk_sectors, in blk_stack_atomic_writes_head()
728 b->atomic_write_hw_boundary >> SECTOR_SHIFT)) in blk_stack_atomic_writes_head()
731 t->atomic_write_hw_unit_max = b->atomic_write_hw_unit_max; in blk_stack_atomic_writes_head()
732 t->atomic_write_hw_unit_min = b->atomic_write_hw_unit_min; in blk_stack_atomic_writes_head()
733 t->atomic_write_hw_max = b->atomic_write_hw_max; in blk_stack_atomic_writes_head()
734 t->atomic_write_hw_boundary = b->atomic_write_hw_boundary; in blk_stack_atomic_writes_head()
741 if (!(b->features & BLK_FEAT_ATOMIC_WRITES)) in blk_stack_atomic_writes_limits()
744 if (!b->atomic_write_hw_unit_min) in blk_stack_atomic_writes_limits()
751 if (t->atomic_write_hw_max == UINT_MAX) { in blk_stack_atomic_writes_limits()
762 t->atomic_write_hw_max = 0; in blk_stack_atomic_writes_limits()
763 t->atomic_write_hw_unit_max = 0; in blk_stack_atomic_writes_limits()
764 t->atomic_write_hw_unit_min = 0; in blk_stack_atomic_writes_limits()
765 t->atomic_write_hw_boundary = 0; in blk_stack_atomic_writes_limits()
769 * blk_stack_limits - adjust queue_limits for stacked devices
785 * and alignments exist, -1 is returned and the resulting top
795 t->features |= (b->features & BLK_FEAT_INHERIT_MASK); in blk_stack_limits()
803 if (!(b->features & BLK_FEAT_NOWAIT)) in blk_stack_limits()
804 t->features &= ~BLK_FEAT_NOWAIT; in blk_stack_limits()
805 if (!(b->features & BLK_FEAT_POLL)) in blk_stack_limits()
806 t->features &= ~BLK_FEAT_POLL; in blk_stack_limits()
808 t->flags |= (b->flags & BLK_FLAG_MISALIGNED); in blk_stack_limits()
810 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors); in blk_stack_limits()
811 t->max_user_sectors = min_not_zero(t->max_user_sectors, in blk_stack_limits()
812 b->max_user_sectors); in blk_stack_limits()
813 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors); in blk_stack_limits()
814 t->max_dev_sectors = min_not_zero(t->max_dev_sectors, b->max_dev_sectors); in blk_stack_limits()
815 t->max_write_zeroes_sectors = min(t->max_write_zeroes_sectors, in blk_stack_limits()
816 b->max_write_zeroes_sectors); in blk_stack_limits()
817 t->max_user_wzeroes_unmap_sectors = in blk_stack_limits()
818 min(t->max_user_wzeroes_unmap_sectors, in blk_stack_limits()
819 b->max_user_wzeroes_unmap_sectors); in blk_stack_limits()
820 t->max_hw_wzeroes_unmap_sectors = in blk_stack_limits()
821 min(t->max_hw_wzeroes_unmap_sectors, in blk_stack_limits()
822 b->max_hw_wzeroes_unmap_sectors); in blk_stack_limits()
824 t->max_hw_zone_append_sectors = min(t->max_hw_zone_append_sectors, in blk_stack_limits()
825 b->max_hw_zone_append_sectors); in blk_stack_limits()
827 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, in blk_stack_limits()
828 b->seg_boundary_mask); in blk_stack_limits()
829 t->virt_boundary_mask = min_not_zero(t->virt_boundary_mask, in blk_stack_limits()
830 b->virt_boundary_mask); in blk_stack_limits()
832 t->max_segments = min_not_zero(t->max_segments, b->max_segments); in blk_stack_limits()
833 t->max_discard_segments = min_not_zero(t->max_discard_segments, in blk_stack_limits()
834 b->max_discard_segments); in blk_stack_limits()
835 t->max_integrity_segments = min_not_zero(t->max_integrity_segments, in blk_stack_limits()
836 b->max_integrity_segments); in blk_stack_limits()
838 t->max_segment_size = min_not_zero(t->max_segment_size, in blk_stack_limits()
839 b->max_segment_size); in blk_stack_limits()
846 if (t->alignment_offset != alignment) { in blk_stack_limits()
848 top = max(t->physical_block_size, t->io_min) in blk_stack_limits()
849 + t->alignment_offset; in blk_stack_limits()
850 bottom = max(b->physical_block_size, b->io_min) + alignment; in blk_stack_limits()
854 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
855 ret = -1; in blk_stack_limits()
859 t->logical_block_size = max(t->logical_block_size, in blk_stack_limits()
860 b->logical_block_size); in blk_stack_limits()
862 t->physical_block_size = max(t->physical_block_size, in blk_stack_limits()
863 b->physical_block_size); in blk_stack_limits()
865 t->io_min = max(t->io_min, b->io_min); in blk_stack_limits()
866 t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); in blk_stack_limits()
867 t->dma_alignment = max(t->dma_alignment, b->dma_alignment); in blk_stack_limits()
869 /* Set non-power-of-2 compatible chunk_sectors boundary */ in blk_stack_limits()
870 if (b->chunk_sectors) in blk_stack_limits()
871 t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); in blk_stack_limits()
874 if (t->physical_block_size & (t->logical_block_size - 1)) { in blk_stack_limits()
875 t->physical_block_size = t->logical_block_size; in blk_stack_limits()
876 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
877 ret = -1; in blk_stack_limits()
881 if (t->io_min & (t->physical_block_size - 1)) { in blk_stack_limits()
882 t->io_min = t->physical_block_size; in blk_stack_limits()
883 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
884 ret = -1; in blk_stack_limits()
888 if (t->io_opt & (t->physical_block_size - 1)) { in blk_stack_limits()
889 t->io_opt = 0; in blk_stack_limits()
890 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
891 ret = -1; in blk_stack_limits()
895 if (t->chunk_sectors % (t->physical_block_size >> SECTOR_SHIFT)) { in blk_stack_limits()
896 t->chunk_sectors = 0; in blk_stack_limits()
897 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
898 ret = -1; in blk_stack_limits()
902 t->alignment_offset = lcm_not_zero(t->alignment_offset, alignment) in blk_stack_limits()
903 % max(t->physical_block_size, t->io_min); in blk_stack_limits()
906 if (t->alignment_offset & (t->logical_block_size - 1)) { in blk_stack_limits()
907 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
908 ret = -1; in blk_stack_limits()
911 t->max_sectors = blk_round_down_sectors(t->max_sectors, t->logical_block_size); in blk_stack_limits()
912 t->max_hw_sectors = blk_round_down_sectors(t->max_hw_sectors, t->logical_block_size); in blk_stack_limits()
913 t->max_dev_sectors = blk_round_down_sectors(t->max_dev_sectors, t->logical_block_size); in blk_stack_limits()
916 if (b->discard_granularity) { in blk_stack_limits()
919 t->max_discard_sectors = min_not_zero(t->max_discard_sectors, in blk_stack_limits()
920 b->max_discard_sectors); in blk_stack_limits()
921 t->max_hw_discard_sectors = min_not_zero(t->max_hw_discard_sectors, in blk_stack_limits()
922 b->max_hw_discard_sectors); in blk_stack_limits()
923 t->discard_granularity = max(t->discard_granularity, in blk_stack_limits()
924 b->discard_granularity); in blk_stack_limits()
925 t->discard_alignment = lcm_not_zero(t->discard_alignment, alignment) % in blk_stack_limits()
926 t->discard_granularity; in blk_stack_limits()
928 t->max_secure_erase_sectors = min_not_zero(t->max_secure_erase_sectors, in blk_stack_limits()
929 b->max_secure_erase_sectors); in blk_stack_limits()
930 t->zone_write_granularity = max(t->zone_write_granularity, in blk_stack_limits()
931 b->zone_write_granularity); in blk_stack_limits()
932 if (!(t->features & BLK_FEAT_ZONED)) { in blk_stack_limits()
933 t->zone_write_granularity = 0; in blk_stack_limits()
934 t->max_zone_append_sectors = 0; in blk_stack_limits()
943 * queue_limits_stack_bdev - adjust queue_limits for stacked devices
968 * queue_limits_stack_integrity - stack integrity profile
984 struct blk_integrity *ti = &t->integrity; in queue_limits_stack_integrity()
985 struct blk_integrity *bi = &b->integrity; in queue_limits_stack_integrity()
990 if (ti->flags & BLK_INTEGRITY_STACKED) { in queue_limits_stack_integrity()
991 if (ti->metadata_size != bi->metadata_size) in queue_limits_stack_integrity()
993 if (ti->interval_exp != bi->interval_exp) in queue_limits_stack_integrity()
995 if (ti->tag_size != bi->tag_size) in queue_limits_stack_integrity()
997 if (ti->csum_type != bi->csum_type) in queue_limits_stack_integrity()
999 if (ti->pi_tuple_size != bi->pi_tuple_size) in queue_limits_stack_integrity()
1001 if ((ti->flags & BLK_INTEGRITY_REF_TAG) != in queue_limits_stack_integrity()
1002 (bi->flags & BLK_INTEGRITY_REF_TAG)) in queue_limits_stack_integrity()
1005 ti->flags = BLK_INTEGRITY_STACKED; in queue_limits_stack_integrity()
1006 ti->flags |= (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE) | in queue_limits_stack_integrity()
1007 (bi->flags & BLK_INTEGRITY_REF_TAG); in queue_limits_stack_integrity()
1008 ti->csum_type = bi->csum_type; in queue_limits_stack_integrity()
1009 ti->pi_tuple_size = bi->pi_tuple_size; in queue_limits_stack_integrity()
1010 ti->metadata_size = bi->metadata_size; in queue_limits_stack_integrity()
1011 ti->pi_offset = bi->pi_offset; in queue_limits_stack_integrity()
1012 ti->interval_exp = bi->interval_exp; in queue_limits_stack_integrity()
1013 ti->tag_size = bi->tag_size; in queue_limits_stack_integrity()
1024 * blk_set_queue_depth - tell the block layer about the device queue depth
1026 * @depth: queue depth
1029 void blk_set_queue_depth(struct request_queue *q, unsigned int depth) in blk_set_queue_depth() argument
1031 q->queue_depth = depth; in blk_set_queue_depth()
1040 if (q->limits.flags & BLK_FLAG_MISALIGNED) in bdev_alignment_offset()
1041 return -1; in bdev_alignment_offset()
1043 return queue_limit_alignment_offset(&q->limits, in bdev_alignment_offset()
1044 bdev->bd_start_sect); in bdev_alignment_offset()
1045 return q->limits.alignment_offset; in bdev_alignment_offset()
1054 return queue_limit_discard_alignment(&q->limits, in bdev_discard_alignment()
1055 bdev->bd_start_sect); in bdev_discard_alignment()
1056 return q->limits.discard_alignment; in bdev_discard_alignment()