Lines Matching +full:power +full:- +full:limits
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
34 * Prepare queue limits for applying limits from underlying devices using
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()
47 /* Inherit limits from component devices */ 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()
66 * For read-ahead of large files to be effective, we need to read ahead in blk_apply_bdi_limits()
69 * There is no hardware limitation for the read-ahead size and the user in blk_apply_bdi_limits()
70 * might have increased the read-ahead size through sysfs, so don't ever in blk_apply_bdi_limits()
73 bdi->ra_pages = max3(bdi->ra_pages, in blk_apply_bdi_limits()
74 lim->io_opt * 2 / PAGE_SIZE, in blk_apply_bdi_limits()
76 bdi->io_pages = lim->max_sectors >> PAGE_SECTORS_SHIFT; in blk_apply_bdi_limits()
81 if (!(lim->features & BLK_FEAT_ZONED)) { in blk_validate_zoned_limits()
82 if (WARN_ON_ONCE(lim->max_open_zones) || in blk_validate_zoned_limits()
83 WARN_ON_ONCE(lim->max_active_zones) || in blk_validate_zoned_limits()
84 WARN_ON_ONCE(lim->zone_write_granularity) || in blk_validate_zoned_limits()
85 WARN_ON_ONCE(lim->max_zone_append_sectors)) in blk_validate_zoned_limits()
86 return -EINVAL; in blk_validate_zoned_limits()
91 return -EINVAL; in blk_validate_zoned_limits()
97 if (lim->max_active_zones && in blk_validate_zoned_limits()
98 lim->max_open_zones > lim->max_active_zones) in blk_validate_zoned_limits()
99 return -EINVAL; in blk_validate_zoned_limits()
101 if (lim->zone_write_granularity < lim->logical_block_size) in blk_validate_zoned_limits()
102 lim->zone_write_granularity = lim->logical_block_size; in blk_validate_zoned_limits()
111 lim->max_zone_append_sectors = in blk_validate_zoned_limits()
112 min_not_zero(lim->max_hw_zone_append_sectors, in blk_validate_zoned_limits()
113 min(lim->chunk_sectors, lim->max_hw_sectors)); in blk_validate_zoned_limits()
119 struct blk_integrity *bi = &lim->integrity; in blk_validate_integrity_limits()
121 if (!bi->metadata_size) { in blk_validate_integrity_limits()
122 if (bi->csum_type != BLK_INTEGRITY_CSUM_NONE || in blk_validate_integrity_limits()
123 bi->tag_size || ((bi->flags & BLK_INTEGRITY_REF_TAG))) { in blk_validate_integrity_limits()
125 return -EINVAL; in blk_validate_integrity_limits()
127 bi->flags |= BLK_INTEGRITY_NOGENERATE | BLK_INTEGRITY_NOVERIFY; in blk_validate_integrity_limits()
133 return -EINVAL; in blk_validate_integrity_limits()
136 if (bi->csum_type == BLK_INTEGRITY_CSUM_NONE && in blk_validate_integrity_limits()
137 (bi->flags & BLK_INTEGRITY_REF_TAG)) { in blk_validate_integrity_limits()
139 return -EINVAL; in blk_validate_integrity_limits()
142 if (bi->pi_tuple_size > bi->metadata_size) { in blk_validate_integrity_limits()
144 bi->pi_tuple_size, in blk_validate_integrity_limits()
145 bi->metadata_size); in blk_validate_integrity_limits()
146 return -EINVAL; in blk_validate_integrity_limits()
149 switch (bi->csum_type) { in blk_validate_integrity_limits()
151 if (bi->pi_tuple_size) { in blk_validate_integrity_limits()
154 return -EINVAL; in blk_validate_integrity_limits()
159 if (bi->pi_tuple_size != sizeof(struct t10_pi_tuple)) { in blk_validate_integrity_limits()
163 bi->pi_tuple_size); in blk_validate_integrity_limits()
164 return -EINVAL; in blk_validate_integrity_limits()
168 if (bi->pi_tuple_size != sizeof(struct crc64_pi_tuple)) { in blk_validate_integrity_limits()
172 bi->pi_tuple_size); in blk_validate_integrity_limits()
173 return -EINVAL; in blk_validate_integrity_limits()
178 if (!bi->interval_exp) in blk_validate_integrity_limits()
179 bi->interval_exp = ilog2(lim->logical_block_size); in blk_validate_integrity_limits()
193 unsigned int max_segments = min(BIO_MAX_VECS, lim->max_segments); in blk_queue_max_guaranteed_bio()
196 length = min(max_segments, 2) * lim->logical_block_size; in blk_queue_max_guaranteed_bio()
198 length += (max_segments - 2) * PAGE_SIZE; in blk_queue_max_guaranteed_bio()
205 unsigned int unit_limit = min(lim->max_hw_sectors << SECTOR_SHIFT, in blk_atomic_writes_update_limits()
210 lim->atomic_write_max_sectors = in blk_atomic_writes_update_limits()
211 min(lim->atomic_write_hw_max >> SECTOR_SHIFT, in blk_atomic_writes_update_limits()
212 lim->max_hw_sectors); in blk_atomic_writes_update_limits()
213 lim->atomic_write_unit_min = in blk_atomic_writes_update_limits()
214 min(lim->atomic_write_hw_unit_min, unit_limit); in blk_atomic_writes_update_limits()
215 lim->atomic_write_unit_max = in blk_atomic_writes_update_limits()
216 min(lim->atomic_write_hw_unit_max, unit_limit); in blk_atomic_writes_update_limits()
217 lim->atomic_write_boundary_sectors = in blk_atomic_writes_update_limits()
218 lim->atomic_write_hw_boundary >> SECTOR_SHIFT; in blk_atomic_writes_update_limits()
225 lim->atomic_write_hw_max >> SECTOR_SHIFT; in blk_validate_atomic_write_limits()
227 if (!(lim->features & BLK_FEAT_ATOMIC_WRITES)) in blk_validate_atomic_write_limits()
230 if (!lim->atomic_write_hw_max) in blk_validate_atomic_write_limits()
233 if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_min))) in blk_validate_atomic_write_limits()
236 if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_max))) in blk_validate_atomic_write_limits()
239 if (WARN_ON_ONCE(lim->atomic_write_hw_unit_min > in blk_validate_atomic_write_limits()
240 lim->atomic_write_hw_unit_max)) in blk_validate_atomic_write_limits()
243 if (WARN_ON_ONCE(lim->atomic_write_hw_unit_max > in blk_validate_atomic_write_limits()
244 lim->atomic_write_hw_max)) in blk_validate_atomic_write_limits()
247 if (WARN_ON_ONCE(lim->chunk_sectors && in blk_validate_atomic_write_limits()
248 atomic_write_hw_max_sectors > lim->chunk_sectors)) in blk_validate_atomic_write_limits()
251 boundary_sectors = lim->atomic_write_hw_boundary >> SECTOR_SHIFT; in blk_validate_atomic_write_limits()
254 if (WARN_ON_ONCE(lim->atomic_write_hw_max > in blk_validate_atomic_write_limits()
255 lim->atomic_write_hw_boundary)) in blk_validate_atomic_write_limits()
263 * which is non-zero and smaller than atomic write HW boundary. in blk_validate_atomic_write_limits()
270 if (WARN_ON_ONCE(lim->chunk_sectors % boundary_sectors)) in blk_validate_atomic_write_limits()
275 * (and not necessarily a power-of-2), so this following check in blk_validate_atomic_write_limits()
278 * that it is compliant with a !power-of-2 boundary. in blk_validate_atomic_write_limits()
288 lim->atomic_write_max_sectors = 0; in blk_validate_atomic_write_limits()
289 lim->atomic_write_boundary_sectors = 0; in blk_validate_atomic_write_limits()
290 lim->atomic_write_unit_min = 0; in blk_validate_atomic_write_limits()
291 lim->atomic_write_unit_max = 0; in blk_validate_atomic_write_limits()
295 * Check that the limits in lim are valid, initialize defaults for unset
309 if (!lim->logical_block_size) in blk_validate_limits()
310 lim->logical_block_size = SECTOR_SIZE; in blk_validate_limits()
311 else if (blk_validate_block_size(lim->logical_block_size)) { in blk_validate_limits()
312 pr_warn("Invalid logical block size (%d)\n", lim->logical_block_size); in blk_validate_limits()
313 return -EINVAL; in blk_validate_limits()
315 if (lim->physical_block_size < lim->logical_block_size) in blk_validate_limits()
316 lim->physical_block_size = lim->logical_block_size; in blk_validate_limits()
322 if (lim->io_min < lim->physical_block_size) in blk_validate_limits()
323 lim->io_min = lim->physical_block_size; in blk_validate_limits()
330 lim->io_opt = round_down(lim->io_opt, lim->physical_block_size); in blk_validate_limits()
341 if (!lim->max_hw_sectors) in blk_validate_limits()
342 lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS; in blk_validate_limits()
343 if (WARN_ON_ONCE(lim->max_hw_sectors < PAGE_SECTORS)) in blk_validate_limits()
344 return -EINVAL; in blk_validate_limits()
345 logical_block_sectors = lim->logical_block_size >> SECTOR_SHIFT; in blk_validate_limits()
346 if (WARN_ON_ONCE(logical_block_sectors > lim->max_hw_sectors)) in blk_validate_limits()
347 return -EINVAL; in blk_validate_limits()
348 lim->max_hw_sectors = round_down(lim->max_hw_sectors, in blk_validate_limits()
354 * value into account. The ->max_sectors value is always calculated in blk_validate_limits()
357 max_hw_sectors = min_not_zero(lim->max_hw_sectors, in blk_validate_limits()
358 lim->max_dev_sectors); in blk_validate_limits()
359 if (lim->max_user_sectors) { in blk_validate_limits()
360 if (lim->max_user_sectors < BLK_MIN_SEGMENT_SIZE / SECTOR_SIZE) in blk_validate_limits()
361 return -EINVAL; in blk_validate_limits()
362 lim->max_sectors = min(max_hw_sectors, lim->max_user_sectors); in blk_validate_limits()
363 } else if (lim->io_opt > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) { in blk_validate_limits()
364 lim->max_sectors = in blk_validate_limits()
365 min(max_hw_sectors, lim->io_opt >> SECTOR_SHIFT); in blk_validate_limits()
366 } else if (lim->io_min > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) { in blk_validate_limits()
367 lim->max_sectors = in blk_validate_limits()
368 min(max_hw_sectors, lim->io_min >> SECTOR_SHIFT); in blk_validate_limits()
370 lim->max_sectors = min(max_hw_sectors, BLK_DEF_MAX_SECTORS_CAP); in blk_validate_limits()
372 lim->max_sectors = round_down(lim->max_sectors, in blk_validate_limits()
379 if (!lim->max_segments) in blk_validate_limits()
380 lim->max_segments = BLK_MAX_SEGMENTS; in blk_validate_limits()
382 if (lim->max_hw_wzeroes_unmap_sectors && in blk_validate_limits()
383 lim->max_hw_wzeroes_unmap_sectors != lim->max_write_zeroes_sectors) in blk_validate_limits()
384 return -EINVAL; in blk_validate_limits()
385 lim->max_wzeroes_unmap_sectors = min(lim->max_hw_wzeroes_unmap_sectors, in blk_validate_limits()
386 lim->max_user_wzeroes_unmap_sectors); in blk_validate_limits()
388 lim->max_discard_sectors = in blk_validate_limits()
389 min(lim->max_hw_discard_sectors, lim->max_user_discard_sectors); in blk_validate_limits()
391 if (!lim->max_discard_segments) in blk_validate_limits()
392 lim->max_discard_segments = 1; in blk_validate_limits()
394 if (lim->discard_granularity < lim->physical_block_size) in blk_validate_limits()
395 lim->discard_granularity = lim->physical_block_size; in blk_validate_limits()
402 if (!lim->seg_boundary_mask) in blk_validate_limits()
403 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; in blk_validate_limits()
404 if (WARN_ON_ONCE(lim->seg_boundary_mask < BLK_MIN_SEGMENT_SIZE - 1)) in blk_validate_limits()
405 return -EINVAL; in blk_validate_limits()
409 * size limit, so allow this setting now, and long-term the two in blk_validate_limits()
410 * might need to move out of stacking limits since we have immutable in blk_validate_limits()
414 if (lim->virt_boundary_mask) { in blk_validate_limits()
415 if (!lim->max_segment_size) in blk_validate_limits()
416 lim->max_segment_size = UINT_MAX; in blk_validate_limits()
423 if (!lim->max_segment_size) in blk_validate_limits()
424 lim->max_segment_size = BLK_MAX_SEGMENT_SIZE; in blk_validate_limits()
425 if (WARN_ON_ONCE(lim->max_segment_size < BLK_MIN_SEGMENT_SIZE)) in blk_validate_limits()
426 return -EINVAL; in blk_validate_limits()
430 if (lim->seg_boundary_mask > lim->max_segment_size - 1) in blk_validate_limits()
431 seg_size = lim->max_segment_size; in blk_validate_limits()
433 seg_size = lim->seg_boundary_mask + 1; in blk_validate_limits()
434 lim->min_segment_size = min_t(unsigned int, seg_size, PAGE_SIZE); in blk_validate_limits()
439 * to set the limits. Once the transition is finished the check in blk_validate_limits()
442 if (!lim->dma_alignment) in blk_validate_limits()
443 lim->dma_alignment = SECTOR_SIZE - 1; in blk_validate_limits()
444 if (WARN_ON_ONCE(lim->dma_alignment > PAGE_SIZE)) in blk_validate_limits()
445 return -EINVAL; in blk_validate_limits()
447 if (lim->alignment_offset) { in blk_validate_limits()
448 lim->alignment_offset &= (lim->physical_block_size - 1); in blk_validate_limits()
449 lim->flags &= ~BLK_FLAG_MISALIGNED; in blk_validate_limits()
452 if (!(lim->features & BLK_FEAT_WRITE_CACHE)) in blk_validate_limits()
453 lim->features &= ~BLK_FEAT_FUA; in blk_validate_limits()
465 * Set the default limits for a newly allocated queue. @lim contains the
466 * initial limits set by the driver, which could be no limit in which case
473 * but these limits are special and need an explicit initialization to in blk_set_default_limits()
476 lim->max_user_discard_sectors = UINT_MAX; in blk_set_default_limits()
477 lim->max_user_wzeroes_unmap_sectors = UINT_MAX; in blk_set_default_limits()
482 * queue_limits_commit_update - commit an atomic update of queue limits
484 * @lim: limits to apply
486 * Apply the limits in @lim that were obtained from queue_limits_start_update()
502 if (q->crypto_profile && lim->integrity.tag_size) { in queue_limits_commit_update()
503 pr_warn("blk-integrity: Integrity and hardware inline encryption are not supported together.\n"); in queue_limits_commit_update()
504 error = -EINVAL; in queue_limits_commit_update()
509 q->limits = *lim; in queue_limits_commit_update()
510 if (q->disk) in queue_limits_commit_update()
511 blk_apply_bdi_limits(q->disk->bdi, lim); in queue_limits_commit_update()
513 mutex_unlock(&q->limits_lock); in queue_limits_commit_update()
519 * queue_limits_commit_update_frozen - commit an atomic update of queue limits
521 * @lim: limits to apply
523 * Apply the limits in @lim that were obtained from queue_limits_start_update()
544 * queue_limits_set - apply queue limits to queue
546 * @lim: limits to apply
548 * Apply the limits in @lim that were freshly initialized to @q.
549 * To update existing limits use queue_limits_start_update() and
556 mutex_lock(&q->limits_lock); in queue_limits_set()
564 unsigned int granularity = max(lim->physical_block_size, lim->io_min); in queue_limit_alignment_offset()
568 return (granularity + lim->alignment_offset - alignment) % granularity; in queue_limit_alignment_offset()
576 if (!lim->max_discard_sectors) in queue_limit_discard_alignment()
580 alignment = lim->discard_alignment >> SECTOR_SHIFT; in queue_limit_discard_alignment()
581 granularity = lim->discard_granularity >> SECTOR_SHIFT; in queue_limit_discard_alignment()
587 offset = (granularity + alignment - offset) % granularity; in queue_limit_discard_alignment()
606 if (t->atomic_write_hw_boundary != b->atomic_write_hw_boundary) in blk_stack_atomic_writes_tail()
610 if (t->atomic_write_hw_unit_min > b->atomic_write_hw_unit_max) in blk_stack_atomic_writes_tail()
614 if (t->atomic_write_hw_unit_max < b->atomic_write_hw_unit_min) in blk_stack_atomic_writes_tail()
617 t->atomic_write_hw_max = min(t->atomic_write_hw_max, in blk_stack_atomic_writes_tail()
618 b->atomic_write_hw_max); in blk_stack_atomic_writes_tail()
619 t->atomic_write_hw_unit_min = max(t->atomic_write_hw_unit_min, in blk_stack_atomic_writes_tail()
620 b->atomic_write_hw_unit_min); in blk_stack_atomic_writes_tail()
621 t->atomic_write_hw_unit_max = min(t->atomic_write_hw_unit_max, in blk_stack_atomic_writes_tail()
622 b->atomic_write_hw_unit_max); in blk_stack_atomic_writes_tail()
632 * devices store chunk sectors in t->io_min. in blk_stack_atomic_writes_boundary_head()
634 if (b->atomic_write_hw_boundary > t->io_min && in blk_stack_atomic_writes_boundary_head()
635 b->atomic_write_hw_boundary % t->io_min) in blk_stack_atomic_writes_boundary_head()
637 if (t->io_min > b->atomic_write_hw_boundary && in blk_stack_atomic_writes_boundary_head()
638 t->io_min % b->atomic_write_hw_boundary) in blk_stack_atomic_writes_boundary_head()
641 t->atomic_write_hw_boundary = b->atomic_write_hw_boundary; in blk_stack_atomic_writes_boundary_head()
649 if (!t->chunk_sectors) in blk_stack_atomic_writes_chunk_sectors()
657 if (check_shl_overflow(t->chunk_sectors, SECTOR_SHIFT, &chunk_bytes)) in blk_stack_atomic_writes_chunk_sectors()
658 chunk_bytes = t->chunk_sectors; in blk_stack_atomic_writes_chunk_sectors()
661 * Find values for limits which work for chunk size. in blk_stack_atomic_writes_chunk_sectors()
662 * b->atomic_write_hw_unit_{min, max} may not be aligned with chunk in blk_stack_atomic_writes_chunk_sectors()
663 * size, as the chunk size is not restricted to a power-of-2. in blk_stack_atomic_writes_chunk_sectors()
664 * So we need to find highest power-of-2 which works for the chunk in blk_stack_atomic_writes_chunk_sectors()
666 * As an example scenario, we could have t->unit_max = 16K and in blk_stack_atomic_writes_chunk_sectors()
667 * t->chunk_sectors = 24KB. For this case, reduce t->unit_max to a in blk_stack_atomic_writes_chunk_sectors()
668 * value aligned with both limits, i.e. 8K in this example. in blk_stack_atomic_writes_chunk_sectors()
670 t->atomic_write_hw_unit_max = min(t->atomic_write_hw_unit_max, in blk_stack_atomic_writes_chunk_sectors()
673 t->atomic_write_hw_unit_min = min(t->atomic_write_hw_unit_min, in blk_stack_atomic_writes_chunk_sectors()
674 t->atomic_write_hw_unit_max); in blk_stack_atomic_writes_chunk_sectors()
675 t->atomic_write_hw_max = min(t->atomic_write_hw_max, chunk_bytes); in blk_stack_atomic_writes_chunk_sectors()
682 if (b->atomic_write_hw_boundary && in blk_stack_atomic_writes_head()
686 t->atomic_write_hw_unit_max = b->atomic_write_hw_unit_max; in blk_stack_atomic_writes_head()
687 t->atomic_write_hw_unit_min = b->atomic_write_hw_unit_min; in blk_stack_atomic_writes_head()
688 t->atomic_write_hw_max = b->atomic_write_hw_max; in blk_stack_atomic_writes_head()
695 if (!(b->features & BLK_FEAT_ATOMIC_WRITES)) in blk_stack_atomic_writes_limits()
698 if (!b->atomic_write_hw_unit_min) in blk_stack_atomic_writes_limits()
708 if (t->atomic_write_hw_max) { in blk_stack_atomic_writes_limits()
720 t->atomic_write_hw_max = 0; in blk_stack_atomic_writes_limits()
721 t->atomic_write_hw_unit_max = 0; in blk_stack_atomic_writes_limits()
722 t->atomic_write_hw_unit_min = 0; in blk_stack_atomic_writes_limits()
723 t->atomic_write_hw_boundary = 0; in blk_stack_atomic_writes_limits()
727 * blk_stack_limits - adjust queue_limits for stacked devices
728 * @t: the stacking driver limits (top device)
729 * @b: the underlying queue limits (bottom, component device)
743 * and alignments exist, -1 is returned and the resulting top
752 t->features |= (b->features & BLK_FEAT_INHERIT_MASK); in blk_stack_limits()
757 * stacking the limits, and this will clear the flags if any of the in blk_stack_limits()
760 if (!(b->features & BLK_FEAT_NOWAIT)) in blk_stack_limits()
761 t->features &= ~BLK_FEAT_NOWAIT; in blk_stack_limits()
762 if (!(b->features & BLK_FEAT_POLL)) in blk_stack_limits()
763 t->features &= ~BLK_FEAT_POLL; in blk_stack_limits()
765 t->flags |= (b->flags & BLK_FLAG_MISALIGNED); in blk_stack_limits()
767 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors); in blk_stack_limits()
768 t->max_user_sectors = min_not_zero(t->max_user_sectors, in blk_stack_limits()
769 b->max_user_sectors); in blk_stack_limits()
770 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors); in blk_stack_limits()
771 t->max_dev_sectors = min_not_zero(t->max_dev_sectors, b->max_dev_sectors); in blk_stack_limits()
772 t->max_write_zeroes_sectors = min(t->max_write_zeroes_sectors, in blk_stack_limits()
773 b->max_write_zeroes_sectors); in blk_stack_limits()
774 t->max_user_wzeroes_unmap_sectors = in blk_stack_limits()
775 min(t->max_user_wzeroes_unmap_sectors, in blk_stack_limits()
776 b->max_user_wzeroes_unmap_sectors); in blk_stack_limits()
777 t->max_hw_wzeroes_unmap_sectors = in blk_stack_limits()
778 min(t->max_hw_wzeroes_unmap_sectors, in blk_stack_limits()
779 b->max_hw_wzeroes_unmap_sectors); in blk_stack_limits()
781 t->max_hw_zone_append_sectors = min(t->max_hw_zone_append_sectors, in blk_stack_limits()
782 b->max_hw_zone_append_sectors); in blk_stack_limits()
784 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, in blk_stack_limits()
785 b->seg_boundary_mask); in blk_stack_limits()
786 t->virt_boundary_mask = min_not_zero(t->virt_boundary_mask, in blk_stack_limits()
787 b->virt_boundary_mask); in blk_stack_limits()
789 t->max_segments = min_not_zero(t->max_segments, b->max_segments); in blk_stack_limits()
790 t->max_discard_segments = min_not_zero(t->max_discard_segments, in blk_stack_limits()
791 b->max_discard_segments); in blk_stack_limits()
792 t->max_integrity_segments = min_not_zero(t->max_integrity_segments, in blk_stack_limits()
793 b->max_integrity_segments); in blk_stack_limits()
795 t->max_segment_size = min_not_zero(t->max_segment_size, in blk_stack_limits()
796 b->max_segment_size); in blk_stack_limits()
803 if (t->alignment_offset != alignment) { in blk_stack_limits()
805 top = max(t->physical_block_size, t->io_min) in blk_stack_limits()
806 + t->alignment_offset; in blk_stack_limits()
807 bottom = max(b->physical_block_size, b->io_min) + alignment; in blk_stack_limits()
811 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
812 ret = -1; in blk_stack_limits()
816 t->logical_block_size = max(t->logical_block_size, in blk_stack_limits()
817 b->logical_block_size); in blk_stack_limits()
819 t->physical_block_size = max(t->physical_block_size, in blk_stack_limits()
820 b->physical_block_size); in blk_stack_limits()
822 t->io_min = max(t->io_min, b->io_min); in blk_stack_limits()
823 t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); in blk_stack_limits()
824 t->dma_alignment = max(t->dma_alignment, b->dma_alignment); in blk_stack_limits()
826 /* Set non-power-of-2 compatible chunk_sectors boundary */ in blk_stack_limits()
827 if (b->chunk_sectors) in blk_stack_limits()
828 t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); in blk_stack_limits()
831 if (t->physical_block_size & (t->logical_block_size - 1)) { in blk_stack_limits()
832 t->physical_block_size = t->logical_block_size; in blk_stack_limits()
833 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
834 ret = -1; in blk_stack_limits()
838 if (t->io_min & (t->physical_block_size - 1)) { in blk_stack_limits()
839 t->io_min = t->physical_block_size; in blk_stack_limits()
840 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
841 ret = -1; in blk_stack_limits()
845 if (t->io_opt & (t->physical_block_size - 1)) { in blk_stack_limits()
846 t->io_opt = 0; in blk_stack_limits()
847 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
848 ret = -1; in blk_stack_limits()
852 if ((t->chunk_sectors << 9) & (t->physical_block_size - 1)) { in blk_stack_limits()
853 t->chunk_sectors = 0; in blk_stack_limits()
854 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
855 ret = -1; in blk_stack_limits()
859 t->alignment_offset = lcm_not_zero(t->alignment_offset, alignment) in blk_stack_limits()
860 % max(t->physical_block_size, t->io_min); in blk_stack_limits()
863 if (t->alignment_offset & (t->logical_block_size - 1)) { in blk_stack_limits()
864 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
865 ret = -1; in blk_stack_limits()
868 t->max_sectors = blk_round_down_sectors(t->max_sectors, t->logical_block_size); in blk_stack_limits()
869 t->max_hw_sectors = blk_round_down_sectors(t->max_hw_sectors, t->logical_block_size); in blk_stack_limits()
870 t->max_dev_sectors = blk_round_down_sectors(t->max_dev_sectors, t->logical_block_size); in blk_stack_limits()
873 if (b->discard_granularity) { in blk_stack_limits()
876 t->max_discard_sectors = min_not_zero(t->max_discard_sectors, in blk_stack_limits()
877 b->max_discard_sectors); in blk_stack_limits()
878 t->max_hw_discard_sectors = min_not_zero(t->max_hw_discard_sectors, in blk_stack_limits()
879 b->max_hw_discard_sectors); in blk_stack_limits()
880 t->discard_granularity = max(t->discard_granularity, in blk_stack_limits()
881 b->discard_granularity); in blk_stack_limits()
882 t->discard_alignment = lcm_not_zero(t->discard_alignment, alignment) % in blk_stack_limits()
883 t->discard_granularity; in blk_stack_limits()
885 t->max_secure_erase_sectors = min_not_zero(t->max_secure_erase_sectors, in blk_stack_limits()
886 b->max_secure_erase_sectors); in blk_stack_limits()
887 t->zone_write_granularity = max(t->zone_write_granularity, in blk_stack_limits()
888 b->zone_write_granularity); in blk_stack_limits()
889 if (!(t->features & BLK_FEAT_ZONED)) { in blk_stack_limits()
890 t->zone_write_granularity = 0; in blk_stack_limits()
891 t->max_zone_append_sectors = 0; in blk_stack_limits()
900 * queue_limits_stack_bdev - adjust queue_limits for stacked devices
901 * @t: the stacking driver limits (top device)
925 * queue_limits_stack_integrity - stack integrity profile
926 * @t: target queue limits
927 * @b: base queue limits
941 struct blk_integrity *ti = &t->integrity; in queue_limits_stack_integrity()
942 struct blk_integrity *bi = &b->integrity; in queue_limits_stack_integrity()
947 if (ti->flags & BLK_INTEGRITY_STACKED) { in queue_limits_stack_integrity()
948 if (ti->metadata_size != bi->metadata_size) in queue_limits_stack_integrity()
950 if (ti->interval_exp != bi->interval_exp) in queue_limits_stack_integrity()
952 if (ti->tag_size != bi->tag_size) in queue_limits_stack_integrity()
954 if (ti->csum_type != bi->csum_type) in queue_limits_stack_integrity()
956 if ((ti->flags & BLK_INTEGRITY_REF_TAG) != in queue_limits_stack_integrity()
957 (bi->flags & BLK_INTEGRITY_REF_TAG)) in queue_limits_stack_integrity()
960 ti->flags = BLK_INTEGRITY_STACKED; in queue_limits_stack_integrity()
961 ti->flags |= (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE) | in queue_limits_stack_integrity()
962 (bi->flags & BLK_INTEGRITY_REF_TAG); in queue_limits_stack_integrity()
963 ti->csum_type = bi->csum_type; in queue_limits_stack_integrity()
964 ti->metadata_size = bi->metadata_size; in queue_limits_stack_integrity()
965 ti->pi_offset = bi->pi_offset; in queue_limits_stack_integrity()
966 ti->interval_exp = bi->interval_exp; in queue_limits_stack_integrity()
967 ti->tag_size = bi->tag_size; in queue_limits_stack_integrity()
978 * blk_set_queue_depth - tell the block layer about the device queue depth
985 q->queue_depth = depth; in blk_set_queue_depth()
994 if (q->limits.flags & BLK_FLAG_MISALIGNED) in bdev_alignment_offset()
995 return -1; in bdev_alignment_offset()
997 return queue_limit_alignment_offset(&q->limits, in bdev_alignment_offset()
998 bdev->bd_start_sect); in bdev_alignment_offset()
999 return q->limits.alignment_offset; in bdev_alignment_offset()
1008 return queue_limit_discard_alignment(&q->limits, in bdev_discard_alignment()
1009 bdev->bd_start_sect); in bdev_discard_alignment()
1010 return q->limits.discard_alignment; in bdev_discard_alignment()