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>
19 #include "blk-rq-qos.h"
20 #include "blk-wbt.h"
24 q->rq_timeout = timeout; in blk_queue_rq_timeout()
29 * blk_set_stacking_limits - set default limits for stacking devices
32 * Prepare queue limits for applying limits from underlying devices using
38 lim->logical_block_size = SECTOR_SIZE; in blk_set_stacking_limits()
39 lim->physical_block_size = SECTOR_SIZE; in blk_set_stacking_limits()
40 lim->io_min = SECTOR_SIZE; in blk_set_stacking_limits()
41 lim->discard_granularity = SECTOR_SIZE; in blk_set_stacking_limits()
42 lim->dma_alignment = SECTOR_SIZE - 1; in blk_set_stacking_limits()
43 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; in blk_set_stacking_limits()
45 /* Inherit limits from component devices */ in blk_set_stacking_limits()
46 lim->max_segments = USHRT_MAX; in blk_set_stacking_limits()
47 lim->max_discard_segments = USHRT_MAX; in blk_set_stacking_limits()
48 lim->max_hw_sectors = UINT_MAX; in blk_set_stacking_limits()
49 lim->max_segment_size = UINT_MAX; in blk_set_stacking_limits()
50 lim->max_sectors = UINT_MAX; in blk_set_stacking_limits()
51 lim->max_dev_sectors = UINT_MAX; in blk_set_stacking_limits()
52 lim->max_write_zeroes_sectors = UINT_MAX; in blk_set_stacking_limits()
53 lim->max_hw_zone_append_sectors = UINT_MAX; in blk_set_stacking_limits()
54 lim->max_user_discard_sectors = UINT_MAX; in blk_set_stacking_limits()
62 * For read-ahead of large files to be effective, we need to read ahead in blk_apply_bdi_limits()
65 bdi->ra_pages = max(lim->io_opt * 2 / PAGE_SIZE, VM_READAHEAD_PAGES); in blk_apply_bdi_limits()
66 bdi->io_pages = lim->max_sectors >> PAGE_SECTORS_SHIFT; in blk_apply_bdi_limits()
71 if (!(lim->features & BLK_FEAT_ZONED)) { in blk_validate_zoned_limits()
72 if (WARN_ON_ONCE(lim->max_open_zones) || in blk_validate_zoned_limits()
73 WARN_ON_ONCE(lim->max_active_zones) || in blk_validate_zoned_limits()
74 WARN_ON_ONCE(lim->zone_write_granularity) || in blk_validate_zoned_limits()
75 WARN_ON_ONCE(lim->max_zone_append_sectors)) in blk_validate_zoned_limits()
76 return -EINVAL; in blk_validate_zoned_limits()
81 return -EINVAL; in blk_validate_zoned_limits()
87 if (lim->max_active_zones && in blk_validate_zoned_limits()
88 lim->max_open_zones > lim->max_active_zones) in blk_validate_zoned_limits()
89 return -EINVAL; in blk_validate_zoned_limits()
91 if (lim->zone_write_granularity < lim->logical_block_size) in blk_validate_zoned_limits()
92 lim->zone_write_granularity = lim->logical_block_size; in blk_validate_zoned_limits()
101 lim->max_zone_append_sectors = in blk_validate_zoned_limits()
102 min_not_zero(lim->max_hw_zone_append_sectors, in blk_validate_zoned_limits()
103 min(lim->chunk_sectors, lim->max_hw_sectors)); in blk_validate_zoned_limits()
109 struct blk_integrity *bi = &lim->integrity; in blk_validate_integrity_limits()
111 if (!bi->tuple_size) { in blk_validate_integrity_limits()
112 if (bi->csum_type != BLK_INTEGRITY_CSUM_NONE || in blk_validate_integrity_limits()
113 bi->tag_size || ((bi->flags & BLK_INTEGRITY_REF_TAG))) { in blk_validate_integrity_limits()
115 return -EINVAL; in blk_validate_integrity_limits()
117 bi->flags |= BLK_INTEGRITY_NOGENERATE | BLK_INTEGRITY_NOVERIFY; in blk_validate_integrity_limits()
123 return -EINVAL; in blk_validate_integrity_limits()
126 if (bi->csum_type == BLK_INTEGRITY_CSUM_NONE && in blk_validate_integrity_limits()
127 (bi->flags & BLK_INTEGRITY_REF_TAG)) { in blk_validate_integrity_limits()
129 return -EINVAL; in blk_validate_integrity_limits()
132 if (!bi->interval_exp) in blk_validate_integrity_limits()
133 bi->interval_exp = ilog2(lim->logical_block_size); in blk_validate_integrity_limits()
147 unsigned int max_segments = min(BIO_MAX_VECS, lim->max_segments); in blk_queue_max_guaranteed_bio()
150 length = min(max_segments, 2) * lim->logical_block_size; in blk_queue_max_guaranteed_bio()
152 length += (max_segments - 2) * PAGE_SIZE; in blk_queue_max_guaranteed_bio()
159 unsigned int unit_limit = min(lim->max_hw_sectors << SECTOR_SHIFT, in blk_atomic_writes_update_limits()
164 lim->atomic_write_max_sectors = in blk_atomic_writes_update_limits()
165 min(lim->atomic_write_hw_max >> SECTOR_SHIFT, in blk_atomic_writes_update_limits()
166 lim->max_hw_sectors); in blk_atomic_writes_update_limits()
167 lim->atomic_write_unit_min = in blk_atomic_writes_update_limits()
168 min(lim->atomic_write_hw_unit_min, unit_limit); in blk_atomic_writes_update_limits()
169 lim->atomic_write_unit_max = in blk_atomic_writes_update_limits()
170 min(lim->atomic_write_hw_unit_max, unit_limit); in blk_atomic_writes_update_limits()
171 lim->atomic_write_boundary_sectors = in blk_atomic_writes_update_limits()
172 lim->atomic_write_hw_boundary >> SECTOR_SHIFT; in blk_atomic_writes_update_limits()
179 if (!(lim->features & BLK_FEAT_ATOMIC_WRITES)) in blk_validate_atomic_write_limits()
182 if (!lim->atomic_write_hw_max) in blk_validate_atomic_write_limits()
185 if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_min))) in blk_validate_atomic_write_limits()
188 if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_max))) in blk_validate_atomic_write_limits()
191 if (WARN_ON_ONCE(lim->atomic_write_hw_unit_min > in blk_validate_atomic_write_limits()
192 lim->atomic_write_hw_unit_max)) in blk_validate_atomic_write_limits()
195 if (WARN_ON_ONCE(lim->atomic_write_hw_unit_max > in blk_validate_atomic_write_limits()
196 lim->atomic_write_hw_max)) in blk_validate_atomic_write_limits()
199 boundary_sectors = lim->atomic_write_hw_boundary >> SECTOR_SHIFT; in blk_validate_atomic_write_limits()
202 if (WARN_ON_ONCE(lim->atomic_write_hw_max > in blk_validate_atomic_write_limits()
203 lim->atomic_write_hw_boundary)) in blk_validate_atomic_write_limits()
211 * which is non-zero and smaller than atomic write HW boundary. in blk_validate_atomic_write_limits()
218 if (WARN_ON_ONCE(lim->chunk_sectors % boundary_sectors)) in blk_validate_atomic_write_limits()
223 * (and not necessarily a power-of-2), so this following check in blk_validate_atomic_write_limits()
226 * that it is compliant with a !power-of-2 boundary. in blk_validate_atomic_write_limits()
236 lim->atomic_write_max_sectors = 0; in blk_validate_atomic_write_limits()
237 lim->atomic_write_boundary_sectors = 0; in blk_validate_atomic_write_limits()
238 lim->atomic_write_unit_min = 0; in blk_validate_atomic_write_limits()
239 lim->atomic_write_unit_max = 0; in blk_validate_atomic_write_limits()
243 * Check that the limits in lim are valid, initialize defaults for unset
257 if (!lim->logical_block_size) in blk_validate_limits()
258 lim->logical_block_size = SECTOR_SIZE; in blk_validate_limits()
259 else if (blk_validate_block_size(lim->logical_block_size)) { in blk_validate_limits()
260 pr_warn("Invalid logical block size (%d)\n", lim->logical_block_size); in blk_validate_limits()
261 return -EINVAL; in blk_validate_limits()
263 if (lim->physical_block_size < lim->logical_block_size) in blk_validate_limits()
264 lim->physical_block_size = lim->logical_block_size; in blk_validate_limits()
270 if (lim->io_min < lim->physical_block_size) in blk_validate_limits()
271 lim->io_min = lim->physical_block_size; in blk_validate_limits()
278 lim->io_opt = round_down(lim->io_opt, lim->physical_block_size); in blk_validate_limits()
289 if (!lim->max_hw_sectors) in blk_validate_limits()
290 lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS; in blk_validate_limits()
291 if (WARN_ON_ONCE(lim->max_hw_sectors < PAGE_SECTORS)) in blk_validate_limits()
292 return -EINVAL; in blk_validate_limits()
293 logical_block_sectors = lim->logical_block_size >> SECTOR_SHIFT; in blk_validate_limits()
294 if (WARN_ON_ONCE(logical_block_sectors > lim->max_hw_sectors)) in blk_validate_limits()
295 return -EINVAL; in blk_validate_limits()
296 lim->max_hw_sectors = round_down(lim->max_hw_sectors, in blk_validate_limits()
302 * value into account. The ->max_sectors value is always calculated in blk_validate_limits()
305 max_hw_sectors = min_not_zero(lim->max_hw_sectors, in blk_validate_limits()
306 lim->max_dev_sectors); in blk_validate_limits()
307 if (lim->max_user_sectors) { in blk_validate_limits()
308 if (lim->max_user_sectors < BLK_MIN_SEGMENT_SIZE / SECTOR_SIZE) in blk_validate_limits()
309 return -EINVAL; in blk_validate_limits()
310 lim->max_sectors = min(max_hw_sectors, lim->max_user_sectors); in blk_validate_limits()
311 } else if (lim->io_opt > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) { in blk_validate_limits()
312 lim->max_sectors = in blk_validate_limits()
313 min(max_hw_sectors, lim->io_opt >> SECTOR_SHIFT); in blk_validate_limits()
314 } else if (lim->io_min > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) { in blk_validate_limits()
315 lim->max_sectors = in blk_validate_limits()
316 min(max_hw_sectors, lim->io_min >> SECTOR_SHIFT); in blk_validate_limits()
318 lim->max_sectors = min(max_hw_sectors, BLK_DEF_MAX_SECTORS_CAP); in blk_validate_limits()
320 lim->max_sectors = round_down(lim->max_sectors, in blk_validate_limits()
327 if (!lim->max_segments) in blk_validate_limits()
328 lim->max_segments = BLK_MAX_SEGMENTS; in blk_validate_limits()
330 lim->max_discard_sectors = in blk_validate_limits()
331 min(lim->max_hw_discard_sectors, lim->max_user_discard_sectors); in blk_validate_limits()
333 if (!lim->max_discard_segments) in blk_validate_limits()
334 lim->max_discard_segments = 1; in blk_validate_limits()
336 if (lim->discard_granularity < lim->physical_block_size) in blk_validate_limits()
337 lim->discard_granularity = lim->physical_block_size; in blk_validate_limits()
344 if (!lim->seg_boundary_mask) in blk_validate_limits()
345 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; in blk_validate_limits()
346 if (WARN_ON_ONCE(lim->seg_boundary_mask < BLK_MIN_SEGMENT_SIZE - 1)) in blk_validate_limits()
347 return -EINVAL; in blk_validate_limits()
351 * size limit, so allow this setting now, and long-term the two in blk_validate_limits()
352 * might need to move out of stacking limits since we have immutable in blk_validate_limits()
356 if (lim->virt_boundary_mask) { in blk_validate_limits()
357 if (!lim->max_segment_size) in blk_validate_limits()
358 lim->max_segment_size = UINT_MAX; in blk_validate_limits()
365 if (!lim->max_segment_size) in blk_validate_limits()
366 lim->max_segment_size = BLK_MAX_SEGMENT_SIZE; in blk_validate_limits()
367 if (WARN_ON_ONCE(lim->max_segment_size < BLK_MIN_SEGMENT_SIZE)) in blk_validate_limits()
368 return -EINVAL; in blk_validate_limits()
372 if (lim->seg_boundary_mask > lim->max_segment_size - 1) in blk_validate_limits()
373 seg_size = lim->max_segment_size; in blk_validate_limits()
375 seg_size = lim->seg_boundary_mask + 1; in blk_validate_limits()
376 lim->min_segment_size = min_t(unsigned int, seg_size, PAGE_SIZE); in blk_validate_limits()
381 * to set the limits. Once the transition is finished the check in blk_validate_limits()
384 if (!lim->dma_alignment) in blk_validate_limits()
385 lim->dma_alignment = SECTOR_SIZE - 1; in blk_validate_limits()
386 if (WARN_ON_ONCE(lim->dma_alignment > PAGE_SIZE)) in blk_validate_limits()
387 return -EINVAL; in blk_validate_limits()
389 if (lim->alignment_offset) { in blk_validate_limits()
390 lim->alignment_offset &= (lim->physical_block_size - 1); in blk_validate_limits()
391 lim->flags &= ~BLK_FLAG_MISALIGNED; in blk_validate_limits()
394 if (!(lim->features & BLK_FEAT_WRITE_CACHE)) in blk_validate_limits()
395 lim->features &= ~BLK_FEAT_FUA; in blk_validate_limits()
407 * Set the default limits for a newly allocated queue. @lim contains the
408 * initial limits set by the driver, which could be no limit in which case
418 lim->max_user_discard_sectors = UINT_MAX; in blk_set_default_limits()
423 * queue_limits_commit_update - commit an atomic update of queue limits
425 * @lim: limits to apply
427 * Apply the limits in @lim that were obtained from queue_limits_start_update()
443 if (q->crypto_profile && lim->integrity.tag_size) { in queue_limits_commit_update()
444 pr_warn("blk-integrity: Integrity and hardware inline encryption are not supported together.\n"); in queue_limits_commit_update()
445 error = -EINVAL; in queue_limits_commit_update()
450 q->limits = *lim; in queue_limits_commit_update()
451 if (q->disk) in queue_limits_commit_update()
452 blk_apply_bdi_limits(q->disk->bdi, lim); in queue_limits_commit_update()
454 mutex_unlock(&q->limits_lock); in queue_limits_commit_update()
460 * queue_limits_commit_update_frozen - commit an atomic update of queue limits
462 * @lim: limits to apply
464 * Apply the limits in @lim that were obtained from queue_limits_start_update()
485 * queue_limits_set - apply queue limits to queue
487 * @lim: limits to apply
489 * Apply the limits in @lim that were freshly initialized to @q.
490 * To update existing limits use queue_limits_start_update() and
497 mutex_lock(&q->limits_lock); in queue_limits_set()
505 unsigned int granularity = max(lim->physical_block_size, lim->io_min); in queue_limit_alignment_offset()
509 return (granularity + lim->alignment_offset - alignment) % granularity; in queue_limit_alignment_offset()
517 if (!lim->max_discard_sectors) in queue_limit_discard_alignment()
521 alignment = lim->discard_alignment >> SECTOR_SHIFT; in queue_limit_discard_alignment()
522 granularity = lim->discard_granularity >> SECTOR_SHIFT; in queue_limit_discard_alignment()
528 offset = (granularity + alignment - offset) % granularity; in queue_limit_discard_alignment()
547 if (t->atomic_write_hw_boundary != b->atomic_write_hw_boundary) in blk_stack_atomic_writes_tail()
551 if (t->atomic_write_hw_unit_min > b->atomic_write_hw_unit_max) in blk_stack_atomic_writes_tail()
555 if (t->atomic_write_hw_unit_max < b->atomic_write_hw_unit_min) in blk_stack_atomic_writes_tail()
558 t->atomic_write_hw_max = min(t->atomic_write_hw_max, in blk_stack_atomic_writes_tail()
559 b->atomic_write_hw_max); in blk_stack_atomic_writes_tail()
560 t->atomic_write_hw_unit_min = max(t->atomic_write_hw_unit_min, in blk_stack_atomic_writes_tail()
561 b->atomic_write_hw_unit_min); in blk_stack_atomic_writes_tail()
562 t->atomic_write_hw_unit_max = min(t->atomic_write_hw_unit_max, in blk_stack_atomic_writes_tail()
563 b->atomic_write_hw_unit_max); in blk_stack_atomic_writes_tail()
573 * devices store chunk sectors in t->io_min. in blk_stack_atomic_writes_boundary_head()
575 if (b->atomic_write_hw_boundary > t->io_min && in blk_stack_atomic_writes_boundary_head()
576 b->atomic_write_hw_boundary % t->io_min) in blk_stack_atomic_writes_boundary_head()
578 if (t->io_min > b->atomic_write_hw_boundary && in blk_stack_atomic_writes_boundary_head()
579 t->io_min % b->atomic_write_hw_boundary) in blk_stack_atomic_writes_boundary_head()
582 t->atomic_write_hw_boundary = b->atomic_write_hw_boundary; in blk_stack_atomic_writes_boundary_head()
591 if (b->atomic_write_hw_boundary && in blk_stack_atomic_writes_head()
595 if (t->io_min <= SECTOR_SIZE) { in blk_stack_atomic_writes_head()
597 t->atomic_write_hw_unit_max = b->atomic_write_hw_unit_max; in blk_stack_atomic_writes_head()
598 t->atomic_write_hw_unit_min = b->atomic_write_hw_unit_min; in blk_stack_atomic_writes_head()
599 t->atomic_write_hw_max = b->atomic_write_hw_max; in blk_stack_atomic_writes_head()
604 * Find values for limits which work for chunk size. in blk_stack_atomic_writes_head()
605 * b->atomic_write_hw_unit_{min, max} may not be aligned with chunk in blk_stack_atomic_writes_head()
606 * size (t->io_min), as chunk size is not restricted to a power-of-2. in blk_stack_atomic_writes_head()
607 * So we need to find highest power-of-2 which works for the chunk in blk_stack_atomic_writes_head()
609 * As an example scenario, we could have b->unit_max = 16K and in blk_stack_atomic_writes_head()
610 * t->io_min = 24K. For this case, reduce t->unit_max to a value in blk_stack_atomic_writes_head()
611 * aligned with both limits, i.e. 8K in this example. in blk_stack_atomic_writes_head()
613 t->atomic_write_hw_unit_max = b->atomic_write_hw_unit_max; in blk_stack_atomic_writes_head()
614 while (t->io_min % t->atomic_write_hw_unit_max) in blk_stack_atomic_writes_head()
615 t->atomic_write_hw_unit_max /= 2; in blk_stack_atomic_writes_head()
617 t->atomic_write_hw_unit_min = min(b->atomic_write_hw_unit_min, in blk_stack_atomic_writes_head()
618 t->atomic_write_hw_unit_max); in blk_stack_atomic_writes_head()
619 t->atomic_write_hw_max = min(b->atomic_write_hw_max, t->io_min); in blk_stack_atomic_writes_head()
627 if (!(b->features & BLK_FEAT_ATOMIC_WRITES)) in blk_stack_atomic_writes_limits()
630 if (!b->atomic_write_hw_unit_min) in blk_stack_atomic_writes_limits()
640 if (t->atomic_write_hw_max) { in blk_stack_atomic_writes_limits()
651 t->atomic_write_hw_max = 0; in blk_stack_atomic_writes_limits()
652 t->atomic_write_hw_unit_max = 0; in blk_stack_atomic_writes_limits()
653 t->atomic_write_hw_unit_min = 0; in blk_stack_atomic_writes_limits()
654 t->atomic_write_hw_boundary = 0; in blk_stack_atomic_writes_limits()
658 * blk_stack_limits - adjust queue_limits for stacked devices
659 * @t: the stacking driver limits (top device)
660 * @b: the underlying queue limits (bottom, component device)
674 * and alignments exist, -1 is returned and the resulting top
683 t->features |= (b->features & BLK_FEAT_INHERIT_MASK); in blk_stack_limits()
688 * stacking the limits, and this will clear the flags if any of the in blk_stack_limits()
691 if (!(b->features & BLK_FEAT_NOWAIT)) in blk_stack_limits()
692 t->features &= ~BLK_FEAT_NOWAIT; in blk_stack_limits()
693 if (!(b->features & BLK_FEAT_POLL)) in blk_stack_limits()
694 t->features &= ~BLK_FEAT_POLL; in blk_stack_limits()
696 t->flags |= (b->flags & BLK_FLAG_MISALIGNED); in blk_stack_limits()
698 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors); in blk_stack_limits()
699 t->max_user_sectors = min_not_zero(t->max_user_sectors, in blk_stack_limits()
700 b->max_user_sectors); in blk_stack_limits()
701 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors); in blk_stack_limits()
702 t->max_dev_sectors = min_not_zero(t->max_dev_sectors, b->max_dev_sectors); in blk_stack_limits()
703 t->max_write_zeroes_sectors = min(t->max_write_zeroes_sectors, in blk_stack_limits()
704 b->max_write_zeroes_sectors); in blk_stack_limits()
705 t->max_hw_zone_append_sectors = min(t->max_hw_zone_append_sectors, in blk_stack_limits()
706 b->max_hw_zone_append_sectors); in blk_stack_limits()
708 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, in blk_stack_limits()
709 b->seg_boundary_mask); in blk_stack_limits()
710 t->virt_boundary_mask = min_not_zero(t->virt_boundary_mask, in blk_stack_limits()
711 b->virt_boundary_mask); in blk_stack_limits()
713 t->max_segments = min_not_zero(t->max_segments, b->max_segments); in blk_stack_limits()
714 t->max_discard_segments = min_not_zero(t->max_discard_segments, in blk_stack_limits()
715 b->max_discard_segments); in blk_stack_limits()
716 t->max_integrity_segments = min_not_zero(t->max_integrity_segments, in blk_stack_limits()
717 b->max_integrity_segments); in blk_stack_limits()
719 t->max_segment_size = min_not_zero(t->max_segment_size, in blk_stack_limits()
720 b->max_segment_size); in blk_stack_limits()
727 if (t->alignment_offset != alignment) { in blk_stack_limits()
729 top = max(t->physical_block_size, t->io_min) in blk_stack_limits()
730 + t->alignment_offset; in blk_stack_limits()
731 bottom = max(b->physical_block_size, b->io_min) + alignment; in blk_stack_limits()
735 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
736 ret = -1; in blk_stack_limits()
740 t->logical_block_size = max(t->logical_block_size, in blk_stack_limits()
741 b->logical_block_size); in blk_stack_limits()
743 t->physical_block_size = max(t->physical_block_size, in blk_stack_limits()
744 b->physical_block_size); in blk_stack_limits()
746 t->io_min = max(t->io_min, b->io_min); in blk_stack_limits()
747 t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); in blk_stack_limits()
748 t->dma_alignment = max(t->dma_alignment, b->dma_alignment); in blk_stack_limits()
750 /* Set non-power-of-2 compatible chunk_sectors boundary */ in blk_stack_limits()
751 if (b->chunk_sectors) in blk_stack_limits()
752 t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); in blk_stack_limits()
755 if (t->physical_block_size & (t->logical_block_size - 1)) { in blk_stack_limits()
756 t->physical_block_size = t->logical_block_size; in blk_stack_limits()
757 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
758 ret = -1; in blk_stack_limits()
762 if (t->io_min & (t->physical_block_size - 1)) { in blk_stack_limits()
763 t->io_min = t->physical_block_size; in blk_stack_limits()
764 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
765 ret = -1; in blk_stack_limits()
769 if (t->io_opt & (t->physical_block_size - 1)) { in blk_stack_limits()
770 t->io_opt = 0; in blk_stack_limits()
771 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
772 ret = -1; in blk_stack_limits()
776 if ((t->chunk_sectors << 9) & (t->physical_block_size - 1)) { in blk_stack_limits()
777 t->chunk_sectors = 0; in blk_stack_limits()
778 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
779 ret = -1; in blk_stack_limits()
783 t->alignment_offset = lcm_not_zero(t->alignment_offset, alignment) in blk_stack_limits()
784 % max(t->physical_block_size, t->io_min); in blk_stack_limits()
787 if (t->alignment_offset & (t->logical_block_size - 1)) { in blk_stack_limits()
788 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
789 ret = -1; in blk_stack_limits()
792 t->max_sectors = blk_round_down_sectors(t->max_sectors, t->logical_block_size); in blk_stack_limits()
793 t->max_hw_sectors = blk_round_down_sectors(t->max_hw_sectors, t->logical_block_size); in blk_stack_limits()
794 t->max_dev_sectors = blk_round_down_sectors(t->max_dev_sectors, t->logical_block_size); in blk_stack_limits()
797 if (b->discard_granularity) { in blk_stack_limits()
800 t->max_discard_sectors = min_not_zero(t->max_discard_sectors, in blk_stack_limits()
801 b->max_discard_sectors); in blk_stack_limits()
802 t->max_hw_discard_sectors = min_not_zero(t->max_hw_discard_sectors, in blk_stack_limits()
803 b->max_hw_discard_sectors); in blk_stack_limits()
804 t->discard_granularity = max(t->discard_granularity, in blk_stack_limits()
805 b->discard_granularity); in blk_stack_limits()
806 t->discard_alignment = lcm_not_zero(t->discard_alignment, alignment) % in blk_stack_limits()
807 t->discard_granularity; in blk_stack_limits()
809 t->max_secure_erase_sectors = min_not_zero(t->max_secure_erase_sectors, in blk_stack_limits()
810 b->max_secure_erase_sectors); in blk_stack_limits()
811 t->zone_write_granularity = max(t->zone_write_granularity, in blk_stack_limits()
812 b->zone_write_granularity); in blk_stack_limits()
813 if (!(t->features & BLK_FEAT_ZONED)) { in blk_stack_limits()
814 t->zone_write_granularity = 0; in blk_stack_limits()
815 t->max_zone_append_sectors = 0; in blk_stack_limits()
824 * queue_limits_stack_bdev - adjust queue_limits for stacked devices
825 * @t: the stacking driver limits (top device)
849 * queue_limits_stack_integrity - stack integrity profile
850 * @t: target queue limits
851 * @b: base queue limits
865 struct blk_integrity *ti = &t->integrity; in queue_limits_stack_integrity()
866 struct blk_integrity *bi = &b->integrity; in queue_limits_stack_integrity()
871 if (ti->flags & BLK_INTEGRITY_STACKED) { in queue_limits_stack_integrity()
872 if (ti->tuple_size != bi->tuple_size) in queue_limits_stack_integrity()
874 if (ti->interval_exp != bi->interval_exp) in queue_limits_stack_integrity()
876 if (ti->tag_size != bi->tag_size) in queue_limits_stack_integrity()
878 if (ti->csum_type != bi->csum_type) in queue_limits_stack_integrity()
880 if ((ti->flags & BLK_INTEGRITY_REF_TAG) != in queue_limits_stack_integrity()
881 (bi->flags & BLK_INTEGRITY_REF_TAG)) in queue_limits_stack_integrity()
884 ti->flags = BLK_INTEGRITY_STACKED; in queue_limits_stack_integrity()
885 ti->flags |= (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE) | in queue_limits_stack_integrity()
886 (bi->flags & BLK_INTEGRITY_REF_TAG); in queue_limits_stack_integrity()
887 ti->csum_type = bi->csum_type; in queue_limits_stack_integrity()
888 ti->tuple_size = bi->tuple_size; in queue_limits_stack_integrity()
889 ti->pi_offset = bi->pi_offset; in queue_limits_stack_integrity()
890 ti->interval_exp = bi->interval_exp; in queue_limits_stack_integrity()
891 ti->tag_size = bi->tag_size; in queue_limits_stack_integrity()
902 * blk_set_queue_depth - tell the block layer about the device queue depth
909 q->queue_depth = depth; in blk_set_queue_depth()
918 if (q->limits.flags & BLK_FLAG_MISALIGNED) in bdev_alignment_offset()
919 return -1; in bdev_alignment_offset()
921 return queue_limit_alignment_offset(&q->limits, in bdev_alignment_offset()
922 bdev->bd_start_sect); in bdev_alignment_offset()
923 return q->limits.alignment_offset; in bdev_alignment_offset()
932 return queue_limit_discard_alignment(&q->limits, in bdev_discard_alignment()
933 bdev->bd_start_sect); in bdev_discard_alignment()
934 return q->limits.discard_alignment; in bdev_discard_alignment()