Lines Matching +full:queue +full:- +full:sizes
1 // SPDX-License-Identifier: GPL-2.0
3 * Functions related to setting various queue properties from drivers
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 WRITE_ONCE(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()
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 * There is no hardware limitation for the read-ahead size and the user in blk_apply_bdi_limits()
66 * might have increased the read-ahead size through sysfs, so don't ever in blk_apply_bdi_limits()
69 bdi->ra_pages = max3(bdi->ra_pages, in blk_apply_bdi_limits()
70 lim->io_opt * 2 / PAGE_SIZE, in blk_apply_bdi_limits()
72 bdi->io_pages = lim->max_sectors >> PAGE_SECTORS_SHIFT; in blk_apply_bdi_limits()
77 if (!(lim->features & BLK_FEAT_ZONED)) { in blk_validate_zoned_limits()
78 if (WARN_ON_ONCE(lim->max_open_zones) || in blk_validate_zoned_limits()
79 WARN_ON_ONCE(lim->max_active_zones) || in blk_validate_zoned_limits()
80 WARN_ON_ONCE(lim->zone_write_granularity) || in blk_validate_zoned_limits()
81 WARN_ON_ONCE(lim->max_zone_append_sectors)) in blk_validate_zoned_limits()
82 return -EINVAL; in blk_validate_zoned_limits()
87 return -EINVAL; in blk_validate_zoned_limits()
93 if (lim->max_active_zones && in blk_validate_zoned_limits()
94 lim->max_open_zones > lim->max_active_zones) in blk_validate_zoned_limits()
95 return -EINVAL; in blk_validate_zoned_limits()
97 if (lim->zone_write_granularity < lim->logical_block_size) in blk_validate_zoned_limits()
98 lim->zone_write_granularity = lim->logical_block_size; in blk_validate_zoned_limits()
107 lim->max_zone_append_sectors = in blk_validate_zoned_limits()
108 min_not_zero(lim->max_hw_zone_append_sectors, in blk_validate_zoned_limits()
109 min(lim->chunk_sectors, lim->max_hw_sectors)); in blk_validate_zoned_limits()
115 struct blk_integrity *bi = &lim->integrity; in blk_validate_integrity_limits()
117 if (!bi->tuple_size) { in blk_validate_integrity_limits()
118 if (bi->csum_type != BLK_INTEGRITY_CSUM_NONE || in blk_validate_integrity_limits()
119 bi->tag_size || ((bi->flags & BLK_INTEGRITY_REF_TAG))) { in blk_validate_integrity_limits()
121 return -EINVAL; in blk_validate_integrity_limits()
123 bi->flags |= BLK_INTEGRITY_NOGENERATE | BLK_INTEGRITY_NOVERIFY; in blk_validate_integrity_limits()
127 if (lim->features & BLK_FEAT_BOUNCE_HIGH) { in blk_validate_integrity_limits()
129 return -EINVAL; in blk_validate_integrity_limits()
134 return -EINVAL; in blk_validate_integrity_limits()
137 if (bi->csum_type == BLK_INTEGRITY_CSUM_NONE && in blk_validate_integrity_limits()
138 (bi->flags & BLK_INTEGRITY_REF_TAG)) { in blk_validate_integrity_limits()
140 return -EINVAL; in blk_validate_integrity_limits()
143 if (!bi->interval_exp) in blk_validate_integrity_limits()
144 bi->interval_exp = ilog2(lim->logical_block_size); in blk_validate_integrity_limits()
158 unsigned int max_segments = min(BIO_MAX_VECS, lim->max_segments); in blk_queue_max_guaranteed_bio()
161 length = min(max_segments, 2) * lim->logical_block_size; in blk_queue_max_guaranteed_bio()
163 length += (max_segments - 2) * PAGE_SIZE; in blk_queue_max_guaranteed_bio()
170 unsigned int unit_limit = min(lim->max_hw_sectors << SECTOR_SHIFT, in blk_atomic_writes_update_limits()
175 lim->atomic_write_max_sectors = in blk_atomic_writes_update_limits()
176 min(lim->atomic_write_hw_max >> SECTOR_SHIFT, in blk_atomic_writes_update_limits()
177 lim->max_hw_sectors); in blk_atomic_writes_update_limits()
178 lim->atomic_write_unit_min = in blk_atomic_writes_update_limits()
179 min(lim->atomic_write_hw_unit_min, unit_limit); in blk_atomic_writes_update_limits()
180 lim->atomic_write_unit_max = in blk_atomic_writes_update_limits()
181 min(lim->atomic_write_hw_unit_max, unit_limit); in blk_atomic_writes_update_limits()
182 lim->atomic_write_boundary_sectors = in blk_atomic_writes_update_limits()
183 lim->atomic_write_hw_boundary >> SECTOR_SHIFT; in blk_atomic_writes_update_limits()
190 if (!(lim->features & BLK_FEAT_ATOMIC_WRITES)) in blk_validate_atomic_write_limits()
193 if (!lim->atomic_write_hw_max) in blk_validate_atomic_write_limits()
196 if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_min))) in blk_validate_atomic_write_limits()
199 if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_max))) in blk_validate_atomic_write_limits()
202 if (WARN_ON_ONCE(lim->atomic_write_hw_unit_min > in blk_validate_atomic_write_limits()
203 lim->atomic_write_hw_unit_max)) in blk_validate_atomic_write_limits()
206 if (WARN_ON_ONCE(lim->atomic_write_hw_unit_max > in blk_validate_atomic_write_limits()
207 lim->atomic_write_hw_max)) in blk_validate_atomic_write_limits()
210 boundary_sectors = lim->atomic_write_hw_boundary >> SECTOR_SHIFT; in blk_validate_atomic_write_limits()
213 if (WARN_ON_ONCE(lim->atomic_write_hw_max > in blk_validate_atomic_write_limits()
214 lim->atomic_write_hw_boundary)) in blk_validate_atomic_write_limits()
222 * which is non-zero and smaller than atomic write HW boundary. in blk_validate_atomic_write_limits()
229 if (WARN_ON_ONCE(lim->chunk_sectors % boundary_sectors)) in blk_validate_atomic_write_limits()
234 * (and not necessarily a power-of-2), so this following check in blk_validate_atomic_write_limits()
237 * that it is compliant with a !power-of-2 boundary. in blk_validate_atomic_write_limits()
247 lim->atomic_write_max_sectors = 0; in blk_validate_atomic_write_limits()
248 lim->atomic_write_boundary_sectors = 0; in blk_validate_atomic_write_limits()
249 lim->atomic_write_unit_min = 0; in blk_validate_atomic_write_limits()
250 lim->atomic_write_unit_max = 0; in blk_validate_atomic_write_limits()
268 if (!lim->logical_block_size) in blk_validate_limits()
269 lim->logical_block_size = SECTOR_SIZE; in blk_validate_limits()
270 else if (blk_validate_block_size(lim->logical_block_size)) { in blk_validate_limits()
271 pr_warn("Invalid logical block size (%d)\n", lim->logical_block_size); in blk_validate_limits()
272 return -EINVAL; in blk_validate_limits()
274 if (lim->physical_block_size < lim->logical_block_size) in blk_validate_limits()
275 lim->physical_block_size = lim->logical_block_size; in blk_validate_limits()
281 if (lim->io_min < lim->physical_block_size) in blk_validate_limits()
282 lim->io_min = lim->physical_block_size; in blk_validate_limits()
289 lim->io_opt = round_down(lim->io_opt, lim->physical_block_size); in blk_validate_limits()
300 if (!lim->max_hw_sectors) in blk_validate_limits()
301 lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS; in blk_validate_limits()
302 if (WARN_ON_ONCE(lim->max_hw_sectors < PAGE_SECTORS)) in blk_validate_limits()
303 return -EINVAL; in blk_validate_limits()
304 logical_block_sectors = lim->logical_block_size >> SECTOR_SHIFT; in blk_validate_limits()
305 if (WARN_ON_ONCE(logical_block_sectors > lim->max_hw_sectors)) in blk_validate_limits()
306 return -EINVAL; in blk_validate_limits()
307 lim->max_hw_sectors = round_down(lim->max_hw_sectors, in blk_validate_limits()
313 * value into account. The ->max_sectors value is always calculated in blk_validate_limits()
316 max_hw_sectors = min_not_zero(lim->max_hw_sectors, in blk_validate_limits()
317 lim->max_dev_sectors); in blk_validate_limits()
318 if (lim->max_user_sectors) { in blk_validate_limits()
319 if (lim->max_user_sectors < BLK_MIN_SEGMENT_SIZE / SECTOR_SIZE) in blk_validate_limits()
320 return -EINVAL; in blk_validate_limits()
321 lim->max_sectors = min(max_hw_sectors, lim->max_user_sectors); in blk_validate_limits()
322 } else if (lim->io_opt > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) { in blk_validate_limits()
323 lim->max_sectors = in blk_validate_limits()
324 min(max_hw_sectors, lim->io_opt >> SECTOR_SHIFT); in blk_validate_limits()
325 } else if (lim->io_min > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) { in blk_validate_limits()
326 lim->max_sectors = in blk_validate_limits()
327 min(max_hw_sectors, lim->io_min >> SECTOR_SHIFT); in blk_validate_limits()
329 lim->max_sectors = min(max_hw_sectors, BLK_DEF_MAX_SECTORS_CAP); in blk_validate_limits()
331 lim->max_sectors = round_down(lim->max_sectors, in blk_validate_limits()
338 if (!lim->max_segments) in blk_validate_limits()
339 lim->max_segments = BLK_MAX_SEGMENTS; in blk_validate_limits()
341 lim->max_discard_sectors = in blk_validate_limits()
342 min(lim->max_hw_discard_sectors, lim->max_user_discard_sectors); in blk_validate_limits()
344 if (!lim->max_discard_segments) in blk_validate_limits()
345 lim->max_discard_segments = 1; in blk_validate_limits()
347 if (lim->discard_granularity < lim->physical_block_size) in blk_validate_limits()
348 lim->discard_granularity = lim->physical_block_size; in blk_validate_limits()
355 if (!lim->seg_boundary_mask) in blk_validate_limits()
356 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; in blk_validate_limits()
357 if (WARN_ON_ONCE(lim->seg_boundary_mask < BLK_MIN_SEGMENT_SIZE - 1)) in blk_validate_limits()
358 return -EINVAL; in blk_validate_limits()
362 * size limit, so allow this setting now, and long-term the two in blk_validate_limits()
367 if (lim->virt_boundary_mask) { in blk_validate_limits()
368 if (!lim->max_segment_size) in blk_validate_limits()
369 lim->max_segment_size = UINT_MAX; in blk_validate_limits()
376 if (!lim->max_segment_size) in blk_validate_limits()
377 lim->max_segment_size = BLK_MAX_SEGMENT_SIZE; in blk_validate_limits()
378 if (WARN_ON_ONCE(lim->max_segment_size < BLK_MIN_SEGMENT_SIZE)) in blk_validate_limits()
379 return -EINVAL; in blk_validate_limits()
383 if (lim->seg_boundary_mask > lim->max_segment_size - 1) in blk_validate_limits()
384 seg_size = lim->max_segment_size; in blk_validate_limits()
386 seg_size = lim->seg_boundary_mask + 1; in blk_validate_limits()
387 lim->min_segment_size = min_t(unsigned int, seg_size, PAGE_SIZE); in blk_validate_limits()
395 if (!lim->dma_alignment) in blk_validate_limits()
396 lim->dma_alignment = SECTOR_SIZE - 1; in blk_validate_limits()
397 if (WARN_ON_ONCE(lim->dma_alignment > PAGE_SIZE)) in blk_validate_limits()
398 return -EINVAL; in blk_validate_limits()
400 if (lim->alignment_offset) { in blk_validate_limits()
401 lim->alignment_offset &= (lim->physical_block_size - 1); in blk_validate_limits()
402 lim->flags &= ~BLK_FLAG_MISALIGNED; in blk_validate_limits()
405 if (!(lim->features & BLK_FEAT_WRITE_CACHE)) in blk_validate_limits()
406 lim->features &= ~BLK_FEAT_FUA; in blk_validate_limits()
418 * Set the default limits for a newly allocated queue. @lim contains the
429 lim->max_user_discard_sectors = UINT_MAX; in blk_set_default_limits()
434 * queue_limits_commit_update - commit an atomic update of queue limits
435 * @q: queue to update
439 * and updated by the caller to @q. The caller must have frozen the queue or
454 if (q->crypto_profile && lim->integrity.tag_size) { in queue_limits_commit_update()
455 pr_warn("blk-integrity: Integrity and hardware inline encryption are not supported together.\n"); in queue_limits_commit_update()
456 error = -EINVAL; in queue_limits_commit_update()
461 q->limits = *lim; in queue_limits_commit_update()
462 if (q->disk) in queue_limits_commit_update()
463 blk_apply_bdi_limits(q->disk->bdi, lim); in queue_limits_commit_update()
465 mutex_unlock(&q->limits_lock); in queue_limits_commit_update()
471 * queue_limits_commit_update_frozen - commit an atomic update of queue limits
472 * @q: queue to update
476 * and updated with the new values by the caller to @q. Freezes the queue
496 * queue_limits_set - apply queue limits to queue
497 * @q: queue to update
508 mutex_lock(&q->limits_lock); in queue_limits_set()
516 unsigned int granularity = max(lim->physical_block_size, lim->io_min); in queue_limit_alignment_offset()
520 return (granularity + lim->alignment_offset - alignment) % granularity; in queue_limit_alignment_offset()
528 if (!lim->max_discard_sectors) in queue_limit_discard_alignment()
532 alignment = lim->discard_alignment >> SECTOR_SHIFT; in queue_limit_discard_alignment()
533 granularity = lim->discard_granularity >> SECTOR_SHIFT; in queue_limit_discard_alignment()
539 offset = (granularity + alignment - offset) % granularity; in queue_limit_discard_alignment()
557 /* We're not going to support different boundary sizes.. yet */ in blk_stack_atomic_writes_tail()
558 if (t->atomic_write_hw_boundary != b->atomic_write_hw_boundary) in blk_stack_atomic_writes_tail()
562 if (t->atomic_write_hw_unit_min > b->atomic_write_hw_unit_max) in blk_stack_atomic_writes_tail()
566 if (t->atomic_write_hw_unit_max < b->atomic_write_hw_unit_min) in blk_stack_atomic_writes_tail()
569 t->atomic_write_hw_max = min(t->atomic_write_hw_max, in blk_stack_atomic_writes_tail()
570 b->atomic_write_hw_max); in blk_stack_atomic_writes_tail()
571 t->atomic_write_hw_unit_min = max(t->atomic_write_hw_unit_min, in blk_stack_atomic_writes_tail()
572 b->atomic_write_hw_unit_min); in blk_stack_atomic_writes_tail()
573 t->atomic_write_hw_unit_max = min(t->atomic_write_hw_unit_max, in blk_stack_atomic_writes_tail()
574 b->atomic_write_hw_unit_max); in blk_stack_atomic_writes_tail()
584 * devices store chunk sectors in t->io_min. in blk_stack_atomic_writes_boundary_head()
586 if (b->atomic_write_hw_boundary > t->io_min && in blk_stack_atomic_writes_boundary_head()
587 b->atomic_write_hw_boundary % t->io_min) in blk_stack_atomic_writes_boundary_head()
589 if (t->io_min > b->atomic_write_hw_boundary && in blk_stack_atomic_writes_boundary_head()
590 t->io_min % b->atomic_write_hw_boundary) in blk_stack_atomic_writes_boundary_head()
593 t->atomic_write_hw_boundary = b->atomic_write_hw_boundary; in blk_stack_atomic_writes_boundary_head()
602 if (b->atomic_write_hw_boundary && in blk_stack_atomic_writes_head()
606 if (t->io_min <= SECTOR_SIZE) { in blk_stack_atomic_writes_head()
608 t->atomic_write_hw_unit_max = b->atomic_write_hw_unit_max; in blk_stack_atomic_writes_head()
609 t->atomic_write_hw_unit_min = b->atomic_write_hw_unit_min; in blk_stack_atomic_writes_head()
610 t->atomic_write_hw_max = b->atomic_write_hw_max; in blk_stack_atomic_writes_head()
616 * b->atomic_write_hw_unit_{min, max} may not be aligned with chunk in blk_stack_atomic_writes_head()
617 * size (t->io_min), as chunk size is not restricted to a power-of-2. in blk_stack_atomic_writes_head()
618 * So we need to find highest power-of-2 which works for the chunk in blk_stack_atomic_writes_head()
620 * As an example scenario, we could have b->unit_max = 16K and in blk_stack_atomic_writes_head()
621 * t->io_min = 24K. For this case, reduce t->unit_max to a value in blk_stack_atomic_writes_head()
624 t->atomic_write_hw_unit_max = b->atomic_write_hw_unit_max; in blk_stack_atomic_writes_head()
625 while (t->io_min % t->atomic_write_hw_unit_max) in blk_stack_atomic_writes_head()
626 t->atomic_write_hw_unit_max /= 2; in blk_stack_atomic_writes_head()
628 t->atomic_write_hw_unit_min = min(b->atomic_write_hw_unit_min, in blk_stack_atomic_writes_head()
629 t->atomic_write_hw_unit_max); in blk_stack_atomic_writes_head()
630 t->atomic_write_hw_max = min(b->atomic_write_hw_max, t->io_min); in blk_stack_atomic_writes_head()
638 if (!(b->features & BLK_FEAT_ATOMIC_WRITES)) in blk_stack_atomic_writes_limits()
641 if (!b->atomic_write_hw_unit_min) in blk_stack_atomic_writes_limits()
651 if (t->atomic_write_hw_max) { in blk_stack_atomic_writes_limits()
662 t->atomic_write_hw_max = 0; in blk_stack_atomic_writes_limits()
663 t->atomic_write_hw_unit_max = 0; in blk_stack_atomic_writes_limits()
664 t->atomic_write_hw_unit_min = 0; in blk_stack_atomic_writes_limits()
665 t->atomic_write_hw_boundary = 0; in blk_stack_atomic_writes_limits()
669 * blk_stack_limits - adjust queue_limits for stacked devices
671 * @b: the underlying queue limits (bottom, component device)
676 * that all component devices have compatible block sizes and
683 * top device's block sizes and alignment offsets may be adjusted to
684 * ensure alignment with the bottom device. If no compatible sizes
685 * and alignments exist, -1 is returned and the resulting top
694 t->features |= (b->features & BLK_FEAT_INHERIT_MASK); in blk_stack_limits()
702 if (!(b->features & BLK_FEAT_NOWAIT)) in blk_stack_limits()
703 t->features &= ~BLK_FEAT_NOWAIT; in blk_stack_limits()
704 if (!(b->features & BLK_FEAT_POLL)) in blk_stack_limits()
705 t->features &= ~BLK_FEAT_POLL; in blk_stack_limits()
707 t->flags |= (b->flags & BLK_FLAG_MISALIGNED); in blk_stack_limits()
709 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors); in blk_stack_limits()
710 t->max_user_sectors = min_not_zero(t->max_user_sectors, in blk_stack_limits()
711 b->max_user_sectors); in blk_stack_limits()
712 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors); in blk_stack_limits()
713 t->max_dev_sectors = min_not_zero(t->max_dev_sectors, b->max_dev_sectors); in blk_stack_limits()
714 t->max_write_zeroes_sectors = min(t->max_write_zeroes_sectors, in blk_stack_limits()
715 b->max_write_zeroes_sectors); in blk_stack_limits()
716 t->max_hw_zone_append_sectors = min(t->max_hw_zone_append_sectors, in blk_stack_limits()
717 b->max_hw_zone_append_sectors); in blk_stack_limits()
719 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, in blk_stack_limits()
720 b->seg_boundary_mask); in blk_stack_limits()
721 t->virt_boundary_mask = min_not_zero(t->virt_boundary_mask, in blk_stack_limits()
722 b->virt_boundary_mask); in blk_stack_limits()
724 t->max_segments = min_not_zero(t->max_segments, b->max_segments); in blk_stack_limits()
725 t->max_discard_segments = min_not_zero(t->max_discard_segments, in blk_stack_limits()
726 b->max_discard_segments); in blk_stack_limits()
727 t->max_integrity_segments = min_not_zero(t->max_integrity_segments, in blk_stack_limits()
728 b->max_integrity_segments); in blk_stack_limits()
730 t->max_segment_size = min_not_zero(t->max_segment_size, in blk_stack_limits()
731 b->max_segment_size); in blk_stack_limits()
738 if (t->alignment_offset != alignment) { in blk_stack_limits()
740 top = max(t->physical_block_size, t->io_min) in blk_stack_limits()
741 + t->alignment_offset; in blk_stack_limits()
742 bottom = max(b->physical_block_size, b->io_min) + alignment; in blk_stack_limits()
746 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
747 ret = -1; in blk_stack_limits()
751 t->logical_block_size = max(t->logical_block_size, in blk_stack_limits()
752 b->logical_block_size); in blk_stack_limits()
754 t->physical_block_size = max(t->physical_block_size, in blk_stack_limits()
755 b->physical_block_size); in blk_stack_limits()
757 t->io_min = max(t->io_min, b->io_min); in blk_stack_limits()
758 t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); in blk_stack_limits()
759 t->dma_alignment = max(t->dma_alignment, b->dma_alignment); in blk_stack_limits()
761 /* Set non-power-of-2 compatible chunk_sectors boundary */ in blk_stack_limits()
762 if (b->chunk_sectors) in blk_stack_limits()
763 t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); in blk_stack_limits()
766 if (t->physical_block_size & (t->logical_block_size - 1)) { in blk_stack_limits()
767 t->physical_block_size = t->logical_block_size; in blk_stack_limits()
768 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
769 ret = -1; in blk_stack_limits()
773 if (t->io_min & (t->physical_block_size - 1)) { in blk_stack_limits()
774 t->io_min = t->physical_block_size; in blk_stack_limits()
775 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
776 ret = -1; in blk_stack_limits()
780 if (t->io_opt & (t->physical_block_size - 1)) { in blk_stack_limits()
781 t->io_opt = 0; in blk_stack_limits()
782 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
783 ret = -1; in blk_stack_limits()
787 if ((t->chunk_sectors << 9) & (t->physical_block_size - 1)) { in blk_stack_limits()
788 t->chunk_sectors = 0; in blk_stack_limits()
789 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
790 ret = -1; in blk_stack_limits()
794 t->alignment_offset = lcm_not_zero(t->alignment_offset, alignment) in blk_stack_limits()
795 % max(t->physical_block_size, t->io_min); in blk_stack_limits()
798 if (t->alignment_offset & (t->logical_block_size - 1)) { in blk_stack_limits()
799 t->flags |= BLK_FLAG_MISALIGNED; in blk_stack_limits()
800 ret = -1; in blk_stack_limits()
803 t->max_sectors = blk_round_down_sectors(t->max_sectors, t->logical_block_size); in blk_stack_limits()
804 t->max_hw_sectors = blk_round_down_sectors(t->max_hw_sectors, t->logical_block_size); in blk_stack_limits()
805 t->max_dev_sectors = blk_round_down_sectors(t->max_dev_sectors, t->logical_block_size); in blk_stack_limits()
808 if (b->discard_granularity) { in blk_stack_limits()
811 t->max_discard_sectors = min_not_zero(t->max_discard_sectors, in blk_stack_limits()
812 b->max_discard_sectors); in blk_stack_limits()
813 t->max_hw_discard_sectors = min_not_zero(t->max_hw_discard_sectors, in blk_stack_limits()
814 b->max_hw_discard_sectors); in blk_stack_limits()
815 t->discard_granularity = max(t->discard_granularity, in blk_stack_limits()
816 b->discard_granularity); in blk_stack_limits()
817 t->discard_alignment = lcm_not_zero(t->discard_alignment, alignment) % in blk_stack_limits()
818 t->discard_granularity; in blk_stack_limits()
820 t->max_secure_erase_sectors = min_not_zero(t->max_secure_erase_sectors, in blk_stack_limits()
821 b->max_secure_erase_sectors); in blk_stack_limits()
822 t->zone_write_granularity = max(t->zone_write_granularity, in blk_stack_limits()
823 b->zone_write_granularity); in blk_stack_limits()
824 if (!(t->features & BLK_FEAT_ZONED)) { in blk_stack_limits()
825 t->zone_write_granularity = 0; in blk_stack_limits()
826 t->max_zone_append_sectors = 0; in blk_stack_limits()
835 * queue_limits_stack_bdev - adjust queue_limits for stacked devices
843 * that all component devices have compatible block sizes and
860 * queue_limits_stack_integrity - stack integrity profile
861 * @t: target queue limits
862 * @b: base queue limits
876 struct blk_integrity *ti = &t->integrity; in queue_limits_stack_integrity()
877 struct blk_integrity *bi = &b->integrity; in queue_limits_stack_integrity()
882 if (ti->flags & BLK_INTEGRITY_STACKED) { in queue_limits_stack_integrity()
883 if (ti->tuple_size != bi->tuple_size) in queue_limits_stack_integrity()
885 if (ti->interval_exp != bi->interval_exp) in queue_limits_stack_integrity()
887 if (ti->tag_size != bi->tag_size) in queue_limits_stack_integrity()
889 if (ti->csum_type != bi->csum_type) in queue_limits_stack_integrity()
891 if ((ti->flags & BLK_INTEGRITY_REF_TAG) != in queue_limits_stack_integrity()
892 (bi->flags & BLK_INTEGRITY_REF_TAG)) in queue_limits_stack_integrity()
895 ti->flags = BLK_INTEGRITY_STACKED; in queue_limits_stack_integrity()
896 ti->flags |= (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE) | in queue_limits_stack_integrity()
897 (bi->flags & BLK_INTEGRITY_REF_TAG); in queue_limits_stack_integrity()
898 ti->csum_type = bi->csum_type; in queue_limits_stack_integrity()
899 ti->tuple_size = bi->tuple_size; in queue_limits_stack_integrity()
900 ti->pi_offset = bi->pi_offset; in queue_limits_stack_integrity()
901 ti->interval_exp = bi->interval_exp; in queue_limits_stack_integrity()
902 ti->tag_size = bi->tag_size; in queue_limits_stack_integrity()
913 * blk_set_queue_depth - tell the block layer about the device queue depth
914 * @q: the request queue for the device
915 * @depth: queue depth
920 q->queue_depth = depth; in blk_set_queue_depth()
929 if (q->limits.flags & BLK_FLAG_MISALIGNED) in bdev_alignment_offset()
930 return -1; in bdev_alignment_offset()
932 return queue_limit_alignment_offset(&q->limits, in bdev_alignment_offset()
933 bdev->bd_start_sect); in bdev_alignment_offset()
934 return q->limits.alignment_offset; in bdev_alignment_offset()
943 return queue_limit_discard_alignment(&q->limits, in bdev_discard_alignment()
944 bdev->bd_start_sect); in bdev_discard_alignment()
945 return q->limits.discard_alignment; in bdev_discard_alignment()