1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Functions related to setting various queue properties from drivers 4 */ 5 #include <linux/kernel.h> 6 #include <linux/module.h> 7 #include <linux/init.h> 8 #include <linux/bio.h> 9 #include <linux/blkdev.h> 10 #include <linux/pagemap.h> 11 #include <linux/backing-dev-defs.h> 12 #include <linux/gcd.h> 13 #include <linux/lcm.h> 14 #include <linux/jiffies.h> 15 #include <linux/gfp.h> 16 #include <linux/dma-mapping.h> 17 18 #include "blk.h" 19 #include "blk-rq-qos.h" 20 #include "blk-wbt.h" 21 22 void blk_queue_rq_timeout(struct request_queue *q, unsigned int timeout) 23 { 24 q->rq_timeout = timeout; 25 } 26 EXPORT_SYMBOL_GPL(blk_queue_rq_timeout); 27 28 /** 29 * blk_set_stacking_limits - set default limits for stacking devices 30 * @lim: the queue_limits structure to reset 31 * 32 * Prepare queue limits for applying limits from underlying devices using 33 * blk_stack_limits(). 34 */ 35 void blk_set_stacking_limits(struct queue_limits *lim) 36 { 37 memset(lim, 0, sizeof(*lim)); 38 lim->logical_block_size = SECTOR_SIZE; 39 lim->physical_block_size = SECTOR_SIZE; 40 lim->io_min = SECTOR_SIZE; 41 lim->discard_granularity = SECTOR_SIZE; 42 lim->dma_alignment = SECTOR_SIZE - 1; 43 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; 44 45 /* Inherit limits from component devices */ 46 lim->max_segments = USHRT_MAX; 47 lim->max_discard_segments = USHRT_MAX; 48 lim->max_hw_sectors = UINT_MAX; 49 lim->max_segment_size = UINT_MAX; 50 lim->max_sectors = UINT_MAX; 51 lim->max_dev_sectors = UINT_MAX; 52 lim->max_write_zeroes_sectors = UINT_MAX; 53 lim->max_zone_append_sectors = UINT_MAX; 54 lim->max_user_discard_sectors = UINT_MAX; 55 } 56 EXPORT_SYMBOL(blk_set_stacking_limits); 57 58 static void blk_apply_bdi_limits(struct backing_dev_info *bdi, 59 struct queue_limits *lim) 60 { 61 /* 62 * For read-ahead of large files to be effective, we need to read ahead 63 * at least twice the optimal I/O size. 64 */ 65 bdi->ra_pages = max(lim->io_opt * 2 / PAGE_SIZE, VM_READAHEAD_PAGES); 66 bdi->io_pages = lim->max_sectors >> PAGE_SECTORS_SHIFT; 67 } 68 69 static int blk_validate_zoned_limits(struct queue_limits *lim) 70 { 71 if (!lim->zoned) { 72 if (WARN_ON_ONCE(lim->max_open_zones) || 73 WARN_ON_ONCE(lim->max_active_zones) || 74 WARN_ON_ONCE(lim->zone_write_granularity) || 75 WARN_ON_ONCE(lim->max_zone_append_sectors)) 76 return -EINVAL; 77 return 0; 78 } 79 80 if (WARN_ON_ONCE(!IS_ENABLED(CONFIG_BLK_DEV_ZONED))) 81 return -EINVAL; 82 83 if (lim->zone_write_granularity < lim->logical_block_size) 84 lim->zone_write_granularity = lim->logical_block_size; 85 86 if (lim->max_zone_append_sectors) { 87 /* 88 * The Zone Append size is limited by the maximum I/O size 89 * and the zone size given that it can't span zones. 90 */ 91 lim->max_zone_append_sectors = 92 min3(lim->max_hw_sectors, 93 lim->max_zone_append_sectors, 94 lim->chunk_sectors); 95 } 96 97 return 0; 98 } 99 100 /* 101 * Check that the limits in lim are valid, initialize defaults for unset 102 * values, and cap values based on others where needed. 103 */ 104 static int blk_validate_limits(struct queue_limits *lim) 105 { 106 unsigned int max_hw_sectors; 107 108 /* 109 * Unless otherwise specified, default to 512 byte logical blocks and a 110 * physical block size equal to the logical block size. 111 */ 112 if (!lim->logical_block_size) 113 lim->logical_block_size = SECTOR_SIZE; 114 if (lim->physical_block_size < lim->logical_block_size) 115 lim->physical_block_size = lim->logical_block_size; 116 117 /* 118 * The minimum I/O size defaults to the physical block size unless 119 * explicitly overridden. 120 */ 121 if (lim->io_min < lim->physical_block_size) 122 lim->io_min = lim->physical_block_size; 123 124 /* 125 * max_hw_sectors has a somewhat weird default for historical reason, 126 * but driver really should set their own instead of relying on this 127 * value. 128 * 129 * The block layer relies on the fact that every driver can 130 * handle at lest a page worth of data per I/O, and needs the value 131 * aligned to the logical block size. 132 */ 133 if (!lim->max_hw_sectors) 134 lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS; 135 if (WARN_ON_ONCE(lim->max_hw_sectors < PAGE_SECTORS)) 136 return -EINVAL; 137 lim->max_hw_sectors = round_down(lim->max_hw_sectors, 138 lim->logical_block_size >> SECTOR_SHIFT); 139 140 /* 141 * The actual max_sectors value is a complex beast and also takes the 142 * max_dev_sectors value (set by SCSI ULPs) and a user configurable 143 * value into account. The ->max_sectors value is always calculated 144 * from these, so directly setting it won't have any effect. 145 */ 146 max_hw_sectors = min_not_zero(lim->max_hw_sectors, 147 lim->max_dev_sectors); 148 if (lim->max_user_sectors) { 149 if (lim->max_user_sectors > max_hw_sectors || 150 lim->max_user_sectors < PAGE_SIZE / SECTOR_SIZE) 151 return -EINVAL; 152 lim->max_sectors = min(max_hw_sectors, lim->max_user_sectors); 153 } else { 154 lim->max_sectors = min(max_hw_sectors, BLK_DEF_MAX_SECTORS_CAP); 155 } 156 lim->max_sectors = round_down(lim->max_sectors, 157 lim->logical_block_size >> SECTOR_SHIFT); 158 159 /* 160 * Random default for the maximum number of segments. Driver should not 161 * rely on this and set their own. 162 */ 163 if (!lim->max_segments) 164 lim->max_segments = BLK_MAX_SEGMENTS; 165 166 lim->max_discard_sectors = 167 min(lim->max_hw_discard_sectors, lim->max_user_discard_sectors); 168 169 if (!lim->max_discard_segments) 170 lim->max_discard_segments = 1; 171 172 if (lim->discard_granularity < lim->physical_block_size) 173 lim->discard_granularity = lim->physical_block_size; 174 175 /* 176 * By default there is no limit on the segment boundary alignment, 177 * but if there is one it can't be smaller than the page size as 178 * that would break all the normal I/O patterns. 179 */ 180 if (!lim->seg_boundary_mask) 181 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK; 182 if (WARN_ON_ONCE(lim->seg_boundary_mask < PAGE_SIZE - 1)) 183 return -EINVAL; 184 185 /* 186 * Devices that require a virtual boundary do not support scatter/gather 187 * I/O natively, but instead require a descriptor list entry for each 188 * page (which might not be identical to the Linux PAGE_SIZE). Because 189 * of that they are not limited by our notion of "segment size". 190 */ 191 if (lim->virt_boundary_mask) { 192 if (WARN_ON_ONCE(lim->max_segment_size && 193 lim->max_segment_size != UINT_MAX)) 194 return -EINVAL; 195 lim->max_segment_size = UINT_MAX; 196 } else { 197 /* 198 * The maximum segment size has an odd historic 64k default that 199 * drivers probably should override. Just like the I/O size we 200 * require drivers to at least handle a full page per segment. 201 */ 202 if (!lim->max_segment_size) 203 lim->max_segment_size = BLK_MAX_SEGMENT_SIZE; 204 if (WARN_ON_ONCE(lim->max_segment_size < PAGE_SIZE)) 205 return -EINVAL; 206 } 207 208 /* 209 * We require drivers to at least do logical block aligned I/O, but 210 * historically could not check for that due to the separate calls 211 * to set the limits. Once the transition is finished the check 212 * below should be narrowed down to check the logical block size. 213 */ 214 if (!lim->dma_alignment) 215 lim->dma_alignment = SECTOR_SIZE - 1; 216 if (WARN_ON_ONCE(lim->dma_alignment > PAGE_SIZE)) 217 return -EINVAL; 218 219 if (lim->alignment_offset) { 220 lim->alignment_offset &= (lim->physical_block_size - 1); 221 lim->misaligned = 0; 222 } 223 224 return blk_validate_zoned_limits(lim); 225 } 226 227 /* 228 * Set the default limits for a newly allocated queue. @lim contains the 229 * initial limits set by the driver, which could be no limit in which case 230 * all fields are cleared to zero. 231 */ 232 int blk_set_default_limits(struct queue_limits *lim) 233 { 234 /* 235 * Most defaults are set by capping the bounds in blk_validate_limits, 236 * but max_user_discard_sectors is special and needs an explicit 237 * initialization to the max value here. 238 */ 239 lim->max_user_discard_sectors = UINT_MAX; 240 return blk_validate_limits(lim); 241 } 242 243 /** 244 * queue_limits_commit_update - commit an atomic update of queue limits 245 * @q: queue to update 246 * @lim: limits to apply 247 * 248 * Apply the limits in @lim that were obtained from queue_limits_start_update() 249 * and updated by the caller to @q. 250 * 251 * Returns 0 if successful, else a negative error code. 252 */ 253 int queue_limits_commit_update(struct request_queue *q, 254 struct queue_limits *lim) 255 __releases(q->limits_lock) 256 { 257 int error = blk_validate_limits(lim); 258 259 if (!error) { 260 q->limits = *lim; 261 if (q->disk) 262 blk_apply_bdi_limits(q->disk->bdi, lim); 263 } 264 mutex_unlock(&q->limits_lock); 265 return error; 266 } 267 EXPORT_SYMBOL_GPL(queue_limits_commit_update); 268 269 /** 270 * queue_limits_set - apply queue limits to queue 271 * @q: queue to update 272 * @lim: limits to apply 273 * 274 * Apply the limits in @lim that were freshly initialized to @q. 275 * To update existing limits use queue_limits_start_update() and 276 * queue_limits_commit_update() instead. 277 * 278 * Returns 0 if successful, else a negative error code. 279 */ 280 int queue_limits_set(struct request_queue *q, struct queue_limits *lim) 281 { 282 mutex_lock(&q->limits_lock); 283 return queue_limits_commit_update(q, lim); 284 } 285 EXPORT_SYMBOL_GPL(queue_limits_set); 286 287 /** 288 * blk_queue_chunk_sectors - set size of the chunk for this queue 289 * @q: the request queue for the device 290 * @chunk_sectors: chunk sectors in the usual 512b unit 291 * 292 * Description: 293 * If a driver doesn't want IOs to cross a given chunk size, it can set 294 * this limit and prevent merging across chunks. Note that the block layer 295 * must accept a page worth of data at any offset. So if the crossing of 296 * chunks is a hard limitation in the driver, it must still be prepared 297 * to split single page bios. 298 **/ 299 void blk_queue_chunk_sectors(struct request_queue *q, unsigned int chunk_sectors) 300 { 301 q->limits.chunk_sectors = chunk_sectors; 302 } 303 EXPORT_SYMBOL(blk_queue_chunk_sectors); 304 305 /** 306 * blk_queue_max_discard_sectors - set max sectors for a single discard 307 * @q: the request queue for the device 308 * @max_discard_sectors: maximum number of sectors to discard 309 **/ 310 void blk_queue_max_discard_sectors(struct request_queue *q, 311 unsigned int max_discard_sectors) 312 { 313 struct queue_limits *lim = &q->limits; 314 315 lim->max_hw_discard_sectors = max_discard_sectors; 316 lim->max_discard_sectors = 317 min(max_discard_sectors, lim->max_user_discard_sectors); 318 } 319 EXPORT_SYMBOL(blk_queue_max_discard_sectors); 320 321 /** 322 * blk_queue_max_secure_erase_sectors - set max sectors for a secure erase 323 * @q: the request queue for the device 324 * @max_sectors: maximum number of sectors to secure_erase 325 **/ 326 void blk_queue_max_secure_erase_sectors(struct request_queue *q, 327 unsigned int max_sectors) 328 { 329 q->limits.max_secure_erase_sectors = max_sectors; 330 } 331 EXPORT_SYMBOL(blk_queue_max_secure_erase_sectors); 332 333 /** 334 * blk_queue_max_write_zeroes_sectors - set max sectors for a single 335 * write zeroes 336 * @q: the request queue for the device 337 * @max_write_zeroes_sectors: maximum number of sectors to write per command 338 **/ 339 void blk_queue_max_write_zeroes_sectors(struct request_queue *q, 340 unsigned int max_write_zeroes_sectors) 341 { 342 q->limits.max_write_zeroes_sectors = max_write_zeroes_sectors; 343 } 344 EXPORT_SYMBOL(blk_queue_max_write_zeroes_sectors); 345 346 /** 347 * blk_queue_max_zone_append_sectors - set max sectors for a single zone append 348 * @q: the request queue for the device 349 * @max_zone_append_sectors: maximum number of sectors to write per command 350 **/ 351 void blk_queue_max_zone_append_sectors(struct request_queue *q, 352 unsigned int max_zone_append_sectors) 353 { 354 unsigned int max_sectors; 355 356 if (WARN_ON(!blk_queue_is_zoned(q))) 357 return; 358 359 max_sectors = min(q->limits.max_hw_sectors, max_zone_append_sectors); 360 max_sectors = min(q->limits.chunk_sectors, max_sectors); 361 362 /* 363 * Signal eventual driver bugs resulting in the max_zone_append sectors limit 364 * being 0 due to a 0 argument, the chunk_sectors limit (zone size) not set, 365 * or the max_hw_sectors limit not set. 366 */ 367 WARN_ON(!max_sectors); 368 369 q->limits.max_zone_append_sectors = max_sectors; 370 } 371 EXPORT_SYMBOL_GPL(blk_queue_max_zone_append_sectors); 372 373 /** 374 * blk_queue_logical_block_size - set logical block size for the queue 375 * @q: the request queue for the device 376 * @size: the logical block size, in bytes 377 * 378 * Description: 379 * This should be set to the lowest possible block size that the 380 * storage device can address. The default of 512 covers most 381 * hardware. 382 **/ 383 void blk_queue_logical_block_size(struct request_queue *q, unsigned int size) 384 { 385 struct queue_limits *limits = &q->limits; 386 387 limits->logical_block_size = size; 388 389 if (limits->discard_granularity < limits->logical_block_size) 390 limits->discard_granularity = limits->logical_block_size; 391 392 if (limits->physical_block_size < size) 393 limits->physical_block_size = size; 394 395 if (limits->io_min < limits->physical_block_size) 396 limits->io_min = limits->physical_block_size; 397 398 limits->max_hw_sectors = 399 round_down(limits->max_hw_sectors, size >> SECTOR_SHIFT); 400 limits->max_sectors = 401 round_down(limits->max_sectors, size >> SECTOR_SHIFT); 402 } 403 EXPORT_SYMBOL(blk_queue_logical_block_size); 404 405 /** 406 * blk_queue_physical_block_size - set physical block size for the queue 407 * @q: the request queue for the device 408 * @size: the physical block size, in bytes 409 * 410 * Description: 411 * This should be set to the lowest possible sector size that the 412 * hardware can operate on without reverting to read-modify-write 413 * operations. 414 */ 415 void blk_queue_physical_block_size(struct request_queue *q, unsigned int size) 416 { 417 q->limits.physical_block_size = size; 418 419 if (q->limits.physical_block_size < q->limits.logical_block_size) 420 q->limits.physical_block_size = q->limits.logical_block_size; 421 422 if (q->limits.discard_granularity < q->limits.physical_block_size) 423 q->limits.discard_granularity = q->limits.physical_block_size; 424 425 if (q->limits.io_min < q->limits.physical_block_size) 426 q->limits.io_min = q->limits.physical_block_size; 427 } 428 EXPORT_SYMBOL(blk_queue_physical_block_size); 429 430 /** 431 * blk_queue_zone_write_granularity - set zone write granularity for the queue 432 * @q: the request queue for the zoned device 433 * @size: the zone write granularity size, in bytes 434 * 435 * Description: 436 * This should be set to the lowest possible size allowing to write in 437 * sequential zones of a zoned block device. 438 */ 439 void blk_queue_zone_write_granularity(struct request_queue *q, 440 unsigned int size) 441 { 442 if (WARN_ON_ONCE(!blk_queue_is_zoned(q))) 443 return; 444 445 q->limits.zone_write_granularity = size; 446 447 if (q->limits.zone_write_granularity < q->limits.logical_block_size) 448 q->limits.zone_write_granularity = q->limits.logical_block_size; 449 } 450 EXPORT_SYMBOL_GPL(blk_queue_zone_write_granularity); 451 452 /** 453 * blk_queue_alignment_offset - set physical block alignment offset 454 * @q: the request queue for the device 455 * @offset: alignment offset in bytes 456 * 457 * Description: 458 * Some devices are naturally misaligned to compensate for things like 459 * the legacy DOS partition table 63-sector offset. Low-level drivers 460 * should call this function for devices whose first sector is not 461 * naturally aligned. 462 */ 463 void blk_queue_alignment_offset(struct request_queue *q, unsigned int offset) 464 { 465 q->limits.alignment_offset = 466 offset & (q->limits.physical_block_size - 1); 467 q->limits.misaligned = 0; 468 } 469 EXPORT_SYMBOL(blk_queue_alignment_offset); 470 471 void disk_update_readahead(struct gendisk *disk) 472 { 473 blk_apply_bdi_limits(disk->bdi, &disk->queue->limits); 474 } 475 EXPORT_SYMBOL_GPL(disk_update_readahead); 476 477 /** 478 * blk_limits_io_min - set minimum request size for a device 479 * @limits: the queue limits 480 * @min: smallest I/O size in bytes 481 * 482 * Description: 483 * Some devices have an internal block size bigger than the reported 484 * hardware sector size. This function can be used to signal the 485 * smallest I/O the device can perform without incurring a performance 486 * penalty. 487 */ 488 void blk_limits_io_min(struct queue_limits *limits, unsigned int min) 489 { 490 limits->io_min = min; 491 492 if (limits->io_min < limits->logical_block_size) 493 limits->io_min = limits->logical_block_size; 494 495 if (limits->io_min < limits->physical_block_size) 496 limits->io_min = limits->physical_block_size; 497 } 498 EXPORT_SYMBOL(blk_limits_io_min); 499 500 /** 501 * blk_queue_io_min - set minimum request size for the queue 502 * @q: the request queue for the device 503 * @min: smallest I/O size in bytes 504 * 505 * Description: 506 * Storage devices may report a granularity or preferred minimum I/O 507 * size which is the smallest request the device can perform without 508 * incurring a performance penalty. For disk drives this is often the 509 * physical block size. For RAID arrays it is often the stripe chunk 510 * size. A properly aligned multiple of minimum_io_size is the 511 * preferred request size for workloads where a high number of I/O 512 * operations is desired. 513 */ 514 void blk_queue_io_min(struct request_queue *q, unsigned int min) 515 { 516 blk_limits_io_min(&q->limits, min); 517 } 518 EXPORT_SYMBOL(blk_queue_io_min); 519 520 /** 521 * blk_limits_io_opt - set optimal request size for a device 522 * @limits: the queue limits 523 * @opt: smallest I/O size in bytes 524 * 525 * Description: 526 * Storage devices may report an optimal I/O size, which is the 527 * device's preferred unit for sustained I/O. This is rarely reported 528 * for disk drives. For RAID arrays it is usually the stripe width or 529 * the internal track size. A properly aligned multiple of 530 * optimal_io_size is the preferred request size for workloads where 531 * sustained throughput is desired. 532 */ 533 void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt) 534 { 535 limits->io_opt = opt; 536 } 537 EXPORT_SYMBOL(blk_limits_io_opt); 538 539 static int queue_limit_alignment_offset(const struct queue_limits *lim, 540 sector_t sector) 541 { 542 unsigned int granularity = max(lim->physical_block_size, lim->io_min); 543 unsigned int alignment = sector_div(sector, granularity >> SECTOR_SHIFT) 544 << SECTOR_SHIFT; 545 546 return (granularity + lim->alignment_offset - alignment) % granularity; 547 } 548 549 static unsigned int queue_limit_discard_alignment( 550 const struct queue_limits *lim, sector_t sector) 551 { 552 unsigned int alignment, granularity, offset; 553 554 if (!lim->max_discard_sectors) 555 return 0; 556 557 /* Why are these in bytes, not sectors? */ 558 alignment = lim->discard_alignment >> SECTOR_SHIFT; 559 granularity = lim->discard_granularity >> SECTOR_SHIFT; 560 if (!granularity) 561 return 0; 562 563 /* Offset of the partition start in 'granularity' sectors */ 564 offset = sector_div(sector, granularity); 565 566 /* And why do we do this modulus *again* in blkdev_issue_discard()? */ 567 offset = (granularity + alignment - offset) % granularity; 568 569 /* Turn it back into bytes, gaah */ 570 return offset << SECTOR_SHIFT; 571 } 572 573 static unsigned int blk_round_down_sectors(unsigned int sectors, unsigned int lbs) 574 { 575 sectors = round_down(sectors, lbs >> SECTOR_SHIFT); 576 if (sectors < PAGE_SIZE >> SECTOR_SHIFT) 577 sectors = PAGE_SIZE >> SECTOR_SHIFT; 578 return sectors; 579 } 580 581 /** 582 * blk_stack_limits - adjust queue_limits for stacked devices 583 * @t: the stacking driver limits (top device) 584 * @b: the underlying queue limits (bottom, component device) 585 * @start: first data sector within component device 586 * 587 * Description: 588 * This function is used by stacking drivers like MD and DM to ensure 589 * that all component devices have compatible block sizes and 590 * alignments. The stacking driver must provide a queue_limits 591 * struct (top) and then iteratively call the stacking function for 592 * all component (bottom) devices. The stacking function will 593 * attempt to combine the values and ensure proper alignment. 594 * 595 * Returns 0 if the top and bottom queue_limits are compatible. The 596 * top device's block sizes and alignment offsets may be adjusted to 597 * ensure alignment with the bottom device. If no compatible sizes 598 * and alignments exist, -1 is returned and the resulting top 599 * queue_limits will have the misaligned flag set to indicate that 600 * the alignment_offset is undefined. 601 */ 602 int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, 603 sector_t start) 604 { 605 unsigned int top, bottom, alignment, ret = 0; 606 607 t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors); 608 t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors); 609 t->max_dev_sectors = min_not_zero(t->max_dev_sectors, b->max_dev_sectors); 610 t->max_write_zeroes_sectors = min(t->max_write_zeroes_sectors, 611 b->max_write_zeroes_sectors); 612 t->max_zone_append_sectors = min(t->max_zone_append_sectors, 613 b->max_zone_append_sectors); 614 t->bounce = max(t->bounce, b->bounce); 615 616 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, 617 b->seg_boundary_mask); 618 t->virt_boundary_mask = min_not_zero(t->virt_boundary_mask, 619 b->virt_boundary_mask); 620 621 t->max_segments = min_not_zero(t->max_segments, b->max_segments); 622 t->max_discard_segments = min_not_zero(t->max_discard_segments, 623 b->max_discard_segments); 624 t->max_integrity_segments = min_not_zero(t->max_integrity_segments, 625 b->max_integrity_segments); 626 627 t->max_segment_size = min_not_zero(t->max_segment_size, 628 b->max_segment_size); 629 630 t->misaligned |= b->misaligned; 631 632 alignment = queue_limit_alignment_offset(b, start); 633 634 /* Bottom device has different alignment. Check that it is 635 * compatible with the current top alignment. 636 */ 637 if (t->alignment_offset != alignment) { 638 639 top = max(t->physical_block_size, t->io_min) 640 + t->alignment_offset; 641 bottom = max(b->physical_block_size, b->io_min) + alignment; 642 643 /* Verify that top and bottom intervals line up */ 644 if (max(top, bottom) % min(top, bottom)) { 645 t->misaligned = 1; 646 ret = -1; 647 } 648 } 649 650 t->logical_block_size = max(t->logical_block_size, 651 b->logical_block_size); 652 653 t->physical_block_size = max(t->physical_block_size, 654 b->physical_block_size); 655 656 t->io_min = max(t->io_min, b->io_min); 657 t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); 658 t->dma_alignment = max(t->dma_alignment, b->dma_alignment); 659 660 /* Set non-power-of-2 compatible chunk_sectors boundary */ 661 if (b->chunk_sectors) 662 t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); 663 664 /* Physical block size a multiple of the logical block size? */ 665 if (t->physical_block_size & (t->logical_block_size - 1)) { 666 t->physical_block_size = t->logical_block_size; 667 t->misaligned = 1; 668 ret = -1; 669 } 670 671 /* Minimum I/O a multiple of the physical block size? */ 672 if (t->io_min & (t->physical_block_size - 1)) { 673 t->io_min = t->physical_block_size; 674 t->misaligned = 1; 675 ret = -1; 676 } 677 678 /* Optimal I/O a multiple of the physical block size? */ 679 if (t->io_opt & (t->physical_block_size - 1)) { 680 t->io_opt = 0; 681 t->misaligned = 1; 682 ret = -1; 683 } 684 685 /* chunk_sectors a multiple of the physical block size? */ 686 if ((t->chunk_sectors << 9) & (t->physical_block_size - 1)) { 687 t->chunk_sectors = 0; 688 t->misaligned = 1; 689 ret = -1; 690 } 691 692 t->raid_partial_stripes_expensive = 693 max(t->raid_partial_stripes_expensive, 694 b->raid_partial_stripes_expensive); 695 696 /* Find lowest common alignment_offset */ 697 t->alignment_offset = lcm_not_zero(t->alignment_offset, alignment) 698 % max(t->physical_block_size, t->io_min); 699 700 /* Verify that new alignment_offset is on a logical block boundary */ 701 if (t->alignment_offset & (t->logical_block_size - 1)) { 702 t->misaligned = 1; 703 ret = -1; 704 } 705 706 t->max_sectors = blk_round_down_sectors(t->max_sectors, t->logical_block_size); 707 t->max_hw_sectors = blk_round_down_sectors(t->max_hw_sectors, t->logical_block_size); 708 t->max_dev_sectors = blk_round_down_sectors(t->max_dev_sectors, t->logical_block_size); 709 710 /* Discard alignment and granularity */ 711 if (b->discard_granularity) { 712 alignment = queue_limit_discard_alignment(b, start); 713 714 if (t->discard_granularity != 0 && 715 t->discard_alignment != alignment) { 716 top = t->discard_granularity + t->discard_alignment; 717 bottom = b->discard_granularity + alignment; 718 719 /* Verify that top and bottom intervals line up */ 720 if ((max(top, bottom) % min(top, bottom)) != 0) 721 t->discard_misaligned = 1; 722 } 723 724 t->max_discard_sectors = min_not_zero(t->max_discard_sectors, 725 b->max_discard_sectors); 726 t->max_hw_discard_sectors = min_not_zero(t->max_hw_discard_sectors, 727 b->max_hw_discard_sectors); 728 t->discard_granularity = max(t->discard_granularity, 729 b->discard_granularity); 730 t->discard_alignment = lcm_not_zero(t->discard_alignment, alignment) % 731 t->discard_granularity; 732 } 733 t->max_secure_erase_sectors = min_not_zero(t->max_secure_erase_sectors, 734 b->max_secure_erase_sectors); 735 t->zone_write_granularity = max(t->zone_write_granularity, 736 b->zone_write_granularity); 737 t->zoned = max(t->zoned, b->zoned); 738 if (!t->zoned) { 739 t->zone_write_granularity = 0; 740 t->max_zone_append_sectors = 0; 741 } 742 return ret; 743 } 744 EXPORT_SYMBOL(blk_stack_limits); 745 746 /** 747 * queue_limits_stack_bdev - adjust queue_limits for stacked devices 748 * @t: the stacking driver limits (top device) 749 * @bdev: the underlying block device (bottom) 750 * @offset: offset to beginning of data within component device 751 * @pfx: prefix to use for warnings logged 752 * 753 * Description: 754 * This function is used by stacking drivers like MD and DM to ensure 755 * that all component devices have compatible block sizes and 756 * alignments. The stacking driver must provide a queue_limits 757 * struct (top) and then iteratively call the stacking function for 758 * all component (bottom) devices. The stacking function will 759 * attempt to combine the values and ensure proper alignment. 760 */ 761 void queue_limits_stack_bdev(struct queue_limits *t, struct block_device *bdev, 762 sector_t offset, const char *pfx) 763 { 764 if (blk_stack_limits(t, &bdev_get_queue(bdev)->limits, 765 get_start_sect(bdev) + offset)) 766 pr_notice("%s: Warning: Device %pg is misaligned\n", 767 pfx, bdev); 768 } 769 EXPORT_SYMBOL_GPL(queue_limits_stack_bdev); 770 771 /** 772 * blk_queue_update_dma_pad - update pad mask 773 * @q: the request queue for the device 774 * @mask: pad mask 775 * 776 * Update dma pad mask. 777 * 778 * Appending pad buffer to a request modifies the last entry of a 779 * scatter list such that it includes the pad buffer. 780 **/ 781 void blk_queue_update_dma_pad(struct request_queue *q, unsigned int mask) 782 { 783 if (mask > q->dma_pad_mask) 784 q->dma_pad_mask = mask; 785 } 786 EXPORT_SYMBOL(blk_queue_update_dma_pad); 787 788 /** 789 * blk_set_queue_depth - tell the block layer about the device queue depth 790 * @q: the request queue for the device 791 * @depth: queue depth 792 * 793 */ 794 void blk_set_queue_depth(struct request_queue *q, unsigned int depth) 795 { 796 q->queue_depth = depth; 797 rq_qos_queue_depth_changed(q); 798 } 799 EXPORT_SYMBOL(blk_set_queue_depth); 800 801 /** 802 * blk_queue_write_cache - configure queue's write cache 803 * @q: the request queue for the device 804 * @wc: write back cache on or off 805 * @fua: device supports FUA writes, if true 806 * 807 * Tell the block layer about the write cache of @q. 808 */ 809 void blk_queue_write_cache(struct request_queue *q, bool wc, bool fua) 810 { 811 if (wc) { 812 blk_queue_flag_set(QUEUE_FLAG_HW_WC, q); 813 blk_queue_flag_set(QUEUE_FLAG_WC, q); 814 } else { 815 blk_queue_flag_clear(QUEUE_FLAG_HW_WC, q); 816 blk_queue_flag_clear(QUEUE_FLAG_WC, q); 817 } 818 if (fua) 819 blk_queue_flag_set(QUEUE_FLAG_FUA, q); 820 else 821 blk_queue_flag_clear(QUEUE_FLAG_FUA, q); 822 } 823 EXPORT_SYMBOL_GPL(blk_queue_write_cache); 824 825 /** 826 * blk_queue_required_elevator_features - Set a queue required elevator features 827 * @q: the request queue for the target device 828 * @features: Required elevator features OR'ed together 829 * 830 * Tell the block layer that for the device controlled through @q, only the 831 * only elevators that can be used are those that implement at least the set of 832 * features specified by @features. 833 */ 834 void blk_queue_required_elevator_features(struct request_queue *q, 835 unsigned int features) 836 { 837 q->required_elevator_features = features; 838 } 839 EXPORT_SYMBOL_GPL(blk_queue_required_elevator_features); 840 841 /** 842 * disk_set_zoned - inidicate a zoned device 843 * @disk: gendisk to configure 844 */ 845 void disk_set_zoned(struct gendisk *disk) 846 { 847 struct request_queue *q = disk->queue; 848 849 WARN_ON_ONCE(!IS_ENABLED(CONFIG_BLK_DEV_ZONED)); 850 851 /* 852 * Set the zone write granularity to the device logical block 853 * size by default. The driver can change this value if needed. 854 */ 855 q->limits.zoned = true; 856 blk_queue_zone_write_granularity(q, queue_logical_block_size(q)); 857 } 858 EXPORT_SYMBOL_GPL(disk_set_zoned); 859 860 int bdev_alignment_offset(struct block_device *bdev) 861 { 862 struct request_queue *q = bdev_get_queue(bdev); 863 864 if (q->limits.misaligned) 865 return -1; 866 if (bdev_is_partition(bdev)) 867 return queue_limit_alignment_offset(&q->limits, 868 bdev->bd_start_sect); 869 return q->limits.alignment_offset; 870 } 871 EXPORT_SYMBOL_GPL(bdev_alignment_offset); 872 873 unsigned int bdev_discard_alignment(struct block_device *bdev) 874 { 875 struct request_queue *q = bdev_get_queue(bdev); 876 877 if (bdev_is_partition(bdev)) 878 return queue_limit_discard_alignment(&q->limits, 879 bdev->bd_start_sect); 880 return q->limits.discard_alignment; 881 } 882 EXPORT_SYMBOL_GPL(bdev_discard_alignment); 883