1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 1991, 1992 Linus Torvalds 4 * Copyright (C) 1994, Karl Keyte: Added support for disk statistics 5 * Elevator latency, (C) 2000 Andrea Arcangeli <andrea@suse.de> SuSE 6 * Queue request tables / lock, selectable elevator, Jens Axboe <axboe@suse.de> 7 * kernel-doc documentation started by NeilBrown <neilb@cse.unsw.edu.au> 8 * - July2000 9 * bio rewrite, highmem i/o, etc, Jens Axboe <axboe@suse.de> - may 2001 10 */ 11 12 /* 13 * This handles all read/write requests to block devices 14 */ 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/bio.h> 18 #include <linux/blkdev.h> 19 #include <linux/blk-pm.h> 20 #include <linux/blk-integrity.h> 21 #include <linux/highmem.h> 22 #include <linux/mm.h> 23 #include <linux/pagemap.h> 24 #include <linux/kernel_stat.h> 25 #include <linux/string.h> 26 #include <linux/init.h> 27 #include <linux/completion.h> 28 #include <linux/slab.h> 29 #include <linux/swap.h> 30 #include <linux/writeback.h> 31 #include <linux/task_io_accounting_ops.h> 32 #include <linux/fault-inject.h> 33 #include <linux/list_sort.h> 34 #include <linux/delay.h> 35 #include <linux/ratelimit.h> 36 #include <linux/pm_runtime.h> 37 #include <linux/blk-cgroup.h> 38 #include <linux/t10-pi.h> 39 #include <linux/debugfs.h> 40 #include <linux/bpf.h> 41 #include <linux/psi.h> 42 #include <linux/part_stat.h> 43 #include <linux/sched/sysctl.h> 44 #include <linux/blk-crypto.h> 45 46 #define CREATE_TRACE_POINTS 47 #include <trace/events/block.h> 48 49 #include "blk.h" 50 #include "blk-mq-sched.h" 51 #include "blk-pm.h" 52 #include "blk-throttle.h" 53 54 struct dentry *blk_debugfs_root; 55 56 EXPORT_TRACEPOINT_SYMBOL_GPL(block_bio_remap); 57 EXPORT_TRACEPOINT_SYMBOL_GPL(block_rq_remap); 58 EXPORT_TRACEPOINT_SYMBOL_GPL(block_bio_complete); 59 EXPORT_TRACEPOINT_SYMBOL_GPL(block_split); 60 EXPORT_TRACEPOINT_SYMBOL_GPL(block_unplug); 61 EXPORT_TRACEPOINT_SYMBOL_GPL(block_rq_insert); 62 63 DEFINE_IDA(blk_queue_ida); 64 65 /* 66 * For queue allocation 67 */ 68 struct kmem_cache *blk_requestq_cachep; 69 struct kmem_cache *blk_requestq_srcu_cachep; 70 71 /* 72 * Controlling structure to kblockd 73 */ 74 static struct workqueue_struct *kblockd_workqueue; 75 76 /** 77 * blk_queue_flag_set - atomically set a queue flag 78 * @flag: flag to be set 79 * @q: request queue 80 */ 81 void blk_queue_flag_set(unsigned int flag, struct request_queue *q) 82 { 83 set_bit(flag, &q->queue_flags); 84 } 85 EXPORT_SYMBOL(blk_queue_flag_set); 86 87 /** 88 * blk_queue_flag_clear - atomically clear a queue flag 89 * @flag: flag to be cleared 90 * @q: request queue 91 */ 92 void blk_queue_flag_clear(unsigned int flag, struct request_queue *q) 93 { 94 clear_bit(flag, &q->queue_flags); 95 } 96 EXPORT_SYMBOL(blk_queue_flag_clear); 97 98 /** 99 * blk_queue_flag_test_and_set - atomically test and set a queue flag 100 * @flag: flag to be set 101 * @q: request queue 102 * 103 * Returns the previous value of @flag - 0 if the flag was not set and 1 if 104 * the flag was already set. 105 */ 106 bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q) 107 { 108 return test_and_set_bit(flag, &q->queue_flags); 109 } 110 EXPORT_SYMBOL_GPL(blk_queue_flag_test_and_set); 111 112 #define REQ_OP_NAME(name) [REQ_OP_##name] = #name 113 static const char *const blk_op_name[] = { 114 REQ_OP_NAME(READ), 115 REQ_OP_NAME(WRITE), 116 REQ_OP_NAME(FLUSH), 117 REQ_OP_NAME(DISCARD), 118 REQ_OP_NAME(SECURE_ERASE), 119 REQ_OP_NAME(ZONE_RESET), 120 REQ_OP_NAME(ZONE_RESET_ALL), 121 REQ_OP_NAME(ZONE_OPEN), 122 REQ_OP_NAME(ZONE_CLOSE), 123 REQ_OP_NAME(ZONE_FINISH), 124 REQ_OP_NAME(ZONE_APPEND), 125 REQ_OP_NAME(WRITE_SAME), 126 REQ_OP_NAME(WRITE_ZEROES), 127 REQ_OP_NAME(DRV_IN), 128 REQ_OP_NAME(DRV_OUT), 129 }; 130 #undef REQ_OP_NAME 131 132 /** 133 * blk_op_str - Return string XXX in the REQ_OP_XXX. 134 * @op: REQ_OP_XXX. 135 * 136 * Description: Centralize block layer function to convert REQ_OP_XXX into 137 * string format. Useful in the debugging and tracing bio or request. For 138 * invalid REQ_OP_XXX it returns string "UNKNOWN". 139 */ 140 inline const char *blk_op_str(unsigned int op) 141 { 142 const char *op_str = "UNKNOWN"; 143 144 if (op < ARRAY_SIZE(blk_op_name) && blk_op_name[op]) 145 op_str = blk_op_name[op]; 146 147 return op_str; 148 } 149 EXPORT_SYMBOL_GPL(blk_op_str); 150 151 static const struct { 152 int errno; 153 const char *name; 154 } blk_errors[] = { 155 [BLK_STS_OK] = { 0, "" }, 156 [BLK_STS_NOTSUPP] = { -EOPNOTSUPP, "operation not supported" }, 157 [BLK_STS_TIMEOUT] = { -ETIMEDOUT, "timeout" }, 158 [BLK_STS_NOSPC] = { -ENOSPC, "critical space allocation" }, 159 [BLK_STS_TRANSPORT] = { -ENOLINK, "recoverable transport" }, 160 [BLK_STS_TARGET] = { -EREMOTEIO, "critical target" }, 161 [BLK_STS_NEXUS] = { -EBADE, "critical nexus" }, 162 [BLK_STS_MEDIUM] = { -ENODATA, "critical medium" }, 163 [BLK_STS_PROTECTION] = { -EILSEQ, "protection" }, 164 [BLK_STS_RESOURCE] = { -ENOMEM, "kernel resource" }, 165 [BLK_STS_DEV_RESOURCE] = { -EBUSY, "device resource" }, 166 [BLK_STS_AGAIN] = { -EAGAIN, "nonblocking retry" }, 167 168 /* device mapper special case, should not leak out: */ 169 [BLK_STS_DM_REQUEUE] = { -EREMCHG, "dm internal retry" }, 170 171 /* zone device specific errors */ 172 [BLK_STS_ZONE_OPEN_RESOURCE] = { -ETOOMANYREFS, "open zones exceeded" }, 173 [BLK_STS_ZONE_ACTIVE_RESOURCE] = { -EOVERFLOW, "active zones exceeded" }, 174 175 /* everything else not covered above: */ 176 [BLK_STS_IOERR] = { -EIO, "I/O" }, 177 }; 178 179 blk_status_t errno_to_blk_status(int errno) 180 { 181 int i; 182 183 for (i = 0; i < ARRAY_SIZE(blk_errors); i++) { 184 if (blk_errors[i].errno == errno) 185 return (__force blk_status_t)i; 186 } 187 188 return BLK_STS_IOERR; 189 } 190 EXPORT_SYMBOL_GPL(errno_to_blk_status); 191 192 int blk_status_to_errno(blk_status_t status) 193 { 194 int idx = (__force int)status; 195 196 if (WARN_ON_ONCE(idx >= ARRAY_SIZE(blk_errors))) 197 return -EIO; 198 return blk_errors[idx].errno; 199 } 200 EXPORT_SYMBOL_GPL(blk_status_to_errno); 201 202 const char *blk_status_to_str(blk_status_t status) 203 { 204 int idx = (__force int)status; 205 206 if (WARN_ON_ONCE(idx >= ARRAY_SIZE(blk_errors))) 207 return "<null>"; 208 return blk_errors[idx].name; 209 } 210 211 /** 212 * blk_sync_queue - cancel any pending callbacks on a queue 213 * @q: the queue 214 * 215 * Description: 216 * The block layer may perform asynchronous callback activity 217 * on a queue, such as calling the unplug function after a timeout. 218 * A block device may call blk_sync_queue to ensure that any 219 * such activity is cancelled, thus allowing it to release resources 220 * that the callbacks might use. The caller must already have made sure 221 * that its ->submit_bio will not re-add plugging prior to calling 222 * this function. 223 * 224 * This function does not cancel any asynchronous activity arising 225 * out of elevator or throttling code. That would require elevator_exit() 226 * and blkcg_exit_queue() to be called with queue lock initialized. 227 * 228 */ 229 void blk_sync_queue(struct request_queue *q) 230 { 231 del_timer_sync(&q->timeout); 232 cancel_work_sync(&q->timeout_work); 233 } 234 EXPORT_SYMBOL(blk_sync_queue); 235 236 /** 237 * blk_set_pm_only - increment pm_only counter 238 * @q: request queue pointer 239 */ 240 void blk_set_pm_only(struct request_queue *q) 241 { 242 atomic_inc(&q->pm_only); 243 } 244 EXPORT_SYMBOL_GPL(blk_set_pm_only); 245 246 void blk_clear_pm_only(struct request_queue *q) 247 { 248 int pm_only; 249 250 pm_only = atomic_dec_return(&q->pm_only); 251 WARN_ON_ONCE(pm_only < 0); 252 if (pm_only == 0) 253 wake_up_all(&q->mq_freeze_wq); 254 } 255 EXPORT_SYMBOL_GPL(blk_clear_pm_only); 256 257 /** 258 * blk_put_queue - decrement the request_queue refcount 259 * @q: the request_queue structure to decrement the refcount for 260 * 261 * Decrements the refcount of the request_queue kobject. When this reaches 0 262 * we'll have blk_release_queue() called. 263 * 264 * Context: Any context, but the last reference must not be dropped from 265 * atomic context. 266 */ 267 void blk_put_queue(struct request_queue *q) 268 { 269 kobject_put(&q->kobj); 270 } 271 EXPORT_SYMBOL(blk_put_queue); 272 273 void blk_queue_start_drain(struct request_queue *q) 274 { 275 /* 276 * When queue DYING flag is set, we need to block new req 277 * entering queue, so we call blk_freeze_queue_start() to 278 * prevent I/O from crossing blk_queue_enter(). 279 */ 280 blk_freeze_queue_start(q); 281 if (queue_is_mq(q)) 282 blk_mq_wake_waiters(q); 283 /* Make blk_queue_enter() reexamine the DYING flag. */ 284 wake_up_all(&q->mq_freeze_wq); 285 } 286 287 void blk_set_queue_dying(struct request_queue *q) 288 { 289 blk_queue_flag_set(QUEUE_FLAG_DYING, q); 290 blk_queue_start_drain(q); 291 } 292 EXPORT_SYMBOL_GPL(blk_set_queue_dying); 293 294 /** 295 * blk_cleanup_queue - shutdown a request queue 296 * @q: request queue to shutdown 297 * 298 * Mark @q DYING, drain all pending requests, mark @q DEAD, destroy and 299 * put it. All future requests will be failed immediately with -ENODEV. 300 * 301 * Context: can sleep 302 */ 303 void blk_cleanup_queue(struct request_queue *q) 304 { 305 /* cannot be called from atomic context */ 306 might_sleep(); 307 308 WARN_ON_ONCE(blk_queue_registered(q)); 309 310 /* mark @q DYING, no new request or merges will be allowed afterwards */ 311 blk_set_queue_dying(q); 312 313 blk_queue_flag_set(QUEUE_FLAG_NOMERGES, q); 314 blk_queue_flag_set(QUEUE_FLAG_NOXMERGES, q); 315 316 /* 317 * Drain all requests queued before DYING marking. Set DEAD flag to 318 * prevent that blk_mq_run_hw_queues() accesses the hardware queues 319 * after draining finished. 320 */ 321 blk_freeze_queue(q); 322 323 blk_queue_flag_set(QUEUE_FLAG_DEAD, q); 324 325 blk_sync_queue(q); 326 if (queue_is_mq(q)) { 327 blk_mq_cancel_work_sync(q); 328 blk_mq_exit_queue(q); 329 } 330 331 /* 332 * In theory, request pool of sched_tags belongs to request queue. 333 * However, the current implementation requires tag_set for freeing 334 * requests, so free the pool now. 335 * 336 * Queue has become frozen, there can't be any in-queue requests, so 337 * it is safe to free requests now. 338 */ 339 mutex_lock(&q->sysfs_lock); 340 if (q->elevator) 341 blk_mq_sched_free_rqs(q); 342 mutex_unlock(&q->sysfs_lock); 343 344 percpu_ref_exit(&q->q_usage_counter); 345 346 /* @q is and will stay empty, shutdown and put */ 347 blk_put_queue(q); 348 } 349 EXPORT_SYMBOL(blk_cleanup_queue); 350 351 /** 352 * blk_queue_enter() - try to increase q->q_usage_counter 353 * @q: request queue pointer 354 * @flags: BLK_MQ_REQ_NOWAIT and/or BLK_MQ_REQ_PM 355 */ 356 int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags) 357 { 358 const bool pm = flags & BLK_MQ_REQ_PM; 359 360 while (!blk_try_enter_queue(q, pm)) { 361 if (flags & BLK_MQ_REQ_NOWAIT) 362 return -EBUSY; 363 364 /* 365 * read pair of barrier in blk_freeze_queue_start(), we need to 366 * order reading __PERCPU_REF_DEAD flag of .q_usage_counter and 367 * reading .mq_freeze_depth or queue dying flag, otherwise the 368 * following wait may never return if the two reads are 369 * reordered. 370 */ 371 smp_rmb(); 372 wait_event(q->mq_freeze_wq, 373 (!q->mq_freeze_depth && 374 blk_pm_resume_queue(pm, q)) || 375 blk_queue_dying(q)); 376 if (blk_queue_dying(q)) 377 return -ENODEV; 378 } 379 380 return 0; 381 } 382 383 int __bio_queue_enter(struct request_queue *q, struct bio *bio) 384 { 385 while (!blk_try_enter_queue(q, false)) { 386 struct gendisk *disk = bio->bi_bdev->bd_disk; 387 388 if (bio->bi_opf & REQ_NOWAIT) { 389 if (test_bit(GD_DEAD, &disk->state)) 390 goto dead; 391 bio_wouldblock_error(bio); 392 return -EBUSY; 393 } 394 395 /* 396 * read pair of barrier in blk_freeze_queue_start(), we need to 397 * order reading __PERCPU_REF_DEAD flag of .q_usage_counter and 398 * reading .mq_freeze_depth or queue dying flag, otherwise the 399 * following wait may never return if the two reads are 400 * reordered. 401 */ 402 smp_rmb(); 403 wait_event(q->mq_freeze_wq, 404 (!q->mq_freeze_depth && 405 blk_pm_resume_queue(false, q)) || 406 test_bit(GD_DEAD, &disk->state)); 407 if (test_bit(GD_DEAD, &disk->state)) 408 goto dead; 409 } 410 411 return 0; 412 dead: 413 bio_io_error(bio); 414 return -ENODEV; 415 } 416 417 void blk_queue_exit(struct request_queue *q) 418 { 419 percpu_ref_put(&q->q_usage_counter); 420 } 421 422 static void blk_queue_usage_counter_release(struct percpu_ref *ref) 423 { 424 struct request_queue *q = 425 container_of(ref, struct request_queue, q_usage_counter); 426 427 wake_up_all(&q->mq_freeze_wq); 428 } 429 430 static void blk_rq_timed_out_timer(struct timer_list *t) 431 { 432 struct request_queue *q = from_timer(q, t, timeout); 433 434 kblockd_schedule_work(&q->timeout_work); 435 } 436 437 static void blk_timeout_work(struct work_struct *work) 438 { 439 } 440 441 struct request_queue *blk_alloc_queue(int node_id, bool alloc_srcu) 442 { 443 struct request_queue *q; 444 int ret; 445 446 q = kmem_cache_alloc_node(blk_get_queue_kmem_cache(alloc_srcu), 447 GFP_KERNEL | __GFP_ZERO, node_id); 448 if (!q) 449 return NULL; 450 451 if (alloc_srcu) { 452 blk_queue_flag_set(QUEUE_FLAG_HAS_SRCU, q); 453 if (init_srcu_struct(q->srcu) != 0) 454 goto fail_q; 455 } 456 457 q->last_merge = NULL; 458 459 q->id = ida_simple_get(&blk_queue_ida, 0, 0, GFP_KERNEL); 460 if (q->id < 0) 461 goto fail_srcu; 462 463 ret = bioset_init(&q->bio_split, BIO_POOL_SIZE, 0, 0); 464 if (ret) 465 goto fail_id; 466 467 q->stats = blk_alloc_queue_stats(); 468 if (!q->stats) 469 goto fail_split; 470 471 q->node = node_id; 472 473 atomic_set(&q->nr_active_requests_shared_tags, 0); 474 475 timer_setup(&q->timeout, blk_rq_timed_out_timer, 0); 476 INIT_WORK(&q->timeout_work, blk_timeout_work); 477 INIT_LIST_HEAD(&q->icq_list); 478 #ifdef CONFIG_BLK_CGROUP 479 INIT_LIST_HEAD(&q->blkg_list); 480 #endif 481 482 kobject_init(&q->kobj, &blk_queue_ktype); 483 484 mutex_init(&q->debugfs_mutex); 485 mutex_init(&q->sysfs_lock); 486 mutex_init(&q->sysfs_dir_lock); 487 spin_lock_init(&q->queue_lock); 488 489 init_waitqueue_head(&q->mq_freeze_wq); 490 mutex_init(&q->mq_freeze_lock); 491 492 /* 493 * Init percpu_ref in atomic mode so that it's faster to shutdown. 494 * See blk_register_queue() for details. 495 */ 496 if (percpu_ref_init(&q->q_usage_counter, 497 blk_queue_usage_counter_release, 498 PERCPU_REF_INIT_ATOMIC, GFP_KERNEL)) 499 goto fail_stats; 500 501 if (blkcg_init_queue(q)) 502 goto fail_ref; 503 504 blk_queue_dma_alignment(q, 511); 505 blk_set_default_limits(&q->limits); 506 q->nr_requests = BLKDEV_DEFAULT_RQ; 507 508 return q; 509 510 fail_ref: 511 percpu_ref_exit(&q->q_usage_counter); 512 fail_stats: 513 blk_free_queue_stats(q->stats); 514 fail_split: 515 bioset_exit(&q->bio_split); 516 fail_id: 517 ida_simple_remove(&blk_queue_ida, q->id); 518 fail_srcu: 519 if (alloc_srcu) 520 cleanup_srcu_struct(q->srcu); 521 fail_q: 522 kmem_cache_free(blk_get_queue_kmem_cache(alloc_srcu), q); 523 return NULL; 524 } 525 526 /** 527 * blk_get_queue - increment the request_queue refcount 528 * @q: the request_queue structure to increment the refcount for 529 * 530 * Increment the refcount of the request_queue kobject. 531 * 532 * Context: Any context. 533 */ 534 bool blk_get_queue(struct request_queue *q) 535 { 536 if (likely(!blk_queue_dying(q))) { 537 __blk_get_queue(q); 538 return true; 539 } 540 541 return false; 542 } 543 EXPORT_SYMBOL(blk_get_queue); 544 545 static void handle_bad_sector(struct bio *bio, sector_t maxsector) 546 { 547 char b[BDEVNAME_SIZE]; 548 549 pr_info_ratelimited("%s: attempt to access beyond end of device\n" 550 "%s: rw=%d, want=%llu, limit=%llu\n", 551 current->comm, 552 bio_devname(bio, b), bio->bi_opf, 553 bio_end_sector(bio), maxsector); 554 } 555 556 #ifdef CONFIG_FAIL_MAKE_REQUEST 557 558 static DECLARE_FAULT_ATTR(fail_make_request); 559 560 static int __init setup_fail_make_request(char *str) 561 { 562 return setup_fault_attr(&fail_make_request, str); 563 } 564 __setup("fail_make_request=", setup_fail_make_request); 565 566 bool should_fail_request(struct block_device *part, unsigned int bytes) 567 { 568 return part->bd_make_it_fail && should_fail(&fail_make_request, bytes); 569 } 570 571 static int __init fail_make_request_debugfs(void) 572 { 573 struct dentry *dir = fault_create_debugfs_attr("fail_make_request", 574 NULL, &fail_make_request); 575 576 return PTR_ERR_OR_ZERO(dir); 577 } 578 579 late_initcall(fail_make_request_debugfs); 580 #endif /* CONFIG_FAIL_MAKE_REQUEST */ 581 582 static inline bool bio_check_ro(struct bio *bio) 583 { 584 if (op_is_write(bio_op(bio)) && bdev_read_only(bio->bi_bdev)) { 585 char b[BDEVNAME_SIZE]; 586 587 if (op_is_flush(bio->bi_opf) && !bio_sectors(bio)) 588 return false; 589 590 WARN_ONCE(1, 591 "Trying to write to read-only block-device %s (partno %d)\n", 592 bio_devname(bio, b), bio->bi_bdev->bd_partno); 593 /* Older lvm-tools actually trigger this */ 594 return false; 595 } 596 597 return false; 598 } 599 600 static noinline int should_fail_bio(struct bio *bio) 601 { 602 if (should_fail_request(bdev_whole(bio->bi_bdev), bio->bi_iter.bi_size)) 603 return -EIO; 604 return 0; 605 } 606 ALLOW_ERROR_INJECTION(should_fail_bio, ERRNO); 607 608 /* 609 * Check whether this bio extends beyond the end of the device or partition. 610 * This may well happen - the kernel calls bread() without checking the size of 611 * the device, e.g., when mounting a file system. 612 */ 613 static inline int bio_check_eod(struct bio *bio) 614 { 615 sector_t maxsector = bdev_nr_sectors(bio->bi_bdev); 616 unsigned int nr_sectors = bio_sectors(bio); 617 618 if (nr_sectors && maxsector && 619 (nr_sectors > maxsector || 620 bio->bi_iter.bi_sector > maxsector - nr_sectors)) { 621 handle_bad_sector(bio, maxsector); 622 return -EIO; 623 } 624 return 0; 625 } 626 627 /* 628 * Remap block n of partition p to block n+start(p) of the disk. 629 */ 630 static int blk_partition_remap(struct bio *bio) 631 { 632 struct block_device *p = bio->bi_bdev; 633 634 if (unlikely(should_fail_request(p, bio->bi_iter.bi_size))) 635 return -EIO; 636 if (bio_sectors(bio)) { 637 bio->bi_iter.bi_sector += p->bd_start_sect; 638 trace_block_bio_remap(bio, p->bd_dev, 639 bio->bi_iter.bi_sector - 640 p->bd_start_sect); 641 } 642 bio_set_flag(bio, BIO_REMAPPED); 643 return 0; 644 } 645 646 /* 647 * Check write append to a zoned block device. 648 */ 649 static inline blk_status_t blk_check_zone_append(struct request_queue *q, 650 struct bio *bio) 651 { 652 sector_t pos = bio->bi_iter.bi_sector; 653 int nr_sectors = bio_sectors(bio); 654 655 /* Only applicable to zoned block devices */ 656 if (!blk_queue_is_zoned(q)) 657 return BLK_STS_NOTSUPP; 658 659 /* The bio sector must point to the start of a sequential zone */ 660 if (pos & (blk_queue_zone_sectors(q) - 1) || 661 !blk_queue_zone_is_seq(q, pos)) 662 return BLK_STS_IOERR; 663 664 /* 665 * Not allowed to cross zone boundaries. Otherwise, the BIO will be 666 * split and could result in non-contiguous sectors being written in 667 * different zones. 668 */ 669 if (nr_sectors > q->limits.chunk_sectors) 670 return BLK_STS_IOERR; 671 672 /* Make sure the BIO is small enough and will not get split */ 673 if (nr_sectors > q->limits.max_zone_append_sectors) 674 return BLK_STS_IOERR; 675 676 bio->bi_opf |= REQ_NOMERGE; 677 678 return BLK_STS_OK; 679 } 680 681 noinline_for_stack bool submit_bio_checks(struct bio *bio) 682 { 683 struct block_device *bdev = bio->bi_bdev; 684 struct request_queue *q = bdev_get_queue(bdev); 685 blk_status_t status = BLK_STS_IOERR; 686 struct blk_plug *plug; 687 688 might_sleep(); 689 690 plug = blk_mq_plug(q, bio); 691 if (plug && plug->nowait) 692 bio->bi_opf |= REQ_NOWAIT; 693 694 /* 695 * For a REQ_NOWAIT based request, return -EOPNOTSUPP 696 * if queue does not support NOWAIT. 697 */ 698 if ((bio->bi_opf & REQ_NOWAIT) && !blk_queue_nowait(q)) 699 goto not_supported; 700 701 if (should_fail_bio(bio)) 702 goto end_io; 703 if (unlikely(bio_check_ro(bio))) 704 goto end_io; 705 if (!bio_flagged(bio, BIO_REMAPPED)) { 706 if (unlikely(bio_check_eod(bio))) 707 goto end_io; 708 if (bdev->bd_partno && unlikely(blk_partition_remap(bio))) 709 goto end_io; 710 } 711 712 /* 713 * Filter flush bio's early so that bio based drivers without flush 714 * support don't have to worry about them. 715 */ 716 if (op_is_flush(bio->bi_opf) && 717 !test_bit(QUEUE_FLAG_WC, &q->queue_flags)) { 718 bio->bi_opf &= ~(REQ_PREFLUSH | REQ_FUA); 719 if (!bio_sectors(bio)) { 720 status = BLK_STS_OK; 721 goto end_io; 722 } 723 } 724 725 if (!test_bit(QUEUE_FLAG_POLL, &q->queue_flags)) 726 bio_clear_polled(bio); 727 728 switch (bio_op(bio)) { 729 case REQ_OP_DISCARD: 730 if (!blk_queue_discard(q)) 731 goto not_supported; 732 break; 733 case REQ_OP_SECURE_ERASE: 734 if (!blk_queue_secure_erase(q)) 735 goto not_supported; 736 break; 737 case REQ_OP_WRITE_SAME: 738 if (!q->limits.max_write_same_sectors) 739 goto not_supported; 740 break; 741 case REQ_OP_ZONE_APPEND: 742 status = blk_check_zone_append(q, bio); 743 if (status != BLK_STS_OK) 744 goto end_io; 745 break; 746 case REQ_OP_ZONE_RESET: 747 case REQ_OP_ZONE_OPEN: 748 case REQ_OP_ZONE_CLOSE: 749 case REQ_OP_ZONE_FINISH: 750 if (!blk_queue_is_zoned(q)) 751 goto not_supported; 752 break; 753 case REQ_OP_ZONE_RESET_ALL: 754 if (!blk_queue_is_zoned(q) || !blk_queue_zone_resetall(q)) 755 goto not_supported; 756 break; 757 case REQ_OP_WRITE_ZEROES: 758 if (!q->limits.max_write_zeroes_sectors) 759 goto not_supported; 760 break; 761 default: 762 break; 763 } 764 765 if (blk_throtl_bio(bio)) 766 return false; 767 768 blk_cgroup_bio_start(bio); 769 blkcg_bio_issue_init(bio); 770 771 if (!bio_flagged(bio, BIO_TRACE_COMPLETION)) { 772 trace_block_bio_queue(bio); 773 /* Now that enqueuing has been traced, we need to trace 774 * completion as well. 775 */ 776 bio_set_flag(bio, BIO_TRACE_COMPLETION); 777 } 778 return true; 779 780 not_supported: 781 status = BLK_STS_NOTSUPP; 782 end_io: 783 bio->bi_status = status; 784 bio_endio(bio); 785 return false; 786 } 787 788 static void __submit_bio_fops(struct gendisk *disk, struct bio *bio) 789 { 790 if (blk_crypto_bio_prep(&bio)) { 791 if (likely(bio_queue_enter(bio) == 0)) { 792 disk->fops->submit_bio(bio); 793 blk_queue_exit(disk->queue); 794 } 795 } 796 } 797 798 static void __submit_bio(struct bio *bio) 799 { 800 struct gendisk *disk = bio->bi_bdev->bd_disk; 801 802 if (unlikely(!submit_bio_checks(bio))) 803 return; 804 805 if (!disk->fops->submit_bio) 806 blk_mq_submit_bio(bio); 807 else 808 __submit_bio_fops(disk, bio); 809 } 810 811 /* 812 * The loop in this function may be a bit non-obvious, and so deserves some 813 * explanation: 814 * 815 * - Before entering the loop, bio->bi_next is NULL (as all callers ensure 816 * that), so we have a list with a single bio. 817 * - We pretend that we have just taken it off a longer list, so we assign 818 * bio_list to a pointer to the bio_list_on_stack, thus initialising the 819 * bio_list of new bios to be added. ->submit_bio() may indeed add some more 820 * bios through a recursive call to submit_bio_noacct. If it did, we find a 821 * non-NULL value in bio_list and re-enter the loop from the top. 822 * - In this case we really did just take the bio of the top of the list (no 823 * pretending) and so remove it from bio_list, and call into ->submit_bio() 824 * again. 825 * 826 * bio_list_on_stack[0] contains bios submitted by the current ->submit_bio. 827 * bio_list_on_stack[1] contains bios that were submitted before the current 828 * ->submit_bio_bio, but that haven't been processed yet. 829 */ 830 static void __submit_bio_noacct(struct bio *bio) 831 { 832 struct bio_list bio_list_on_stack[2]; 833 834 BUG_ON(bio->bi_next); 835 836 bio_list_init(&bio_list_on_stack[0]); 837 current->bio_list = bio_list_on_stack; 838 839 do { 840 struct request_queue *q = bdev_get_queue(bio->bi_bdev); 841 struct bio_list lower, same; 842 843 /* 844 * Create a fresh bio_list for all subordinate requests. 845 */ 846 bio_list_on_stack[1] = bio_list_on_stack[0]; 847 bio_list_init(&bio_list_on_stack[0]); 848 849 __submit_bio(bio); 850 851 /* 852 * Sort new bios into those for a lower level and those for the 853 * same level. 854 */ 855 bio_list_init(&lower); 856 bio_list_init(&same); 857 while ((bio = bio_list_pop(&bio_list_on_stack[0])) != NULL) 858 if (q == bdev_get_queue(bio->bi_bdev)) 859 bio_list_add(&same, bio); 860 else 861 bio_list_add(&lower, bio); 862 863 /* 864 * Now assemble so we handle the lowest level first. 865 */ 866 bio_list_merge(&bio_list_on_stack[0], &lower); 867 bio_list_merge(&bio_list_on_stack[0], &same); 868 bio_list_merge(&bio_list_on_stack[0], &bio_list_on_stack[1]); 869 } while ((bio = bio_list_pop(&bio_list_on_stack[0]))); 870 871 current->bio_list = NULL; 872 } 873 874 static void __submit_bio_noacct_mq(struct bio *bio) 875 { 876 struct bio_list bio_list[2] = { }; 877 878 current->bio_list = bio_list; 879 880 do { 881 __submit_bio(bio); 882 } while ((bio = bio_list_pop(&bio_list[0]))); 883 884 current->bio_list = NULL; 885 } 886 887 /** 888 * submit_bio_noacct - re-submit a bio to the block device layer for I/O 889 * @bio: The bio describing the location in memory and on the device. 890 * 891 * This is a version of submit_bio() that shall only be used for I/O that is 892 * resubmitted to lower level drivers by stacking block drivers. All file 893 * systems and other upper level users of the block layer should use 894 * submit_bio() instead. 895 */ 896 void submit_bio_noacct(struct bio *bio) 897 { 898 /* 899 * We only want one ->submit_bio to be active at a time, else stack 900 * usage with stacked devices could be a problem. Use current->bio_list 901 * to collect a list of requests submited by a ->submit_bio method while 902 * it is active, and then process them after it returned. 903 */ 904 if (current->bio_list) 905 bio_list_add(¤t->bio_list[0], bio); 906 else if (!bio->bi_bdev->bd_disk->fops->submit_bio) 907 __submit_bio_noacct_mq(bio); 908 else 909 __submit_bio_noacct(bio); 910 } 911 EXPORT_SYMBOL(submit_bio_noacct); 912 913 /** 914 * submit_bio - submit a bio to the block device layer for I/O 915 * @bio: The &struct bio which describes the I/O 916 * 917 * submit_bio() is used to submit I/O requests to block devices. It is passed a 918 * fully set up &struct bio that describes the I/O that needs to be done. The 919 * bio will be send to the device described by the bi_bdev field. 920 * 921 * The success/failure status of the request, along with notification of 922 * completion, is delivered asynchronously through the ->bi_end_io() callback 923 * in @bio. The bio must NOT be touched by thecaller until ->bi_end_io() has 924 * been called. 925 */ 926 void submit_bio(struct bio *bio) 927 { 928 if (blkcg_punt_bio_submit(bio)) 929 return; 930 931 /* 932 * If it's a regular read/write or a barrier with data attached, 933 * go through the normal accounting stuff before submission. 934 */ 935 if (bio_has_data(bio)) { 936 unsigned int count; 937 938 if (unlikely(bio_op(bio) == REQ_OP_WRITE_SAME)) 939 count = queue_logical_block_size( 940 bdev_get_queue(bio->bi_bdev)) >> 9; 941 else 942 count = bio_sectors(bio); 943 944 if (op_is_write(bio_op(bio))) { 945 count_vm_events(PGPGOUT, count); 946 } else { 947 task_io_account_read(bio->bi_iter.bi_size); 948 count_vm_events(PGPGIN, count); 949 } 950 } 951 952 /* 953 * If we're reading data that is part of the userspace workingset, count 954 * submission time as memory stall. When the device is congested, or 955 * the submitting cgroup IO-throttled, submission can be a significant 956 * part of overall IO time. 957 */ 958 if (unlikely(bio_op(bio) == REQ_OP_READ && 959 bio_flagged(bio, BIO_WORKINGSET))) { 960 unsigned long pflags; 961 962 psi_memstall_enter(&pflags); 963 submit_bio_noacct(bio); 964 psi_memstall_leave(&pflags); 965 return; 966 } 967 968 submit_bio_noacct(bio); 969 } 970 EXPORT_SYMBOL(submit_bio); 971 972 /** 973 * bio_poll - poll for BIO completions 974 * @bio: bio to poll for 975 * @iob: batches of IO 976 * @flags: BLK_POLL_* flags that control the behavior 977 * 978 * Poll for completions on queue associated with the bio. Returns number of 979 * completed entries found. 980 * 981 * Note: the caller must either be the context that submitted @bio, or 982 * be in a RCU critical section to prevent freeing of @bio. 983 */ 984 int bio_poll(struct bio *bio, struct io_comp_batch *iob, unsigned int flags) 985 { 986 struct request_queue *q = bdev_get_queue(bio->bi_bdev); 987 blk_qc_t cookie = READ_ONCE(bio->bi_cookie); 988 int ret; 989 990 if (cookie == BLK_QC_T_NONE || 991 !test_bit(QUEUE_FLAG_POLL, &q->queue_flags)) 992 return 0; 993 994 if (current->plug) 995 blk_flush_plug(current->plug, false); 996 997 if (blk_queue_enter(q, BLK_MQ_REQ_NOWAIT)) 998 return 0; 999 if (WARN_ON_ONCE(!queue_is_mq(q))) 1000 ret = 0; /* not yet implemented, should not happen */ 1001 else 1002 ret = blk_mq_poll(q, cookie, iob, flags); 1003 blk_queue_exit(q); 1004 return ret; 1005 } 1006 EXPORT_SYMBOL_GPL(bio_poll); 1007 1008 /* 1009 * Helper to implement file_operations.iopoll. Requires the bio to be stored 1010 * in iocb->private, and cleared before freeing the bio. 1011 */ 1012 int iocb_bio_iopoll(struct kiocb *kiocb, struct io_comp_batch *iob, 1013 unsigned int flags) 1014 { 1015 struct bio *bio; 1016 int ret = 0; 1017 1018 /* 1019 * Note: the bio cache only uses SLAB_TYPESAFE_BY_RCU, so bio can 1020 * point to a freshly allocated bio at this point. If that happens 1021 * we have a few cases to consider: 1022 * 1023 * 1) the bio is beeing initialized and bi_bdev is NULL. We can just 1024 * simply nothing in this case 1025 * 2) the bio points to a not poll enabled device. bio_poll will catch 1026 * this and return 0 1027 * 3) the bio points to a poll capable device, including but not 1028 * limited to the one that the original bio pointed to. In this 1029 * case we will call into the actual poll method and poll for I/O, 1030 * even if we don't need to, but it won't cause harm either. 1031 * 1032 * For cases 2) and 3) above the RCU grace period ensures that bi_bdev 1033 * is still allocated. Because partitions hold a reference to the whole 1034 * device bdev and thus disk, the disk is also still valid. Grabbing 1035 * a reference to the queue in bio_poll() ensures the hctxs and requests 1036 * are still valid as well. 1037 */ 1038 rcu_read_lock(); 1039 bio = READ_ONCE(kiocb->private); 1040 if (bio && bio->bi_bdev) 1041 ret = bio_poll(bio, iob, flags); 1042 rcu_read_unlock(); 1043 1044 return ret; 1045 } 1046 EXPORT_SYMBOL_GPL(iocb_bio_iopoll); 1047 1048 void update_io_ticks(struct block_device *part, unsigned long now, bool end) 1049 { 1050 unsigned long stamp; 1051 again: 1052 stamp = READ_ONCE(part->bd_stamp); 1053 if (unlikely(time_after(now, stamp))) { 1054 if (likely(cmpxchg(&part->bd_stamp, stamp, now) == stamp)) 1055 __part_stat_add(part, io_ticks, end ? now - stamp : 1); 1056 } 1057 if (part->bd_partno) { 1058 part = bdev_whole(part); 1059 goto again; 1060 } 1061 } 1062 1063 static unsigned long __part_start_io_acct(struct block_device *part, 1064 unsigned int sectors, unsigned int op) 1065 { 1066 const int sgrp = op_stat_group(op); 1067 unsigned long now = READ_ONCE(jiffies); 1068 1069 part_stat_lock(); 1070 update_io_ticks(part, now, false); 1071 part_stat_inc(part, ios[sgrp]); 1072 part_stat_add(part, sectors[sgrp], sectors); 1073 part_stat_local_inc(part, in_flight[op_is_write(op)]); 1074 part_stat_unlock(); 1075 1076 return now; 1077 } 1078 1079 /** 1080 * bio_start_io_acct - start I/O accounting for bio based drivers 1081 * @bio: bio to start account for 1082 * 1083 * Returns the start time that should be passed back to bio_end_io_acct(). 1084 */ 1085 unsigned long bio_start_io_acct(struct bio *bio) 1086 { 1087 return __part_start_io_acct(bio->bi_bdev, bio_sectors(bio), bio_op(bio)); 1088 } 1089 EXPORT_SYMBOL_GPL(bio_start_io_acct); 1090 1091 unsigned long disk_start_io_acct(struct gendisk *disk, unsigned int sectors, 1092 unsigned int op) 1093 { 1094 return __part_start_io_acct(disk->part0, sectors, op); 1095 } 1096 EXPORT_SYMBOL(disk_start_io_acct); 1097 1098 static void __part_end_io_acct(struct block_device *part, unsigned int op, 1099 unsigned long start_time) 1100 { 1101 const int sgrp = op_stat_group(op); 1102 unsigned long now = READ_ONCE(jiffies); 1103 unsigned long duration = now - start_time; 1104 1105 part_stat_lock(); 1106 update_io_ticks(part, now, true); 1107 part_stat_add(part, nsecs[sgrp], jiffies_to_nsecs(duration)); 1108 part_stat_local_dec(part, in_flight[op_is_write(op)]); 1109 part_stat_unlock(); 1110 } 1111 1112 void bio_end_io_acct_remapped(struct bio *bio, unsigned long start_time, 1113 struct block_device *orig_bdev) 1114 { 1115 __part_end_io_acct(orig_bdev, bio_op(bio), start_time); 1116 } 1117 EXPORT_SYMBOL_GPL(bio_end_io_acct_remapped); 1118 1119 void disk_end_io_acct(struct gendisk *disk, unsigned int op, 1120 unsigned long start_time) 1121 { 1122 __part_end_io_acct(disk->part0, op, start_time); 1123 } 1124 EXPORT_SYMBOL(disk_end_io_acct); 1125 1126 /** 1127 * blk_lld_busy - Check if underlying low-level drivers of a device are busy 1128 * @q : the queue of the device being checked 1129 * 1130 * Description: 1131 * Check if underlying low-level drivers of a device are busy. 1132 * If the drivers want to export their busy state, they must set own 1133 * exporting function using blk_queue_lld_busy() first. 1134 * 1135 * Basically, this function is used only by request stacking drivers 1136 * to stop dispatching requests to underlying devices when underlying 1137 * devices are busy. This behavior helps more I/O merging on the queue 1138 * of the request stacking driver and prevents I/O throughput regression 1139 * on burst I/O load. 1140 * 1141 * Return: 1142 * 0 - Not busy (The request stacking driver should dispatch request) 1143 * 1 - Busy (The request stacking driver should stop dispatching request) 1144 */ 1145 int blk_lld_busy(struct request_queue *q) 1146 { 1147 if (queue_is_mq(q) && q->mq_ops->busy) 1148 return q->mq_ops->busy(q); 1149 1150 return 0; 1151 } 1152 EXPORT_SYMBOL_GPL(blk_lld_busy); 1153 1154 int kblockd_schedule_work(struct work_struct *work) 1155 { 1156 return queue_work(kblockd_workqueue, work); 1157 } 1158 EXPORT_SYMBOL(kblockd_schedule_work); 1159 1160 int kblockd_mod_delayed_work_on(int cpu, struct delayed_work *dwork, 1161 unsigned long delay) 1162 { 1163 return mod_delayed_work_on(cpu, kblockd_workqueue, dwork, delay); 1164 } 1165 EXPORT_SYMBOL(kblockd_mod_delayed_work_on); 1166 1167 void blk_start_plug_nr_ios(struct blk_plug *plug, unsigned short nr_ios) 1168 { 1169 struct task_struct *tsk = current; 1170 1171 /* 1172 * If this is a nested plug, don't actually assign it. 1173 */ 1174 if (tsk->plug) 1175 return; 1176 1177 plug->mq_list = NULL; 1178 plug->cached_rq = NULL; 1179 plug->nr_ios = min_t(unsigned short, nr_ios, BLK_MAX_REQUEST_COUNT); 1180 plug->rq_count = 0; 1181 plug->multiple_queues = false; 1182 plug->has_elevator = false; 1183 plug->nowait = false; 1184 INIT_LIST_HEAD(&plug->cb_list); 1185 1186 /* 1187 * Store ordering should not be needed here, since a potential 1188 * preempt will imply a full memory barrier 1189 */ 1190 tsk->plug = plug; 1191 } 1192 1193 /** 1194 * blk_start_plug - initialize blk_plug and track it inside the task_struct 1195 * @plug: The &struct blk_plug that needs to be initialized 1196 * 1197 * Description: 1198 * blk_start_plug() indicates to the block layer an intent by the caller 1199 * to submit multiple I/O requests in a batch. The block layer may use 1200 * this hint to defer submitting I/Os from the caller until blk_finish_plug() 1201 * is called. However, the block layer may choose to submit requests 1202 * before a call to blk_finish_plug() if the number of queued I/Os 1203 * exceeds %BLK_MAX_REQUEST_COUNT, or if the size of the I/O is larger than 1204 * %BLK_PLUG_FLUSH_SIZE. The queued I/Os may also be submitted early if 1205 * the task schedules (see below). 1206 * 1207 * Tracking blk_plug inside the task_struct will help with auto-flushing the 1208 * pending I/O should the task end up blocking between blk_start_plug() and 1209 * blk_finish_plug(). This is important from a performance perspective, but 1210 * also ensures that we don't deadlock. For instance, if the task is blocking 1211 * for a memory allocation, memory reclaim could end up wanting to free a 1212 * page belonging to that request that is currently residing in our private 1213 * plug. By flushing the pending I/O when the process goes to sleep, we avoid 1214 * this kind of deadlock. 1215 */ 1216 void blk_start_plug(struct blk_plug *plug) 1217 { 1218 blk_start_plug_nr_ios(plug, 1); 1219 } 1220 EXPORT_SYMBOL(blk_start_plug); 1221 1222 static void flush_plug_callbacks(struct blk_plug *plug, bool from_schedule) 1223 { 1224 LIST_HEAD(callbacks); 1225 1226 while (!list_empty(&plug->cb_list)) { 1227 list_splice_init(&plug->cb_list, &callbacks); 1228 1229 while (!list_empty(&callbacks)) { 1230 struct blk_plug_cb *cb = list_first_entry(&callbacks, 1231 struct blk_plug_cb, 1232 list); 1233 list_del(&cb->list); 1234 cb->callback(cb, from_schedule); 1235 } 1236 } 1237 } 1238 1239 struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug, void *data, 1240 int size) 1241 { 1242 struct blk_plug *plug = current->plug; 1243 struct blk_plug_cb *cb; 1244 1245 if (!plug) 1246 return NULL; 1247 1248 list_for_each_entry(cb, &plug->cb_list, list) 1249 if (cb->callback == unplug && cb->data == data) 1250 return cb; 1251 1252 /* Not currently on the callback list */ 1253 BUG_ON(size < sizeof(*cb)); 1254 cb = kzalloc(size, GFP_ATOMIC); 1255 if (cb) { 1256 cb->data = data; 1257 cb->callback = unplug; 1258 list_add(&cb->list, &plug->cb_list); 1259 } 1260 return cb; 1261 } 1262 EXPORT_SYMBOL(blk_check_plugged); 1263 1264 void blk_flush_plug(struct blk_plug *plug, bool from_schedule) 1265 { 1266 if (!list_empty(&plug->cb_list)) 1267 flush_plug_callbacks(plug, from_schedule); 1268 if (!rq_list_empty(plug->mq_list)) 1269 blk_mq_flush_plug_list(plug, from_schedule); 1270 /* 1271 * Unconditionally flush out cached requests, even if the unplug 1272 * event came from schedule. Since we know hold references to the 1273 * queue for cached requests, we don't want a blocked task holding 1274 * up a queue freeze/quiesce event. 1275 */ 1276 if (unlikely(!rq_list_empty(plug->cached_rq))) 1277 blk_mq_free_plug_rqs(plug); 1278 } 1279 1280 /** 1281 * blk_finish_plug - mark the end of a batch of submitted I/O 1282 * @plug: The &struct blk_plug passed to blk_start_plug() 1283 * 1284 * Description: 1285 * Indicate that a batch of I/O submissions is complete. This function 1286 * must be paired with an initial call to blk_start_plug(). The intent 1287 * is to allow the block layer to optimize I/O submission. See the 1288 * documentation for blk_start_plug() for more information. 1289 */ 1290 void blk_finish_plug(struct blk_plug *plug) 1291 { 1292 if (plug == current->plug) { 1293 blk_flush_plug(plug, false); 1294 current->plug = NULL; 1295 } 1296 } 1297 EXPORT_SYMBOL(blk_finish_plug); 1298 1299 void blk_io_schedule(void) 1300 { 1301 /* Prevent hang_check timer from firing at us during very long I/O */ 1302 unsigned long timeout = sysctl_hung_task_timeout_secs * HZ / 2; 1303 1304 if (timeout) 1305 io_schedule_timeout(timeout); 1306 else 1307 io_schedule(); 1308 } 1309 EXPORT_SYMBOL_GPL(blk_io_schedule); 1310 1311 int __init blk_dev_init(void) 1312 { 1313 BUILD_BUG_ON(REQ_OP_LAST >= (1 << REQ_OP_BITS)); 1314 BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 * 1315 sizeof_field(struct request, cmd_flags)); 1316 BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 * 1317 sizeof_field(struct bio, bi_opf)); 1318 BUILD_BUG_ON(ALIGN(offsetof(struct request_queue, srcu), 1319 __alignof__(struct request_queue)) != 1320 sizeof(struct request_queue)); 1321 1322 /* used for unplugging and affects IO latency/throughput - HIGHPRI */ 1323 kblockd_workqueue = alloc_workqueue("kblockd", 1324 WQ_MEM_RECLAIM | WQ_HIGHPRI, 0); 1325 if (!kblockd_workqueue) 1326 panic("Failed to create kblockd\n"); 1327 1328 blk_requestq_cachep = kmem_cache_create("request_queue", 1329 sizeof(struct request_queue), 0, SLAB_PANIC, NULL); 1330 1331 blk_requestq_srcu_cachep = kmem_cache_create("request_queue_srcu", 1332 sizeof(struct request_queue) + 1333 sizeof(struct srcu_struct), 0, SLAB_PANIC, NULL); 1334 1335 blk_debugfs_root = debugfs_create_dir("block", NULL); 1336 1337 return 0; 1338 } 1339