LCOV - code coverage report
Current view: top level - block - blk-core.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 274 625 43.8 %
Date: 2021-04-22 12:43:58 Functions: 33 64 51.6 %

          Line data    Source code
       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/backing-dev.h>
      18             : #include <linux/bio.h>
      19             : #include <linux/blkdev.h>
      20             : #include <linux/blk-mq.h>
      21             : #include <linux/blk-pm.h>
      22             : #include <linux/highmem.h>
      23             : #include <linux/mm.h>
      24             : #include <linux/pagemap.h>
      25             : #include <linux/kernel_stat.h>
      26             : #include <linux/string.h>
      27             : #include <linux/init.h>
      28             : #include <linux/completion.h>
      29             : #include <linux/slab.h>
      30             : #include <linux/swap.h>
      31             : #include <linux/writeback.h>
      32             : #include <linux/task_io_accounting_ops.h>
      33             : #include <linux/fault-inject.h>
      34             : #include <linux/list_sort.h>
      35             : #include <linux/delay.h>
      36             : #include <linux/ratelimit.h>
      37             : #include <linux/pm_runtime.h>
      38             : #include <linux/blk-cgroup.h>
      39             : #include <linux/t10-pi.h>
      40             : #include <linux/debugfs.h>
      41             : #include <linux/bpf.h>
      42             : #include <linux/psi.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.h"
      51             : #include "blk-mq-sched.h"
      52             : #include "blk-pm.h"
      53             : #include "blk-rq-qos.h"
      54             : 
      55             : struct dentry *blk_debugfs_root;
      56             : 
      57             : EXPORT_TRACEPOINT_SYMBOL_GPL(block_bio_remap);
      58             : EXPORT_TRACEPOINT_SYMBOL_GPL(block_rq_remap);
      59             : EXPORT_TRACEPOINT_SYMBOL_GPL(block_bio_complete);
      60             : EXPORT_TRACEPOINT_SYMBOL_GPL(block_split);
      61             : EXPORT_TRACEPOINT_SYMBOL_GPL(block_unplug);
      62             : EXPORT_TRACEPOINT_SYMBOL_GPL(block_rq_insert);
      63             : 
      64             : DEFINE_IDA(blk_queue_ida);
      65             : 
      66             : /*
      67             :  * For queue allocation
      68             :  */
      69             : struct kmem_cache *blk_requestq_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          28 : void blk_queue_flag_set(unsigned int flag, struct request_queue *q)
      82             : {
      83          28 :         set_bit(flag, &q->queue_flags);
      84          28 : }
      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           1 : void blk_queue_flag_clear(unsigned int flag, struct request_queue *q)
      93             : {
      94           1 :         clear_bit(flag, &q->queue_flags);
      95           1 : }
      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           0 : bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q)
     107             : {
     108           0 :         return test_and_set_bit(flag, &q->queue_flags);
     109             : }
     110             : EXPORT_SYMBOL_GPL(blk_queue_flag_test_and_set);
     111             : 
     112         191 : void blk_rq_init(struct request_queue *q, struct request *rq)
     113             : {
     114         191 :         memset(rq, 0, sizeof(*rq));
     115             : 
     116         191 :         INIT_LIST_HEAD(&rq->queuelist);
     117         191 :         rq->q = q;
     118         191 :         rq->__sector = (sector_t) -1;
     119         191 :         INIT_HLIST_NODE(&rq->hash);
     120         191 :         RB_CLEAR_NODE(&rq->rb_node);
     121         191 :         rq->tag = BLK_MQ_NO_TAG;
     122         191 :         rq->internal_tag = BLK_MQ_NO_TAG;
     123         191 :         rq->start_time_ns = ktime_get_ns();
     124         191 :         rq->part = NULL;
     125         191 :         refcount_set(&rq->ref, 1);
     126         191 :         blk_crypto_rq_set_defaults(rq);
     127         191 : }
     128             : EXPORT_SYMBOL(blk_rq_init);
     129             : 
     130             : #define REQ_OP_NAME(name) [REQ_OP_##name] = #name
     131             : static const char *const blk_op_name[] = {
     132             :         REQ_OP_NAME(READ),
     133             :         REQ_OP_NAME(WRITE),
     134             :         REQ_OP_NAME(FLUSH),
     135             :         REQ_OP_NAME(DISCARD),
     136             :         REQ_OP_NAME(SECURE_ERASE),
     137             :         REQ_OP_NAME(ZONE_RESET),
     138             :         REQ_OP_NAME(ZONE_RESET_ALL),
     139             :         REQ_OP_NAME(ZONE_OPEN),
     140             :         REQ_OP_NAME(ZONE_CLOSE),
     141             :         REQ_OP_NAME(ZONE_FINISH),
     142             :         REQ_OP_NAME(ZONE_APPEND),
     143             :         REQ_OP_NAME(WRITE_SAME),
     144             :         REQ_OP_NAME(WRITE_ZEROES),
     145             :         REQ_OP_NAME(SCSI_IN),
     146             :         REQ_OP_NAME(SCSI_OUT),
     147             :         REQ_OP_NAME(DRV_IN),
     148             :         REQ_OP_NAME(DRV_OUT),
     149             : };
     150             : #undef REQ_OP_NAME
     151             : 
     152             : /**
     153             :  * blk_op_str - Return string XXX in the REQ_OP_XXX.
     154             :  * @op: REQ_OP_XXX.
     155             :  *
     156             :  * Description: Centralize block layer function to convert REQ_OP_XXX into
     157             :  * string format. Useful in the debugging and tracing bio or request. For
     158             :  * invalid REQ_OP_XXX it returns string "UNKNOWN".
     159             :  */
     160           0 : inline const char *blk_op_str(unsigned int op)
     161             : {
     162           0 :         const char *op_str = "UNKNOWN";
     163             : 
     164           0 :         if (op < ARRAY_SIZE(blk_op_name) && blk_op_name[op])
     165           0 :                 op_str = blk_op_name[op];
     166             : 
     167           0 :         return op_str;
     168             : }
     169             : EXPORT_SYMBOL_GPL(blk_op_str);
     170             : 
     171             : static const struct {
     172             :         int             errno;
     173             :         const char      *name;
     174             : } blk_errors[] = {
     175             :         [BLK_STS_OK]            = { 0,          "" },
     176             :         [BLK_STS_NOTSUPP]       = { -EOPNOTSUPP, "operation not supported" },
     177             :         [BLK_STS_TIMEOUT]       = { -ETIMEDOUT, "timeout" },
     178             :         [BLK_STS_NOSPC]         = { -ENOSPC,    "critical space allocation" },
     179             :         [BLK_STS_TRANSPORT]     = { -ENOLINK,   "recoverable transport" },
     180             :         [BLK_STS_TARGET]        = { -EREMOTEIO, "critical target" },
     181             :         [BLK_STS_NEXUS]         = { -EBADE,     "critical nexus" },
     182             :         [BLK_STS_MEDIUM]        = { -ENODATA,   "critical medium" },
     183             :         [BLK_STS_PROTECTION]    = { -EILSEQ,    "protection" },
     184             :         [BLK_STS_RESOURCE]      = { -ENOMEM,    "kernel resource" },
     185             :         [BLK_STS_DEV_RESOURCE]  = { -EBUSY,     "device resource" },
     186             :         [BLK_STS_AGAIN]         = { -EAGAIN,    "nonblocking retry" },
     187             : 
     188             :         /* device mapper special case, should not leak out: */
     189             :         [BLK_STS_DM_REQUEUE]    = { -EREMCHG, "dm internal retry" },
     190             : 
     191             :         /* zone device specific errors */
     192             :         [BLK_STS_ZONE_OPEN_RESOURCE]    = { -ETOOMANYREFS, "open zones exceeded" },
     193             :         [BLK_STS_ZONE_ACTIVE_RESOURCE]  = { -EOVERFLOW, "active zones exceeded" },
     194             : 
     195             :         /* everything else not covered above: */
     196             :         [BLK_STS_IOERR]         = { -EIO,       "I/O" },
     197             : };
     198             : 
     199           0 : blk_status_t errno_to_blk_status(int errno)
     200             : {
     201           0 :         int i;
     202             : 
     203           0 :         for (i = 0; i < ARRAY_SIZE(blk_errors); i++) {
     204           0 :                 if (blk_errors[i].errno == errno)
     205           0 :                         return (__force blk_status_t)i;
     206             :         }
     207             : 
     208             :         return BLK_STS_IOERR;
     209             : }
     210             : EXPORT_SYMBOL_GPL(errno_to_blk_status);
     211             : 
     212        4095 : int blk_status_to_errno(blk_status_t status)
     213             : {
     214        4095 :         int idx = (__force int)status;
     215             : 
     216        4095 :         if (WARN_ON_ONCE(idx >= ARRAY_SIZE(blk_errors)))
     217             :                 return -EIO;
     218        4095 :         return blk_errors[idx].errno;
     219             : }
     220             : EXPORT_SYMBOL_GPL(blk_status_to_errno);
     221             : 
     222           0 : static void print_req_error(struct request *req, blk_status_t status,
     223             :                 const char *caller)
     224             : {
     225           0 :         int idx = (__force int)status;
     226             : 
     227           0 :         if (WARN_ON_ONCE(idx >= ARRAY_SIZE(blk_errors)))
     228             :                 return;
     229             : 
     230           0 :         printk_ratelimited(KERN_ERR
     231             :                 "%s: %s error, dev %s, sector %llu op 0x%x:(%s) flags 0x%x "
     232             :                 "phys_seg %u prio class %u\n",
     233             :                 caller, blk_errors[idx].name,
     234             :                 req->rq_disk ? req->rq_disk->disk_name : "?",
     235             :                 blk_rq_pos(req), req_op(req), blk_op_str(req_op(req)),
     236             :                 req->cmd_flags & ~REQ_OP_MASK,
     237             :                 req->nr_phys_segments,
     238             :                 IOPRIO_PRIO_CLASS(req->ioprio));
     239             : }
     240             : 
     241        8799 : static void req_bio_endio(struct request *rq, struct bio *bio,
     242             :                           unsigned int nbytes, blk_status_t error)
     243             : {
     244        8799 :         if (error)
     245           0 :                 bio->bi_status = error;
     246             : 
     247        8799 :         if (unlikely(rq->rq_flags & RQF_QUIET))
     248           0 :                 bio_set_flag(bio, BIO_QUIET);
     249             : 
     250        8799 :         bio_advance(bio, nbytes);
     251             : 
     252        8798 :         if (req_op(rq) == REQ_OP_ZONE_APPEND && error == BLK_STS_OK) {
     253             :                 /*
     254             :                  * Partial zone append completions cannot be supported as the
     255             :                  * BIO fragments may end up not being written sequentially.
     256             :                  */
     257           0 :                 if (bio->bi_iter.bi_size)
     258           0 :                         bio->bi_status = BLK_STS_IOERR;
     259             :                 else
     260           0 :                         bio->bi_iter.bi_sector = rq->__sector;
     261             :         }
     262             : 
     263             :         /* don't actually finish bio if it's part of flush sequence */
     264        8798 :         if (bio->bi_iter.bi_size == 0 && !(rq->rq_flags & RQF_FLUSH_SEQ))
     265        8738 :                 bio_endio(bio);
     266        8799 : }
     267             : 
     268           0 : void blk_dump_rq_flags(struct request *rq, char *msg)
     269             : {
     270           0 :         printk(KERN_INFO "%s: dev %s: flags=%llx\n", msg,
     271           0 :                 rq->rq_disk ? rq->rq_disk->disk_name : "?",
     272           0 :                 (unsigned long long) rq->cmd_flags);
     273             : 
     274           0 :         printk(KERN_INFO "  sector %llu, nr/cnr %u/%u\n",
     275           0 :                (unsigned long long)blk_rq_pos(rq),
     276             :                blk_rq_sectors(rq), blk_rq_cur_sectors(rq));
     277           0 :         printk(KERN_INFO "  bio %p, biotail %p, len %u\n",
     278             :                rq->bio, rq->biotail, blk_rq_bytes(rq));
     279           0 : }
     280             : EXPORT_SYMBOL(blk_dump_rq_flags);
     281             : 
     282             : /**
     283             :  * blk_sync_queue - cancel any pending callbacks on a queue
     284             :  * @q: the queue
     285             :  *
     286             :  * Description:
     287             :  *     The block layer may perform asynchronous callback activity
     288             :  *     on a queue, such as calling the unplug function after a timeout.
     289             :  *     A block device may call blk_sync_queue to ensure that any
     290             :  *     such activity is cancelled, thus allowing it to release resources
     291             :  *     that the callbacks might use. The caller must already have made sure
     292             :  *     that its ->submit_bio will not re-add plugging prior to calling
     293             :  *     this function.
     294             :  *
     295             :  *     This function does not cancel any asynchronous activity arising
     296             :  *     out of elevator or throttling code. That would require elevator_exit()
     297             :  *     and blkcg_exit_queue() to be called with queue lock initialized.
     298             :  *
     299             :  */
     300           0 : void blk_sync_queue(struct request_queue *q)
     301             : {
     302           0 :         del_timer_sync(&q->timeout);
     303           0 :         cancel_work_sync(&q->timeout_work);
     304           0 : }
     305             : EXPORT_SYMBOL(blk_sync_queue);
     306             : 
     307             : /**
     308             :  * blk_set_pm_only - increment pm_only counter
     309             :  * @q: request queue pointer
     310             :  */
     311           0 : void blk_set_pm_only(struct request_queue *q)
     312             : {
     313           0 :         atomic_inc(&q->pm_only);
     314           0 : }
     315             : EXPORT_SYMBOL_GPL(blk_set_pm_only);
     316             : 
     317           0 : void blk_clear_pm_only(struct request_queue *q)
     318             : {
     319           0 :         int pm_only;
     320             : 
     321           0 :         pm_only = atomic_dec_return(&q->pm_only);
     322           0 :         WARN_ON_ONCE(pm_only < 0);
     323           0 :         if (pm_only == 0)
     324           0 :                 wake_up_all(&q->mq_freeze_wq);
     325           0 : }
     326             : EXPORT_SYMBOL_GPL(blk_clear_pm_only);
     327             : 
     328             : /**
     329             :  * blk_put_queue - decrement the request_queue refcount
     330             :  * @q: the request_queue structure to decrement the refcount for
     331             :  *
     332             :  * Decrements the refcount of the request_queue kobject. When this reaches 0
     333             :  * we'll have blk_release_queue() called.
     334             :  *
     335             :  * Context: Any context, but the last reference must not be dropped from
     336             :  *          atomic context.
     337             :  */
     338           0 : void blk_put_queue(struct request_queue *q)
     339             : {
     340           0 :         kobject_put(&q->kobj);
     341           0 : }
     342             : EXPORT_SYMBOL(blk_put_queue);
     343             : 
     344           0 : void blk_set_queue_dying(struct request_queue *q)
     345             : {
     346           0 :         blk_queue_flag_set(QUEUE_FLAG_DYING, q);
     347             : 
     348             :         /*
     349             :          * When queue DYING flag is set, we need to block new req
     350             :          * entering queue, so we call blk_freeze_queue_start() to
     351             :          * prevent I/O from crossing blk_queue_enter().
     352             :          */
     353           0 :         blk_freeze_queue_start(q);
     354             : 
     355           0 :         if (queue_is_mq(q))
     356           0 :                 blk_mq_wake_waiters(q);
     357             : 
     358             :         /* Make blk_queue_enter() reexamine the DYING flag. */
     359           0 :         wake_up_all(&q->mq_freeze_wq);
     360           0 : }
     361             : EXPORT_SYMBOL_GPL(blk_set_queue_dying);
     362             : 
     363             : /**
     364             :  * blk_cleanup_queue - shutdown a request queue
     365             :  * @q: request queue to shutdown
     366             :  *
     367             :  * Mark @q DYING, drain all pending requests, mark @q DEAD, destroy and
     368             :  * put it.  All future requests will be failed immediately with -ENODEV.
     369             :  *
     370             :  * Context: can sleep
     371             :  */
     372           0 : void blk_cleanup_queue(struct request_queue *q)
     373             : {
     374             :         /* cannot be called from atomic context */
     375           0 :         might_sleep();
     376             : 
     377           0 :         WARN_ON_ONCE(blk_queue_registered(q));
     378             : 
     379             :         /* mark @q DYING, no new request or merges will be allowed afterwards */
     380           0 :         blk_set_queue_dying(q);
     381             : 
     382           0 :         blk_queue_flag_set(QUEUE_FLAG_NOMERGES, q);
     383           0 :         blk_queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
     384             : 
     385             :         /*
     386             :          * Drain all requests queued before DYING marking. Set DEAD flag to
     387             :          * prevent that blk_mq_run_hw_queues() accesses the hardware queues
     388             :          * after draining finished.
     389             :          */
     390           0 :         blk_freeze_queue(q);
     391             : 
     392           0 :         rq_qos_exit(q);
     393             : 
     394           0 :         blk_queue_flag_set(QUEUE_FLAG_DEAD, q);
     395             : 
     396             :         /* for synchronous bio-based driver finish in-flight integrity i/o */
     397           0 :         blk_flush_integrity();
     398             : 
     399             :         /* @q won't process any more request, flush async actions */
     400           0 :         del_timer_sync(&q->backing_dev_info->laptop_mode_wb_timer);
     401           0 :         blk_sync_queue(q);
     402             : 
     403           0 :         if (queue_is_mq(q))
     404           0 :                 blk_mq_exit_queue(q);
     405             : 
     406             :         /*
     407             :          * In theory, request pool of sched_tags belongs to request queue.
     408             :          * However, the current implementation requires tag_set for freeing
     409             :          * requests, so free the pool now.
     410             :          *
     411             :          * Queue has become frozen, there can't be any in-queue requests, so
     412             :          * it is safe to free requests now.
     413             :          */
     414           0 :         mutex_lock(&q->sysfs_lock);
     415           0 :         if (q->elevator)
     416           0 :                 blk_mq_sched_free_requests(q);
     417           0 :         mutex_unlock(&q->sysfs_lock);
     418             : 
     419           0 :         percpu_ref_exit(&q->q_usage_counter);
     420             : 
     421             :         /* @q is and will stay empty, shutdown and put */
     422           0 :         blk_put_queue(q);
     423           0 : }
     424             : EXPORT_SYMBOL(blk_cleanup_queue);
     425             : 
     426             : /**
     427             :  * blk_queue_enter() - try to increase q->q_usage_counter
     428             :  * @q: request queue pointer
     429             :  * @flags: BLK_MQ_REQ_NOWAIT and/or BLK_MQ_REQ_PM
     430             :  */
     431        8738 : int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags)
     432             : {
     433        8738 :         const bool pm = flags & BLK_MQ_REQ_PM;
     434             : 
     435        8738 :         while (true) {
     436        8738 :                 bool success = false;
     437             : 
     438        8738 :                 rcu_read_lock();
     439        8738 :                 if (percpu_ref_tryget_live(&q->q_usage_counter)) {
     440             :                         /*
     441             :                          * The code that increments the pm_only counter is
     442             :                          * responsible for ensuring that that counter is
     443             :                          * globally visible before the queue is unfrozen.
     444             :                          */
     445        8738 :                         if ((pm && queue_rpm_status(q) != RPM_SUSPENDED) ||
     446        8738 :                             !blk_queue_pm_only(q)) {
     447        8738 :                                 success = true;
     448             :                         } else {
     449           0 :                                 percpu_ref_put(&q->q_usage_counter);
     450             :                         }
     451             :                 }
     452        8738 :                 rcu_read_unlock();
     453             : 
     454           0 :                 if (success)
     455        8738 :                         return 0;
     456             : 
     457           0 :                 if (flags & BLK_MQ_REQ_NOWAIT)
     458             :                         return -EBUSY;
     459             : 
     460             :                 /*
     461             :                  * read pair of barrier in blk_freeze_queue_start(),
     462             :                  * we need to order reading __PERCPU_REF_DEAD flag of
     463             :                  * .q_usage_counter and reading .mq_freeze_depth or
     464             :                  * queue dying flag, otherwise the following wait may
     465             :                  * never return if the two reads are reordered.
     466             :                  */
     467           0 :                 smp_rmb();
     468             : 
     469           0 :                 wait_event(q->mq_freeze_wq,
     470             :                            (!q->mq_freeze_depth &&
     471             :                             blk_pm_resume_queue(pm, q)) ||
     472             :                            blk_queue_dying(q));
     473           0 :                 if (blk_queue_dying(q))
     474             :                         return -ENODEV;
     475             :         }
     476             : }
     477             : 
     478        8736 : static inline int bio_queue_enter(struct bio *bio)
     479             : {
     480        8736 :         struct request_queue *q = bio->bi_bdev->bd_disk->queue;
     481        8736 :         bool nowait = bio->bi_opf & REQ_NOWAIT;
     482        8736 :         int ret;
     483             : 
     484        8736 :         ret = blk_queue_enter(q, nowait ? BLK_MQ_REQ_NOWAIT : 0);
     485        8737 :         if (unlikely(ret)) {
     486           0 :                 if (nowait && !blk_queue_dying(q))
     487           0 :                         bio_wouldblock_error(bio);
     488             :                 else
     489           0 :                         bio_io_error(bio);
     490             :         }
     491             : 
     492        8737 :         return ret;
     493             : }
     494             : 
     495        8755 : void blk_queue_exit(struct request_queue *q)
     496             : {
     497        8755 :         percpu_ref_put(&q->q_usage_counter);
     498        8755 : }
     499             : 
     500           0 : static void blk_queue_usage_counter_release(struct percpu_ref *ref)
     501             : {
     502           0 :         struct request_queue *q =
     503           0 :                 container_of(ref, struct request_queue, q_usage_counter);
     504             : 
     505           0 :         wake_up_all(&q->mq_freeze_wq);
     506           0 : }
     507             : 
     508           8 : static void blk_rq_timed_out_timer(struct timer_list *t)
     509             : {
     510           8 :         struct request_queue *q = from_timer(q, t, timeout);
     511             : 
     512           8 :         kblockd_schedule_work(&q->timeout_work);
     513           8 : }
     514             : 
     515           0 : static void blk_timeout_work(struct work_struct *work)
     516             : {
     517           0 : }
     518             : 
     519           9 : struct request_queue *blk_alloc_queue(int node_id)
     520             : {
     521           9 :         struct request_queue *q;
     522           9 :         int ret;
     523             : 
     524           9 :         q = kmem_cache_alloc_node(blk_requestq_cachep,
     525             :                                 GFP_KERNEL | __GFP_ZERO, node_id);
     526           9 :         if (!q)
     527             :                 return NULL;
     528             : 
     529           9 :         q->last_merge = NULL;
     530             : 
     531           9 :         q->id = ida_simple_get(&blk_queue_ida, 0, 0, GFP_KERNEL);
     532           9 :         if (q->id < 0)
     533           0 :                 goto fail_q;
     534             : 
     535           9 :         ret = bioset_init(&q->bio_split, BIO_POOL_SIZE, 0, 0);
     536           9 :         if (ret)
     537           0 :                 goto fail_id;
     538             : 
     539           9 :         q->backing_dev_info = bdi_alloc(node_id);
     540           9 :         if (!q->backing_dev_info)
     541           0 :                 goto fail_split;
     542             : 
     543           9 :         q->stats = blk_alloc_queue_stats();
     544           9 :         if (!q->stats)
     545           0 :                 goto fail_stats;
     546             : 
     547           9 :         q->node = node_id;
     548             : 
     549           9 :         atomic_set(&q->nr_active_requests_shared_sbitmap, 0);
     550             : 
     551           9 :         timer_setup(&q->backing_dev_info->laptop_mode_wb_timer,
     552             :                     laptop_mode_timer_fn, 0);
     553           9 :         timer_setup(&q->timeout, blk_rq_timed_out_timer, 0);
     554           9 :         INIT_WORK(&q->timeout_work, blk_timeout_work);
     555           9 :         INIT_LIST_HEAD(&q->icq_list);
     556             : #ifdef CONFIG_BLK_CGROUP
     557             :         INIT_LIST_HEAD(&q->blkg_list);
     558             : #endif
     559             : 
     560           9 :         kobject_init(&q->kobj, &blk_queue_ktype);
     561             : 
     562           9 :         mutex_init(&q->debugfs_mutex);
     563           9 :         mutex_init(&q->sysfs_lock);
     564           9 :         mutex_init(&q->sysfs_dir_lock);
     565           9 :         spin_lock_init(&q->queue_lock);
     566             : 
     567           9 :         init_waitqueue_head(&q->mq_freeze_wq);
     568           9 :         mutex_init(&q->mq_freeze_lock);
     569             : 
     570             :         /*
     571             :          * Init percpu_ref in atomic mode so that it's faster to shutdown.
     572             :          * See blk_register_queue() for details.
     573             :          */
     574           9 :         if (percpu_ref_init(&q->q_usage_counter,
     575             :                                 blk_queue_usage_counter_release,
     576             :                                 PERCPU_REF_INIT_ATOMIC, GFP_KERNEL))
     577           0 :                 goto fail_bdi;
     578             : 
     579           9 :         if (blkcg_init_queue(q))
     580             :                 goto fail_ref;
     581             : 
     582           9 :         blk_queue_dma_alignment(q, 511);
     583           9 :         blk_set_default_limits(&q->limits);
     584           9 :         q->nr_requests = BLKDEV_MAX_RQ;
     585             : 
     586           9 :         return q;
     587             : 
     588             : fail_ref:
     589             :         percpu_ref_exit(&q->q_usage_counter);
     590           0 : fail_bdi:
     591           0 :         blk_free_queue_stats(q->stats);
     592           0 : fail_stats:
     593           0 :         bdi_put(q->backing_dev_info);
     594           0 : fail_split:
     595           0 :         bioset_exit(&q->bio_split);
     596           0 : fail_id:
     597           0 :         ida_simple_remove(&blk_queue_ida, q->id);
     598           0 : fail_q:
     599           0 :         kmem_cache_free(blk_requestq_cachep, q);
     600           0 :         return NULL;
     601             : }
     602             : EXPORT_SYMBOL(blk_alloc_queue);
     603             : 
     604             : /**
     605             :  * blk_get_queue - increment the request_queue refcount
     606             :  * @q: the request_queue structure to increment the refcount for
     607             :  *
     608             :  * Increment the refcount of the request_queue kobject.
     609             :  *
     610             :  * Context: Any context.
     611             :  */
     612           9 : bool blk_get_queue(struct request_queue *q)
     613             : {
     614           9 :         if (likely(!blk_queue_dying(q))) {
     615           9 :                 __blk_get_queue(q);
     616           9 :                 return true;
     617             :         }
     618             : 
     619             :         return false;
     620             : }
     621             : EXPORT_SYMBOL(blk_get_queue);
     622             : 
     623             : /**
     624             :  * blk_get_request - allocate a request
     625             :  * @q: request queue to allocate a request for
     626             :  * @op: operation (REQ_OP_*) and REQ_* flags, e.g. REQ_SYNC.
     627             :  * @flags: BLK_MQ_REQ_* flags, e.g. BLK_MQ_REQ_NOWAIT.
     628             :  */
     629           2 : struct request *blk_get_request(struct request_queue *q, unsigned int op,
     630             :                                 blk_mq_req_flags_t flags)
     631             : {
     632           2 :         struct request *req;
     633             : 
     634           2 :         WARN_ON_ONCE(op & REQ_NOWAIT);
     635           2 :         WARN_ON_ONCE(flags & ~(BLK_MQ_REQ_NOWAIT | BLK_MQ_REQ_PM));
     636             : 
     637           2 :         req = blk_mq_alloc_request(q, op, flags);
     638           2 :         if (!IS_ERR(req) && q->mq_ops->initialize_rq_fn)
     639           0 :                 q->mq_ops->initialize_rq_fn(req);
     640             : 
     641           2 :         return req;
     642             : }
     643             : EXPORT_SYMBOL(blk_get_request);
     644             : 
     645           2 : void blk_put_request(struct request *req)
     646             : {
     647           2 :         blk_mq_free_request(req);
     648           2 : }
     649             : EXPORT_SYMBOL(blk_put_request);
     650             : 
     651           0 : static void handle_bad_sector(struct bio *bio, sector_t maxsector)
     652             : {
     653           0 :         char b[BDEVNAME_SIZE];
     654             : 
     655           0 :         pr_info_ratelimited("attempt to access beyond end of device\n"
     656             :                             "%s: rw=%d, want=%llu, limit=%llu\n",
     657             :                             bio_devname(bio, b), bio->bi_opf,
     658             :                             bio_end_sector(bio), maxsector);
     659           0 : }
     660             : 
     661             : #ifdef CONFIG_FAIL_MAKE_REQUEST
     662             : 
     663             : static DECLARE_FAULT_ATTR(fail_make_request);
     664             : 
     665             : static int __init setup_fail_make_request(char *str)
     666             : {
     667             :         return setup_fault_attr(&fail_make_request, str);
     668             : }
     669             : __setup("fail_make_request=", setup_fail_make_request);
     670             : 
     671             : static bool should_fail_request(struct block_device *part, unsigned int bytes)
     672             : {
     673             :         return part->bd_make_it_fail && should_fail(&fail_make_request, bytes);
     674             : }
     675             : 
     676             : static int __init fail_make_request_debugfs(void)
     677             : {
     678             :         struct dentry *dir = fault_create_debugfs_attr("fail_make_request",
     679             :                                                 NULL, &fail_make_request);
     680             : 
     681             :         return PTR_ERR_OR_ZERO(dir);
     682             : }
     683             : 
     684             : late_initcall(fail_make_request_debugfs);
     685             : 
     686             : #else /* CONFIG_FAIL_MAKE_REQUEST */
     687             : 
     688       17423 : static inline bool should_fail_request(struct block_device *part,
     689             :                                         unsigned int bytes)
     690             : {
     691       17423 :         return false;
     692             : }
     693             : 
     694             : #endif /* CONFIG_FAIL_MAKE_REQUEST */
     695             : 
     696        8737 : static inline bool bio_check_ro(struct bio *bio)
     697             : {
     698        8737 :         if (op_is_write(bio_op(bio)) && bdev_read_only(bio->bi_bdev)) {
     699           0 :                 char b[BDEVNAME_SIZE];
     700             : 
     701           0 :                 if (op_is_flush(bio->bi_opf) && !bio_sectors(bio))
     702             :                         return false;
     703             : 
     704           0 :                 WARN_ONCE(1,
     705             :                        "Trying to write to read-only block-device %s (partno %d)\n",
     706             :                         bio_devname(bio, b), bio->bi_bdev->bd_partno);
     707             :                 /* Older lvm-tools actually trigger this */
     708           0 :                 return false;
     709             :         }
     710             : 
     711             :         return false;
     712             : }
     713             : 
     714        8736 : static noinline int should_fail_bio(struct bio *bio)
     715             : {
     716        8736 :         if (should_fail_request(bdev_whole(bio->bi_bdev), bio->bi_iter.bi_size))
     717             :                 return -EIO;
     718        8736 :         return 0;
     719             : }
     720             : ALLOW_ERROR_INJECTION(should_fail_bio, ERRNO);
     721             : 
     722             : /*
     723             :  * Check whether this bio extends beyond the end of the device or partition.
     724             :  * This may well happen - the kernel calls bread() without checking the size of
     725             :  * the device, e.g., when mounting a file system.
     726             :  */
     727        8737 : static inline int bio_check_eod(struct bio *bio)
     728             : {
     729        8737 :         sector_t maxsector = bdev_nr_sectors(bio->bi_bdev);
     730        8737 :         unsigned int nr_sectors = bio_sectors(bio);
     731             : 
     732        8737 :         if (nr_sectors && maxsector &&
     733        8665 :             (nr_sectors > maxsector ||
     734        8665 :              bio->bi_iter.bi_sector > maxsector - nr_sectors)) {
     735           0 :                 handle_bad_sector(bio, maxsector);
     736           0 :                 return -EIO;
     737             :         }
     738             :         return 0;
     739             : }
     740             : 
     741             : /*
     742             :  * Remap block n of partition p to block n+start(p) of the disk.
     743             :  */
     744        8687 : static int blk_partition_remap(struct bio *bio)
     745             : {
     746        8687 :         struct block_device *p = bio->bi_bdev;
     747             : 
     748        8687 :         if (unlikely(should_fail_request(p, bio->bi_iter.bi_size)))
     749             :                 return -EIO;
     750        8687 :         if (bio_sectors(bio)) {
     751        8614 :                 bio->bi_iter.bi_sector += p->bd_start_sect;
     752        8614 :                 trace_block_bio_remap(bio, p->bd_dev,
     753             :                                       bio->bi_iter.bi_sector -
     754        8614 :                                       p->bd_start_sect);
     755             :         }
     756        8689 :         bio_set_flag(bio, BIO_REMAPPED);
     757        8689 :         return 0;
     758             : }
     759             : 
     760             : /*
     761             :  * Check write append to a zoned block device.
     762             :  */
     763           0 : static inline blk_status_t blk_check_zone_append(struct request_queue *q,
     764             :                                                  struct bio *bio)
     765             : {
     766           0 :         sector_t pos = bio->bi_iter.bi_sector;
     767           0 :         int nr_sectors = bio_sectors(bio);
     768             : 
     769             :         /* Only applicable to zoned block devices */
     770           0 :         if (!blk_queue_is_zoned(q))
     771           0 :                 return BLK_STS_NOTSUPP;
     772             : 
     773             :         /* The bio sector must point to the start of a sequential zone */
     774             :         if (pos & (blk_queue_zone_sectors(q) - 1) ||
     775             :             !blk_queue_zone_is_seq(q, pos))
     776             :                 return BLK_STS_IOERR;
     777             : 
     778             :         /*
     779             :          * Not allowed to cross zone boundaries. Otherwise, the BIO will be
     780             :          * split and could result in non-contiguous sectors being written in
     781             :          * different zones.
     782             :          */
     783             :         if (nr_sectors > q->limits.chunk_sectors)
     784             :                 return BLK_STS_IOERR;
     785             : 
     786             :         /* Make sure the BIO is small enough and will not get split */
     787             :         if (nr_sectors > q->limits.max_zone_append_sectors)
     788             :                 return BLK_STS_IOERR;
     789             : 
     790             :         bio->bi_opf |= REQ_NOMERGE;
     791             : 
     792             :         return BLK_STS_OK;
     793             : }
     794             : 
     795        8737 : static noinline_for_stack bool submit_bio_checks(struct bio *bio)
     796             : {
     797        8737 :         struct block_device *bdev = bio->bi_bdev;
     798        8737 :         struct request_queue *q = bdev->bd_disk->queue;
     799        8737 :         blk_status_t status = BLK_STS_IOERR;
     800        8737 :         struct blk_plug *plug;
     801             : 
     802        8737 :         might_sleep();
     803             : 
     804        8737 :         plug = blk_mq_plug(q, bio);
     805        8737 :         if (plug && plug->nowait)
     806           0 :                 bio->bi_opf |= REQ_NOWAIT;
     807             : 
     808             :         /*
     809             :          * For a REQ_NOWAIT based request, return -EOPNOTSUPP
     810             :          * if queue does not support NOWAIT.
     811             :          */
     812        8737 :         if ((bio->bi_opf & REQ_NOWAIT) && !blk_queue_nowait(q))
     813           0 :                 goto not_supported;
     814             : 
     815        8737 :         if (should_fail_bio(bio))
     816           0 :                 goto end_io;
     817        8737 :         if (unlikely(bio_check_ro(bio)))
     818           0 :                 goto end_io;
     819        8737 :         if (!bio_flagged(bio, BIO_REMAPPED)) {
     820        8737 :                 if (unlikely(bio_check_eod(bio)))
     821           0 :                         goto end_io;
     822        8737 :                 if (bdev->bd_partno && unlikely(blk_partition_remap(bio)))
     823           0 :                         goto end_io;
     824             :         }
     825             : 
     826             :         /*
     827             :          * Filter flush bio's early so that bio based drivers without flush
     828             :          * support don't have to worry about them.
     829             :          */
     830        8737 :         if (op_is_flush(bio->bi_opf) &&
     831         132 :             !test_bit(QUEUE_FLAG_WC, &q->queue_flags)) {
     832           0 :                 bio->bi_opf &= ~(REQ_PREFLUSH | REQ_FUA);
     833           0 :                 if (!bio_sectors(bio)) {
     834           0 :                         status = BLK_STS_OK;
     835           0 :                         goto end_io;
     836             :                 }
     837             :         }
     838             : 
     839        8737 :         if (!test_bit(QUEUE_FLAG_POLL, &q->queue_flags))
     840        8737 :                 bio->bi_opf &= ~REQ_HIPRI;
     841             : 
     842        8737 :         switch (bio_op(bio)) {
     843           0 :         case REQ_OP_DISCARD:
     844           0 :                 if (!blk_queue_discard(q))
     845           0 :                         goto not_supported;
     846             :                 break;
     847           0 :         case REQ_OP_SECURE_ERASE:
     848           0 :                 if (!blk_queue_secure_erase(q))
     849           0 :                         goto not_supported;
     850             :                 break;
     851           0 :         case REQ_OP_WRITE_SAME:
     852           0 :                 if (!q->limits.max_write_same_sectors)
     853           0 :                         goto not_supported;
     854             :                 break;
     855             :         case REQ_OP_ZONE_APPEND:
     856           0 :                 status = blk_check_zone_append(q, bio);
     857           0 :                 if (status != BLK_STS_OK)
     858           0 :                         goto end_io;
     859             :                 break;
     860             :         case REQ_OP_ZONE_RESET:
     861             :         case REQ_OP_ZONE_OPEN:
     862             :         case REQ_OP_ZONE_CLOSE:
     863             :         case REQ_OP_ZONE_FINISH:
     864           0 :                 if (!blk_queue_is_zoned(q))
     865           0 :                         goto not_supported;
     866             :                 break;
     867             :         case REQ_OP_ZONE_RESET_ALL:
     868           0 :                 if (!blk_queue_is_zoned(q) || !blk_queue_zone_resetall(q))
     869           0 :                         goto not_supported;
     870             :                 break;
     871           0 :         case REQ_OP_WRITE_ZEROES:
     872           0 :                 if (!q->limits.max_write_zeroes_sectors)
     873           0 :                         goto not_supported;
     874             :                 break;
     875             :         default:
     876             :                 break;
     877             :         }
     878             : 
     879             :         /*
     880             :          * Various block parts want %current->io_context, so allocate it up
     881             :          * front rather than dealing with lots of pain to allocate it only
     882             :          * where needed. This may fail and the block layer knows how to live
     883             :          * with it.
     884             :          */
     885        8737 :         if (unlikely(!current->io_context))
     886         145 :                 create_task_io_context(current, GFP_ATOMIC, q->node);
     887             : 
     888        8737 :         if (blk_throtl_bio(bio)) {
     889             :                 blkcg_bio_issue_init(bio);
     890             :                 return false;
     891             :         }
     892             : 
     893        8737 :         blk_cgroup_bio_start(bio);
     894        8737 :         blkcg_bio_issue_init(bio);
     895             : 
     896        8737 :         if (!bio_flagged(bio, BIO_TRACE_COMPLETION)) {
     897        8737 :                 trace_block_bio_queue(bio);
     898             :                 /* Now that enqueuing has been traced, we need to trace
     899             :                  * completion as well.
     900             :                  */
     901        8735 :                 bio_set_flag(bio, BIO_TRACE_COMPLETION);
     902             :         }
     903             :         return true;
     904             : 
     905             : not_supported:
     906             :         status = BLK_STS_NOTSUPP;
     907           0 : end_io:
     908           0 :         bio->bi_status = status;
     909           0 :         bio_endio(bio);
     910           0 :         return false;
     911             : }
     912             : 
     913           0 : static blk_qc_t __submit_bio(struct bio *bio)
     914             : {
     915           0 :         struct gendisk *disk = bio->bi_bdev->bd_disk;
     916           0 :         blk_qc_t ret = BLK_QC_T_NONE;
     917             : 
     918           0 :         if (blk_crypto_bio_prep(&bio)) {
     919           0 :                 if (!disk->fops->submit_bio)
     920           0 :                         return blk_mq_submit_bio(bio);
     921           0 :                 ret = disk->fops->submit_bio(bio);
     922             :         }
     923           0 :         blk_queue_exit(disk->queue);
     924           0 :         return ret;
     925             : }
     926             : 
     927             : /*
     928             :  * The loop in this function may be a bit non-obvious, and so deserves some
     929             :  * explanation:
     930             :  *
     931             :  *  - Before entering the loop, bio->bi_next is NULL (as all callers ensure
     932             :  *    that), so we have a list with a single bio.
     933             :  *  - We pretend that we have just taken it off a longer list, so we assign
     934             :  *    bio_list to a pointer to the bio_list_on_stack, thus initialising the
     935             :  *    bio_list of new bios to be added.  ->submit_bio() may indeed add some more
     936             :  *    bios through a recursive call to submit_bio_noacct.  If it did, we find a
     937             :  *    non-NULL value in bio_list and re-enter the loop from the top.
     938             :  *  - In this case we really did just take the bio of the top of the list (no
     939             :  *    pretending) and so remove it from bio_list, and call into ->submit_bio()
     940             :  *    again.
     941             :  *
     942             :  * bio_list_on_stack[0] contains bios submitted by the current ->submit_bio.
     943             :  * bio_list_on_stack[1] contains bios that were submitted before the current
     944             :  *      ->submit_bio_bio, but that haven't been processed yet.
     945             :  */
     946           0 : static blk_qc_t __submit_bio_noacct(struct bio *bio)
     947             : {
     948           0 :         struct bio_list bio_list_on_stack[2];
     949           0 :         blk_qc_t ret = BLK_QC_T_NONE;
     950             : 
     951           0 :         BUG_ON(bio->bi_next);
     952             : 
     953           0 :         bio_list_init(&bio_list_on_stack[0]);
     954           0 :         current->bio_list = bio_list_on_stack;
     955             : 
     956           0 :         do {
     957           0 :                 struct request_queue *q = bio->bi_bdev->bd_disk->queue;
     958           0 :                 struct bio_list lower, same;
     959             : 
     960           0 :                 if (unlikely(bio_queue_enter(bio) != 0))
     961           0 :                         continue;
     962             : 
     963             :                 /*
     964             :                  * Create a fresh bio_list for all subordinate requests.
     965             :                  */
     966           0 :                 bio_list_on_stack[1] = bio_list_on_stack[0];
     967           0 :                 bio_list_init(&bio_list_on_stack[0]);
     968             : 
     969           0 :                 ret = __submit_bio(bio);
     970             : 
     971             :                 /*
     972             :                  * Sort new bios into those for a lower level and those for the
     973             :                  * same level.
     974             :                  */
     975           0 :                 bio_list_init(&lower);
     976           0 :                 bio_list_init(&same);
     977           0 :                 while ((bio = bio_list_pop(&bio_list_on_stack[0])) != NULL)
     978           0 :                         if (q == bio->bi_bdev->bd_disk->queue)
     979           0 :                                 bio_list_add(&same, bio);
     980             :                         else
     981           0 :                                 bio_list_add(&lower, bio);
     982             : 
     983             :                 /*
     984             :                  * Now assemble so we handle the lowest level first.
     985             :                  */
     986           0 :                 bio_list_merge(&bio_list_on_stack[0], &lower);
     987           0 :                 bio_list_merge(&bio_list_on_stack[0], &same);
     988           0 :                 bio_list_merge(&bio_list_on_stack[0], &bio_list_on_stack[1]);
     989           0 :         } while ((bio = bio_list_pop(&bio_list_on_stack[0])));
     990             : 
     991           0 :         current->bio_list = NULL;
     992           0 :         return ret;
     993             : }
     994             : 
     995        8736 : static blk_qc_t __submit_bio_noacct_mq(struct bio *bio)
     996             : {
     997        8736 :         struct bio_list bio_list[2] = { };
     998        8736 :         blk_qc_t ret = BLK_QC_T_NONE;
     999             : 
    1000        8736 :         current->bio_list = bio_list;
    1001             : 
    1002        8736 :         do {
    1003        8736 :                 struct gendisk *disk = bio->bi_bdev->bd_disk;
    1004             : 
    1005        8736 :                 if (unlikely(bio_queue_enter(bio) != 0))
    1006           0 :                         continue;
    1007             : 
    1008        8737 :                 if (!blk_crypto_bio_prep(&bio)) {
    1009             :                         blk_queue_exit(disk->queue);
    1010             :                         ret = BLK_QC_T_NONE;
    1011             :                         continue;
    1012             :                 }
    1013             : 
    1014        8737 :                 ret = blk_mq_submit_bio(bio);
    1015        8737 :         } while ((bio = bio_list_pop(&bio_list[0])));
    1016             : 
    1017        8737 :         current->bio_list = NULL;
    1018        8737 :         return ret;
    1019             : }
    1020             : 
    1021             : /**
    1022             :  * submit_bio_noacct - re-submit a bio to the block device layer for I/O
    1023             :  * @bio:  The bio describing the location in memory and on the device.
    1024             :  *
    1025             :  * This is a version of submit_bio() that shall only be used for I/O that is
    1026             :  * resubmitted to lower level drivers by stacking block drivers.  All file
    1027             :  * systems and other upper level users of the block layer should use
    1028             :  * submit_bio() instead.
    1029             :  */
    1030        8737 : blk_qc_t submit_bio_noacct(struct bio *bio)
    1031             : {
    1032        8737 :         if (!submit_bio_checks(bio))
    1033             :                 return BLK_QC_T_NONE;
    1034             : 
    1035             :         /*
    1036             :          * We only want one ->submit_bio to be active at a time, else stack
    1037             :          * usage with stacked devices could be a problem.  Use current->bio_list
    1038             :          * to collect a list of requests submited by a ->submit_bio method while
    1039             :          * it is active, and then process them after it returned.
    1040             :          */
    1041        8736 :         if (current->bio_list) {
    1042           0 :                 bio_list_add(&current->bio_list[0], bio);
    1043           0 :                 return BLK_QC_T_NONE;
    1044             :         }
    1045             : 
    1046        8736 :         if (!bio->bi_bdev->bd_disk->fops->submit_bio)
    1047        8736 :                 return __submit_bio_noacct_mq(bio);
    1048           0 :         return __submit_bio_noacct(bio);
    1049             : }
    1050             : EXPORT_SYMBOL(submit_bio_noacct);
    1051             : 
    1052             : /**
    1053             :  * submit_bio - submit a bio to the block device layer for I/O
    1054             :  * @bio: The &struct bio which describes the I/O
    1055             :  *
    1056             :  * submit_bio() is used to submit I/O requests to block devices.  It is passed a
    1057             :  * fully set up &struct bio that describes the I/O that needs to be done.  The
    1058             :  * bio will be send to the device described by the bi_bdev field.
    1059             :  *
    1060             :  * The success/failure status of the request, along with notification of
    1061             :  * completion, is delivered asynchronously through the ->bi_end_io() callback
    1062             :  * in @bio.  The bio must NOT be touched by thecaller until ->bi_end_io() has
    1063             :  * been called.
    1064             :  */
    1065        8737 : blk_qc_t submit_bio(struct bio *bio)
    1066             : {
    1067        8737 :         if (blkcg_punt_bio_submit(bio))
    1068             :                 return BLK_QC_T_NONE;
    1069             : 
    1070             :         /*
    1071             :          * If it's a regular read/write or a barrier with data attached,
    1072             :          * go through the normal accounting stuff before submission.
    1073             :          */
    1074        8737 :         if (bio_has_data(bio)) {
    1075        8665 :                 unsigned int count;
    1076             : 
    1077        8665 :                 if (unlikely(bio_op(bio) == REQ_OP_WRITE_SAME))
    1078           0 :                         count = queue_logical_block_size(
    1079           0 :                                         bio->bi_bdev->bd_disk->queue) >> 9;
    1080             :                 else
    1081        8665 :                         count = bio_sectors(bio);
    1082             : 
    1083        8665 :                 if (op_is_write(bio_op(bio))) {
    1084        3003 :                         count_vm_events(PGPGOUT, count);
    1085             :                 } else {
    1086        5662 :                         task_io_account_read(bio->bi_iter.bi_size);
    1087        5662 :                         count_vm_events(PGPGIN, count);
    1088             :                 }
    1089             : 
    1090        8665 :                 if (unlikely(block_dump)) {
    1091           0 :                         char b[BDEVNAME_SIZE];
    1092           0 :                         printk(KERN_DEBUG "%s(%d): %s block %Lu on %s (%u sectors)\n",
    1093           0 :                         current->comm, task_pid_nr(current),
    1094           0 :                                 op_is_write(bio_op(bio)) ? "WRITE" : "READ",
    1095           0 :                                 (unsigned long long)bio->bi_iter.bi_sector,
    1096             :                                 bio_devname(bio, b), count);
    1097             :                 }
    1098             :         }
    1099             : 
    1100             :         /*
    1101             :          * If we're reading data that is part of the userspace workingset, count
    1102             :          * submission time as memory stall.  When the device is congested, or
    1103             :          * the submitting cgroup IO-throttled, submission can be a significant
    1104             :          * part of overall IO time.
    1105             :          */
    1106        8737 :         if (unlikely(bio_op(bio) == REQ_OP_READ &&
    1107             :             bio_flagged(bio, BIO_WORKINGSET))) {
    1108           0 :                 unsigned long pflags;
    1109           0 :                 blk_qc_t ret;
    1110             : 
    1111           0 :                 psi_memstall_enter(&pflags);
    1112           0 :                 ret = submit_bio_noacct(bio);
    1113           0 :                 psi_memstall_leave(&pflags);
    1114             : 
    1115           0 :                 return ret;
    1116             :         }
    1117             : 
    1118        8737 :         return submit_bio_noacct(bio);
    1119             : }
    1120             : EXPORT_SYMBOL(submit_bio);
    1121             : 
    1122             : /**
    1123             :  * blk_cloned_rq_check_limits - Helper function to check a cloned request
    1124             :  *                              for the new queue limits
    1125             :  * @q:  the queue
    1126             :  * @rq: the request being checked
    1127             :  *
    1128             :  * Description:
    1129             :  *    @rq may have been made based on weaker limitations of upper-level queues
    1130             :  *    in request stacking drivers, and it may violate the limitation of @q.
    1131             :  *    Since the block layer and the underlying device driver trust @rq
    1132             :  *    after it is inserted to @q, it should be checked against @q before
    1133             :  *    the insertion using this generic function.
    1134             :  *
    1135             :  *    Request stacking drivers like request-based dm may change the queue
    1136             :  *    limits when retrying requests on other queues. Those requests need
    1137             :  *    to be checked against the new queue limits again during dispatch.
    1138             :  */
    1139           0 : static blk_status_t blk_cloned_rq_check_limits(struct request_queue *q,
    1140             :                                       struct request *rq)
    1141             : {
    1142           0 :         unsigned int max_sectors = blk_queue_get_max_sectors(q, req_op(rq));
    1143             : 
    1144           0 :         if (blk_rq_sectors(rq) > max_sectors) {
    1145             :                 /*
    1146             :                  * SCSI device does not have a good way to return if
    1147             :                  * Write Same/Zero is actually supported. If a device rejects
    1148             :                  * a non-read/write command (discard, write same,etc.) the
    1149             :                  * low-level device driver will set the relevant queue limit to
    1150             :                  * 0 to prevent blk-lib from issuing more of the offending
    1151             :                  * operations. Commands queued prior to the queue limit being
    1152             :                  * reset need to be completed with BLK_STS_NOTSUPP to avoid I/O
    1153             :                  * errors being propagated to upper layers.
    1154             :                  */
    1155           0 :                 if (max_sectors == 0)
    1156             :                         return BLK_STS_NOTSUPP;
    1157             : 
    1158           0 :                 printk(KERN_ERR "%s: over max size limit. (%u > %u)\n",
    1159             :                         __func__, blk_rq_sectors(rq), max_sectors);
    1160           0 :                 return BLK_STS_IOERR;
    1161             :         }
    1162             : 
    1163             :         /*
    1164             :          * queue's settings related to segment counting like q->bounce_pfn
    1165             :          * may differ from that of other stacking queues.
    1166             :          * Recalculate it to check the request correctly on this queue's
    1167             :          * limitation.
    1168             :          */
    1169           0 :         rq->nr_phys_segments = blk_recalc_rq_segments(rq);
    1170           0 :         if (rq->nr_phys_segments > queue_max_segments(q)) {
    1171           0 :                 printk(KERN_ERR "%s: over max segments limit. (%hu > %hu)\n",
    1172           0 :                         __func__, rq->nr_phys_segments, queue_max_segments(q));
    1173           0 :                 return BLK_STS_IOERR;
    1174             :         }
    1175             : 
    1176             :         return BLK_STS_OK;
    1177             : }
    1178             : 
    1179             : /**
    1180             :  * blk_insert_cloned_request - Helper for stacking drivers to submit a request
    1181             :  * @q:  the queue to submit the request
    1182             :  * @rq: the request being queued
    1183             :  */
    1184           0 : blk_status_t blk_insert_cloned_request(struct request_queue *q, struct request *rq)
    1185             : {
    1186           0 :         blk_status_t ret;
    1187             : 
    1188           0 :         ret = blk_cloned_rq_check_limits(q, rq);
    1189           0 :         if (ret != BLK_STS_OK)
    1190             :                 return ret;
    1191             : 
    1192           0 :         if (rq->rq_disk &&
    1193             :             should_fail_request(rq->rq_disk->part0, blk_rq_bytes(rq)))
    1194             :                 return BLK_STS_IOERR;
    1195             : 
    1196           0 :         if (blk_crypto_insert_cloned_request(rq))
    1197             :                 return BLK_STS_IOERR;
    1198             : 
    1199           0 :         if (blk_queue_io_stat(q))
    1200           0 :                 blk_account_io_start(rq);
    1201             : 
    1202             :         /*
    1203             :          * Since we have a scheduler attached on the top device,
    1204             :          * bypass a potential scheduler on the bottom device for
    1205             :          * insert.
    1206             :          */
    1207           0 :         return blk_mq_request_issue_directly(rq, true);
    1208             : }
    1209             : EXPORT_SYMBOL_GPL(blk_insert_cloned_request);
    1210             : 
    1211             : /**
    1212             :  * blk_rq_err_bytes - determine number of bytes till the next failure boundary
    1213             :  * @rq: request to examine
    1214             :  *
    1215             :  * Description:
    1216             :  *     A request could be merge of IOs which require different failure
    1217             :  *     handling.  This function determines the number of bytes which
    1218             :  *     can be failed from the beginning of the request without
    1219             :  *     crossing into area which need to be retried further.
    1220             :  *
    1221             :  * Return:
    1222             :  *     The number of bytes to fail.
    1223             :  */
    1224           0 : unsigned int blk_rq_err_bytes(const struct request *rq)
    1225             : {
    1226           0 :         unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK;
    1227           0 :         unsigned int bytes = 0;
    1228           0 :         struct bio *bio;
    1229             : 
    1230           0 :         if (!(rq->rq_flags & RQF_MIXED_MERGE))
    1231           0 :                 return blk_rq_bytes(rq);
    1232             : 
    1233             :         /*
    1234             :          * Currently the only 'mixing' which can happen is between
    1235             :          * different fastfail types.  We can safely fail portions
    1236             :          * which have all the failfast bits that the first one has -
    1237             :          * the ones which are at least as eager to fail as the first
    1238             :          * one.
    1239             :          */
    1240           0 :         for (bio = rq->bio; bio; bio = bio->bi_next) {
    1241           0 :                 if ((bio->bi_opf & ff) != ff)
    1242             :                         break;
    1243           0 :                 bytes += bio->bi_iter.bi_size;
    1244             :         }
    1245             : 
    1246             :         /* this could lead to infinite loop */
    1247           0 :         BUG_ON(blk_rq_bytes(rq) && !bytes);
    1248             :         return bytes;
    1249             : }
    1250             : EXPORT_SYMBOL_GPL(blk_rq_err_bytes);
    1251             : 
    1252        6507 : static void update_io_ticks(struct block_device *part, unsigned long now,
    1253             :                 bool end)
    1254             : {
    1255       12912 :         unsigned long stamp;
    1256       12912 : again:
    1257       12912 :         stamp = READ_ONCE(part->bd_stamp);
    1258       12912 :         if (unlikely(stamp != now)) {
    1259        2682 :                 if (likely(cmpxchg(&part->bd_stamp, stamp, now) == stamp))
    1260       12912 :                         __part_stat_add(part, io_ticks, end ? now - stamp : 1);
    1261             :         }
    1262       12912 :         if (part->bd_partno) {
    1263        6405 :                 part = bdev_whole(part);
    1264        6405 :                 goto again;
    1265             :         }
    1266        6507 : }
    1267             : 
    1268        3314 : static void blk_account_io_completion(struct request *req, unsigned int bytes)
    1269             : {
    1270        6628 :         if (req->part && blk_do_io_stat(req)) {
    1271        3314 :                 const int sgrp = op_stat_group(req_op(req));
    1272             : 
    1273        3314 :                 part_stat_lock();
    1274        3314 :                 part_stat_add(req->part, sectors[sgrp], bytes >> 9);
    1275        3314 :                 part_stat_unlock();
    1276             :         }
    1277        3314 : }
    1278             : 
    1279        3505 : void blk_account_io_done(struct request *req, u64 now)
    1280             : {
    1281             :         /*
    1282             :          * Account IO completion.  flush_rq isn't accounted as a
    1283             :          * normal IO on queueing nor completion.  Accounting the
    1284             :          * containing request is enough.
    1285             :          */
    1286        6819 :         if (req->part && blk_do_io_stat(req) &&
    1287        3314 :             !(req->rq_flags & RQF_FLUSH_SEQ)) {
    1288        3254 :                 const int sgrp = op_stat_group(req_op(req));
    1289             : 
    1290        3254 :                 part_stat_lock();
    1291        3254 :                 update_io_ticks(req->part, jiffies, true);
    1292        3254 :                 part_stat_inc(req->part, ios[sgrp]);
    1293        3254 :                 part_stat_add(req->part, nsecs[sgrp], now - req->start_time_ns);
    1294        3254 :                 part_stat_unlock();
    1295             :         }
    1296        3505 : }
    1297             : 
    1298        3253 : void blk_account_io_start(struct request *rq)
    1299             : {
    1300        6506 :         if (!blk_do_io_stat(rq))
    1301             :                 return;
    1302             : 
    1303             :         /* passthrough requests can hold bios that do not have ->bi_bdev set */
    1304        3253 :         if (rq->bio && rq->bio->bi_bdev)
    1305        3251 :                 rq->part = rq->bio->bi_bdev;
    1306             :         else
    1307           2 :                 rq->part = rq->rq_disk->part0;
    1308             : 
    1309        3253 :         part_stat_lock();
    1310        3253 :         update_io_ticks(rq->part, jiffies, false);
    1311        3254 :         part_stat_unlock();
    1312             : }
    1313             : 
    1314           0 : static unsigned long __part_start_io_acct(struct block_device *part,
    1315             :                                           unsigned int sectors, unsigned int op)
    1316             : {
    1317           0 :         const int sgrp = op_stat_group(op);
    1318           0 :         unsigned long now = READ_ONCE(jiffies);
    1319             : 
    1320           0 :         part_stat_lock();
    1321           0 :         update_io_ticks(part, now, false);
    1322           0 :         part_stat_inc(part, ios[sgrp]);
    1323           0 :         part_stat_add(part, sectors[sgrp], sectors);
    1324           0 :         part_stat_local_inc(part, in_flight[op_is_write(op)]);
    1325           0 :         part_stat_unlock();
    1326             : 
    1327           0 :         return now;
    1328             : }
    1329             : 
    1330             : /**
    1331             :  * bio_start_io_acct - start I/O accounting for bio based drivers
    1332             :  * @bio:        bio to start account for
    1333             :  *
    1334             :  * Returns the start time that should be passed back to bio_end_io_acct().
    1335             :  */
    1336           0 : unsigned long bio_start_io_acct(struct bio *bio)
    1337             : {
    1338           0 :         return __part_start_io_acct(bio->bi_bdev, bio_sectors(bio), bio_op(bio));
    1339             : }
    1340             : EXPORT_SYMBOL_GPL(bio_start_io_acct);
    1341             : 
    1342           0 : unsigned long disk_start_io_acct(struct gendisk *disk, unsigned int sectors,
    1343             :                                  unsigned int op)
    1344             : {
    1345           0 :         return __part_start_io_acct(disk->part0, sectors, op);
    1346             : }
    1347             : EXPORT_SYMBOL(disk_start_io_acct);
    1348             : 
    1349           0 : static void __part_end_io_acct(struct block_device *part, unsigned int op,
    1350             :                                unsigned long start_time)
    1351             : {
    1352           0 :         const int sgrp = op_stat_group(op);
    1353           0 :         unsigned long now = READ_ONCE(jiffies);
    1354           0 :         unsigned long duration = now - start_time;
    1355             : 
    1356           0 :         part_stat_lock();
    1357           0 :         update_io_ticks(part, now, true);
    1358           0 :         part_stat_add(part, nsecs[sgrp], jiffies_to_nsecs(duration));
    1359           0 :         part_stat_local_dec(part, in_flight[op_is_write(op)]);
    1360           0 :         part_stat_unlock();
    1361           0 : }
    1362             : 
    1363           0 : void bio_end_io_acct_remapped(struct bio *bio, unsigned long start_time,
    1364             :                 struct block_device *orig_bdev)
    1365             : {
    1366           0 :         __part_end_io_acct(orig_bdev, bio_op(bio), start_time);
    1367           0 : }
    1368             : EXPORT_SYMBOL_GPL(bio_end_io_acct_remapped);
    1369             : 
    1370           0 : void disk_end_io_acct(struct gendisk *disk, unsigned int op,
    1371             :                       unsigned long start_time)
    1372             : {
    1373           0 :         __part_end_io_acct(disk->part0, op, start_time);
    1374           0 : }
    1375             : EXPORT_SYMBOL(disk_end_io_acct);
    1376             : 
    1377             : /*
    1378             :  * Steal bios from a request and add them to a bio list.
    1379             :  * The request must not have been partially completed before.
    1380             :  */
    1381           0 : void blk_steal_bios(struct bio_list *list, struct request *rq)
    1382             : {
    1383           0 :         if (rq->bio) {
    1384           0 :                 if (list->tail)
    1385           0 :                         list->tail->bi_next = rq->bio;
    1386             :                 else
    1387           0 :                         list->head = rq->bio;
    1388           0 :                 list->tail = rq->biotail;
    1389             : 
    1390           0 :                 rq->bio = NULL;
    1391           0 :                 rq->biotail = NULL;
    1392             :         }
    1393             : 
    1394           0 :         rq->__data_len = 0;
    1395           0 : }
    1396             : EXPORT_SYMBOL_GPL(blk_steal_bios);
    1397             : 
    1398             : /**
    1399             :  * blk_update_request - Special helper function for request stacking drivers
    1400             :  * @req:      the request being processed
    1401             :  * @error:    block status code
    1402             :  * @nr_bytes: number of bytes to complete @req
    1403             :  *
    1404             :  * Description:
    1405             :  *     Ends I/O on a number of bytes attached to @req, but doesn't complete
    1406             :  *     the request structure even if @req doesn't have leftover.
    1407             :  *     If @req has leftover, sets it up for the next range of segments.
    1408             :  *
    1409             :  *     This special helper function is only for request stacking drivers
    1410             :  *     (e.g. request-based dm) so that they can handle partial completion.
    1411             :  *     Actual device drivers should use blk_mq_end_request instead.
    1412             :  *
    1413             :  *     Passing the result of blk_rq_bytes() as @nr_bytes guarantees
    1414             :  *     %false return from this function.
    1415             :  *
    1416             :  * Note:
    1417             :  *      The RQF_SPECIAL_PAYLOAD flag is ignored on purpose in both
    1418             :  *      blk_rq_bytes() and in blk_update_request().
    1419             :  *
    1420             :  * Return:
    1421             :  *     %false - this request doesn't have any more data
    1422             :  *     %true  - this request has more data
    1423             :  **/
    1424        3504 : bool blk_update_request(struct request *req, blk_status_t error,
    1425             :                 unsigned int nr_bytes)
    1426             : {
    1427        3504 :         int total_bytes;
    1428             : 
    1429        3504 :         trace_block_rq_complete(req, blk_status_to_errno(error), nr_bytes);
    1430             : 
    1431        3505 :         if (!req->bio)
    1432             :                 return false;
    1433             : 
    1434             : #ifdef CONFIG_BLK_DEV_INTEGRITY
    1435             :         if (blk_integrity_rq(req) && req_op(req) == REQ_OP_READ &&
    1436             :             error == BLK_STS_OK)
    1437             :                 req->q->integrity.profile->complete_fn(req, nr_bytes);
    1438             : #endif
    1439             : 
    1440        3314 :         if (unlikely(error && !blk_rq_is_passthrough(req) &&
    1441             :                      !(req->rq_flags & RQF_QUIET)))
    1442           0 :                 print_req_error(req, error, __func__);
    1443             : 
    1444        3314 :         blk_account_io_completion(req, nr_bytes);
    1445             : 
    1446        3314 :         total_bytes = 0;
    1447        8799 :         while (req->bio) {
    1448        8799 :                 struct bio *bio = req->bio;
    1449        8799 :                 unsigned bio_bytes = min(bio->bi_iter.bi_size, nr_bytes);
    1450             : 
    1451        8799 :                 if (bio_bytes == bio->bi_iter.bi_size)
    1452        8799 :                         req->bio = bio->bi_next;
    1453             : 
    1454             :                 /* Completion has already been traced */
    1455        8799 :                 bio_clear_flag(bio, BIO_TRACE_COMPLETION);
    1456        8799 :                 req_bio_endio(req, bio, bio_bytes, error);
    1457             : 
    1458        8799 :                 total_bytes += bio_bytes;
    1459        8799 :                 nr_bytes -= bio_bytes;
    1460             : 
    1461        8799 :                 if (!nr_bytes)
    1462             :                         break;
    1463             :         }
    1464             : 
    1465             :         /*
    1466             :          * completely done
    1467             :          */
    1468        3314 :         if (!req->bio) {
    1469             :                 /*
    1470             :                  * Reset counters so that the request stacking driver
    1471             :                  * can find how many bytes remain in the request
    1472             :                  * later.
    1473             :                  */
    1474        3314 :                 req->__data_len = 0;
    1475        3314 :                 return false;
    1476             :         }
    1477             : 
    1478           0 :         req->__data_len -= total_bytes;
    1479             : 
    1480             :         /* update sector only for requests with clear definition of sector */
    1481           0 :         if (!blk_rq_is_passthrough(req))
    1482           0 :                 req->__sector += total_bytes >> 9;
    1483             : 
    1484             :         /* mixed attributes always follow the first bio */
    1485           0 :         if (req->rq_flags & RQF_MIXED_MERGE) {
    1486           0 :                 req->cmd_flags &= ~REQ_FAILFAST_MASK;
    1487           0 :                 req->cmd_flags |= req->bio->bi_opf & REQ_FAILFAST_MASK;
    1488             :         }
    1489             : 
    1490           0 :         if (!(req->rq_flags & RQF_SPECIAL_PAYLOAD)) {
    1491             :                 /*
    1492             :                  * If total number of sectors is less than the first segment
    1493             :                  * size, something has gone terribly wrong.
    1494             :                  */
    1495           0 :                 if (blk_rq_bytes(req) < blk_rq_cur_bytes(req)) {
    1496           0 :                         blk_dump_rq_flags(req, "request botched");
    1497           0 :                         req->__data_len = blk_rq_cur_bytes(req);
    1498             :                 }
    1499             : 
    1500             :                 /* recalculate the number of segments */
    1501           0 :                 req->nr_phys_segments = blk_recalc_rq_segments(req);
    1502             :         }
    1503             : 
    1504             :         return true;
    1505             : }
    1506             : EXPORT_SYMBOL_GPL(blk_update_request);
    1507             : 
    1508             : #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
    1509             : /**
    1510             :  * rq_flush_dcache_pages - Helper function to flush all pages in a request
    1511             :  * @rq: the request to be flushed
    1512             :  *
    1513             :  * Description:
    1514             :  *     Flush all pages in @rq.
    1515             :  */
    1516             : void rq_flush_dcache_pages(struct request *rq)
    1517             : {
    1518             :         struct req_iterator iter;
    1519             :         struct bio_vec bvec;
    1520             : 
    1521             :         rq_for_each_segment(bvec, rq, iter)
    1522             :                 flush_dcache_page(bvec.bv_page);
    1523             : }
    1524             : EXPORT_SYMBOL_GPL(rq_flush_dcache_pages);
    1525             : #endif
    1526             : 
    1527             : /**
    1528             :  * blk_lld_busy - Check if underlying low-level drivers of a device are busy
    1529             :  * @q : the queue of the device being checked
    1530             :  *
    1531             :  * Description:
    1532             :  *    Check if underlying low-level drivers of a device are busy.
    1533             :  *    If the drivers want to export their busy state, they must set own
    1534             :  *    exporting function using blk_queue_lld_busy() first.
    1535             :  *
    1536             :  *    Basically, this function is used only by request stacking drivers
    1537             :  *    to stop dispatching requests to underlying devices when underlying
    1538             :  *    devices are busy.  This behavior helps more I/O merging on the queue
    1539             :  *    of the request stacking driver and prevents I/O throughput regression
    1540             :  *    on burst I/O load.
    1541             :  *
    1542             :  * Return:
    1543             :  *    0 - Not busy (The request stacking driver should dispatch request)
    1544             :  *    1 - Busy (The request stacking driver should stop dispatching request)
    1545             :  */
    1546           0 : int blk_lld_busy(struct request_queue *q)
    1547             : {
    1548           0 :         if (queue_is_mq(q) && q->mq_ops->busy)
    1549           0 :                 return q->mq_ops->busy(q);
    1550             : 
    1551             :         return 0;
    1552             : }
    1553             : EXPORT_SYMBOL_GPL(blk_lld_busy);
    1554             : 
    1555             : /**
    1556             :  * blk_rq_unprep_clone - Helper function to free all bios in a cloned request
    1557             :  * @rq: the clone request to be cleaned up
    1558             :  *
    1559             :  * Description:
    1560             :  *     Free all bios in @rq for a cloned request.
    1561             :  */
    1562           0 : void blk_rq_unprep_clone(struct request *rq)
    1563             : {
    1564           0 :         struct bio *bio;
    1565             : 
    1566           0 :         while ((bio = rq->bio) != NULL) {
    1567           0 :                 rq->bio = bio->bi_next;
    1568             : 
    1569           0 :                 bio_put(bio);
    1570             :         }
    1571           0 : }
    1572             : EXPORT_SYMBOL_GPL(blk_rq_unprep_clone);
    1573             : 
    1574             : /**
    1575             :  * blk_rq_prep_clone - Helper function to setup clone request
    1576             :  * @rq: the request to be setup
    1577             :  * @rq_src: original request to be cloned
    1578             :  * @bs: bio_set that bios for clone are allocated from
    1579             :  * @gfp_mask: memory allocation mask for bio
    1580             :  * @bio_ctr: setup function to be called for each clone bio.
    1581             :  *           Returns %0 for success, non %0 for failure.
    1582             :  * @data: private data to be passed to @bio_ctr
    1583             :  *
    1584             :  * Description:
    1585             :  *     Clones bios in @rq_src to @rq, and copies attributes of @rq_src to @rq.
    1586             :  *     Also, pages which the original bios are pointing to are not copied
    1587             :  *     and the cloned bios just point same pages.
    1588             :  *     So cloned bios must be completed before original bios, which means
    1589             :  *     the caller must complete @rq before @rq_src.
    1590             :  */
    1591           0 : int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
    1592             :                       struct bio_set *bs, gfp_t gfp_mask,
    1593             :                       int (*bio_ctr)(struct bio *, struct bio *, void *),
    1594             :                       void *data)
    1595             : {
    1596           0 :         struct bio *bio, *bio_src;
    1597             : 
    1598           0 :         if (!bs)
    1599           0 :                 bs = &fs_bio_set;
    1600             : 
    1601           0 :         __rq_for_each_bio(bio_src, rq_src) {
    1602           0 :                 bio = bio_clone_fast(bio_src, gfp_mask, bs);
    1603           0 :                 if (!bio)
    1604           0 :                         goto free_and_out;
    1605             : 
    1606           0 :                 if (bio_ctr && bio_ctr(bio, bio_src, data))
    1607           0 :                         goto free_and_out;
    1608             : 
    1609           0 :                 if (rq->bio) {
    1610           0 :                         rq->biotail->bi_next = bio;
    1611           0 :                         rq->biotail = bio;
    1612             :                 } else {
    1613           0 :                         rq->bio = rq->biotail = bio;
    1614             :                 }
    1615           0 :                 bio = NULL;
    1616             :         }
    1617             : 
    1618             :         /* Copy attributes of the original request to the clone request. */
    1619           0 :         rq->__sector = blk_rq_pos(rq_src);
    1620           0 :         rq->__data_len = blk_rq_bytes(rq_src);
    1621           0 :         if (rq_src->rq_flags & RQF_SPECIAL_PAYLOAD) {
    1622           0 :                 rq->rq_flags |= RQF_SPECIAL_PAYLOAD;
    1623           0 :                 rq->special_vec = rq_src->special_vec;
    1624             :         }
    1625           0 :         rq->nr_phys_segments = rq_src->nr_phys_segments;
    1626           0 :         rq->ioprio = rq_src->ioprio;
    1627             : 
    1628           0 :         if (rq->bio && blk_crypto_rq_bio_prep(rq, rq->bio, gfp_mask) < 0)
    1629             :                 goto free_and_out;
    1630             : 
    1631           0 :         return 0;
    1632             : 
    1633           0 : free_and_out:
    1634           0 :         if (bio)
    1635           0 :                 bio_put(bio);
    1636           0 :         blk_rq_unprep_clone(rq);
    1637             : 
    1638           0 :         return -ENOMEM;
    1639             : }
    1640             : EXPORT_SYMBOL_GPL(blk_rq_prep_clone);
    1641             : 
    1642           8 : int kblockd_schedule_work(struct work_struct *work)
    1643             : {
    1644           8 :         return queue_work(kblockd_workqueue, work);
    1645             : }
    1646             : EXPORT_SYMBOL(kblockd_schedule_work);
    1647             : 
    1648         265 : int kblockd_mod_delayed_work_on(int cpu, struct delayed_work *dwork,
    1649             :                                 unsigned long delay)
    1650             : {
    1651         265 :         return mod_delayed_work_on(cpu, kblockd_workqueue, dwork, delay);
    1652             : }
    1653             : EXPORT_SYMBOL(kblockd_mod_delayed_work_on);
    1654             : 
    1655             : /**
    1656             :  * blk_start_plug - initialize blk_plug and track it inside the task_struct
    1657             :  * @plug:       The &struct blk_plug that needs to be initialized
    1658             :  *
    1659             :  * Description:
    1660             :  *   blk_start_plug() indicates to the block layer an intent by the caller
    1661             :  *   to submit multiple I/O requests in a batch.  The block layer may use
    1662             :  *   this hint to defer submitting I/Os from the caller until blk_finish_plug()
    1663             :  *   is called.  However, the block layer may choose to submit requests
    1664             :  *   before a call to blk_finish_plug() if the number of queued I/Os
    1665             :  *   exceeds %BLK_MAX_REQUEST_COUNT, or if the size of the I/O is larger than
    1666             :  *   %BLK_PLUG_FLUSH_SIZE.  The queued I/Os may also be submitted early if
    1667             :  *   the task schedules (see below).
    1668             :  *
    1669             :  *   Tracking blk_plug inside the task_struct will help with auto-flushing the
    1670             :  *   pending I/O should the task end up blocking between blk_start_plug() and
    1671             :  *   blk_finish_plug(). This is important from a performance perspective, but
    1672             :  *   also ensures that we don't deadlock. For instance, if the task is blocking
    1673             :  *   for a memory allocation, memory reclaim could end up wanting to free a
    1674             :  *   page belonging to that request that is currently residing in our private
    1675             :  *   plug. By flushing the pending I/O when the process goes to sleep, we avoid
    1676             :  *   this kind of deadlock.
    1677             :  */
    1678        2114 : void blk_start_plug(struct blk_plug *plug)
    1679             : {
    1680        2114 :         struct task_struct *tsk = current;
    1681             : 
    1682             :         /*
    1683             :          * If this is a nested plug, don't actually assign it.
    1684             :          */
    1685        2114 :         if (tsk->plug)
    1686             :                 return;
    1687             : 
    1688        2028 :         INIT_LIST_HEAD(&plug->mq_list);
    1689        2028 :         INIT_LIST_HEAD(&plug->cb_list);
    1690        2028 :         plug->rq_count = 0;
    1691        2028 :         plug->multiple_queues = false;
    1692        2028 :         plug->nowait = false;
    1693             : 
    1694             :         /*
    1695             :          * Store ordering should not be needed here, since a potential
    1696             :          * preempt will imply a full memory barrier
    1697             :          */
    1698        2028 :         tsk->plug = plug;
    1699             : }
    1700             : EXPORT_SYMBOL(blk_start_plug);
    1701             : 
    1702        2072 : static void flush_plug_callbacks(struct blk_plug *plug, bool from_schedule)
    1703             : {
    1704        2072 :         LIST_HEAD(callbacks);
    1705             : 
    1706        2072 :         while (!list_empty(&plug->cb_list)) {
    1707           0 :                 list_splice_init(&plug->cb_list, &callbacks);
    1708             : 
    1709           0 :                 while (!list_empty(&callbacks)) {
    1710           0 :                         struct blk_plug_cb *cb = list_first_entry(&callbacks,
    1711             :                                                           struct blk_plug_cb,
    1712             :                                                           list);
    1713           0 :                         list_del(&cb->list);
    1714           0 :                         cb->callback(cb, from_schedule);
    1715             :                 }
    1716             :         }
    1717        2072 : }
    1718             : 
    1719           0 : struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug, void *data,
    1720             :                                       int size)
    1721             : {
    1722           0 :         struct blk_plug *plug = current->plug;
    1723           0 :         struct blk_plug_cb *cb;
    1724             : 
    1725           0 :         if (!plug)
    1726             :                 return NULL;
    1727             : 
    1728           0 :         list_for_each_entry(cb, &plug->cb_list, list)
    1729           0 :                 if (cb->callback == unplug && cb->data == data)
    1730           0 :                         return cb;
    1731             : 
    1732             :         /* Not currently on the callback list */
    1733           0 :         BUG_ON(size < sizeof(*cb));
    1734           0 :         cb = kzalloc(size, GFP_ATOMIC);
    1735           0 :         if (cb) {
    1736           0 :                 cb->data = data;
    1737           0 :                 cb->callback = unplug;
    1738           0 :                 list_add(&cb->list, &plug->cb_list);
    1739             :         }
    1740             :         return cb;
    1741             : }
    1742             : EXPORT_SYMBOL(blk_check_plugged);
    1743             : 
    1744        2072 : void blk_flush_plug_list(struct blk_plug *plug, bool from_schedule)
    1745             : {
    1746        2072 :         flush_plug_callbacks(plug, from_schedule);
    1747             : 
    1748        2072 :         if (!list_empty(&plug->mq_list))
    1749        1880 :                 blk_mq_flush_plug_list(plug, from_schedule);
    1750        2072 : }
    1751             : 
    1752             : /**
    1753             :  * blk_finish_plug - mark the end of a batch of submitted I/O
    1754             :  * @plug:       The &struct blk_plug passed to blk_start_plug()
    1755             :  *
    1756             :  * Description:
    1757             :  * Indicate that a batch of I/O submissions is complete.  This function
    1758             :  * must be paired with an initial call to blk_start_plug().  The intent
    1759             :  * is to allow the block layer to optimize I/O submission.  See the
    1760             :  * documentation for blk_start_plug() for more information.
    1761             :  */
    1762        2114 : void blk_finish_plug(struct blk_plug *plug)
    1763             : {
    1764        2114 :         if (plug != current->plug)
    1765             :                 return;
    1766        2028 :         blk_flush_plug_list(plug, false);
    1767             : 
    1768        2028 :         current->plug = NULL;
    1769             : }
    1770             : EXPORT_SYMBOL(blk_finish_plug);
    1771             : 
    1772           0 : void blk_io_schedule(void)
    1773             : {
    1774             :         /* Prevent hang_check timer from firing at us during very long I/O */
    1775           0 :         unsigned long timeout = sysctl_hung_task_timeout_secs * HZ / 2;
    1776             : 
    1777           0 :         if (timeout)
    1778             :                 io_schedule_timeout(timeout);
    1779             :         else
    1780           0 :                 io_schedule();
    1781           0 : }
    1782             : EXPORT_SYMBOL_GPL(blk_io_schedule);
    1783             : 
    1784           1 : int __init blk_dev_init(void)
    1785             : {
    1786           1 :         BUILD_BUG_ON(REQ_OP_LAST >= (1 << REQ_OP_BITS));
    1787           1 :         BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 *
    1788             :                         sizeof_field(struct request, cmd_flags));
    1789           1 :         BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 *
    1790             :                         sizeof_field(struct bio, bi_opf));
    1791             : 
    1792             :         /* used for unplugging and affects IO latency/throughput - HIGHPRI */
    1793           1 :         kblockd_workqueue = alloc_workqueue("kblockd",
    1794             :                                             WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
    1795           1 :         if (!kblockd_workqueue)
    1796           0 :                 panic("Failed to create kblockd\n");
    1797             : 
    1798           1 :         blk_requestq_cachep = kmem_cache_create("request_queue",
    1799             :                         sizeof(struct request_queue), 0, SLAB_PANIC, NULL);
    1800             : 
    1801           1 :         blk_debugfs_root = debugfs_create_dir("block", NULL);
    1802             : 
    1803           1 :         return 0;
    1804             : }

Generated by: LCOV version 1.14