SCSI: fix queue cleanup race before queue initialization is done
[sfrench/cifs-2.6.git] / block / blk-core.c
1 /*
2  * Copyright (C) 1991, 1992 Linus Torvalds
3  * Copyright (C) 1994,      Karl Keyte: Added support for disk statistics
4  * Elevator latency, (C) 2000  Andrea Arcangeli <andrea@suse.de> SuSE
5  * Queue request tables / lock, selectable elevator, Jens Axboe <axboe@suse.de>
6  * kernel-doc documentation started by NeilBrown <neilb@cse.unsw.edu.au>
7  *      -  July2000
8  * bio rewrite, highmem i/o, etc, Jens Axboe <axboe@suse.de> - may 2001
9  */
10
11 /*
12  * This handles all read/write requests to block devices
13  */
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/backing-dev.h>
17 #include <linux/bio.h>
18 #include <linux/blkdev.h>
19 #include <linux/blk-mq.h>
20 #include <linux/highmem.h>
21 #include <linux/mm.h>
22 #include <linux/kernel_stat.h>
23 #include <linux/string.h>
24 #include <linux/init.h>
25 #include <linux/completion.h>
26 #include <linux/slab.h>
27 #include <linux/swap.h>
28 #include <linux/writeback.h>
29 #include <linux/task_io_accounting_ops.h>
30 #include <linux/fault-inject.h>
31 #include <linux/list_sort.h>
32 #include <linux/delay.h>
33 #include <linux/ratelimit.h>
34 #include <linux/pm_runtime.h>
35 #include <linux/blk-cgroup.h>
36 #include <linux/debugfs.h>
37 #include <linux/bpf.h>
38
39 #define CREATE_TRACE_POINTS
40 #include <trace/events/block.h>
41
42 #include "blk.h"
43 #include "blk-mq.h"
44 #include "blk-mq-sched.h"
45 #include "blk-pm.h"
46 #include "blk-rq-qos.h"
47
48 #ifdef CONFIG_DEBUG_FS
49 struct dentry *blk_debugfs_root;
50 #endif
51
52 EXPORT_TRACEPOINT_SYMBOL_GPL(block_bio_remap);
53 EXPORT_TRACEPOINT_SYMBOL_GPL(block_rq_remap);
54 EXPORT_TRACEPOINT_SYMBOL_GPL(block_bio_complete);
55 EXPORT_TRACEPOINT_SYMBOL_GPL(block_split);
56 EXPORT_TRACEPOINT_SYMBOL_GPL(block_unplug);
57
58 DEFINE_IDA(blk_queue_ida);
59
60 /*
61  * For the allocated request tables
62  */
63 struct kmem_cache *request_cachep;
64
65 /*
66  * For queue allocation
67  */
68 struct kmem_cache *blk_requestq_cachep;
69
70 /*
71  * Controlling structure to kblockd
72  */
73 static struct workqueue_struct *kblockd_workqueue;
74
75 /**
76  * blk_queue_flag_set - atomically set a queue flag
77  * @flag: flag to be set
78  * @q: request queue
79  */
80 void blk_queue_flag_set(unsigned int flag, struct request_queue *q)
81 {
82         unsigned long flags;
83
84         spin_lock_irqsave(q->queue_lock, flags);
85         queue_flag_set(flag, q);
86         spin_unlock_irqrestore(q->queue_lock, flags);
87 }
88 EXPORT_SYMBOL(blk_queue_flag_set);
89
90 /**
91  * blk_queue_flag_clear - atomically clear a queue flag
92  * @flag: flag to be cleared
93  * @q: request queue
94  */
95 void blk_queue_flag_clear(unsigned int flag, struct request_queue *q)
96 {
97         unsigned long flags;
98
99         spin_lock_irqsave(q->queue_lock, flags);
100         queue_flag_clear(flag, q);
101         spin_unlock_irqrestore(q->queue_lock, flags);
102 }
103 EXPORT_SYMBOL(blk_queue_flag_clear);
104
105 /**
106  * blk_queue_flag_test_and_set - atomically test and set a queue flag
107  * @flag: flag to be set
108  * @q: request queue
109  *
110  * Returns the previous value of @flag - 0 if the flag was not set and 1 if
111  * the flag was already set.
112  */
113 bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q)
114 {
115         unsigned long flags;
116         bool res;
117
118         spin_lock_irqsave(q->queue_lock, flags);
119         res = queue_flag_test_and_set(flag, q);
120         spin_unlock_irqrestore(q->queue_lock, flags);
121
122         return res;
123 }
124 EXPORT_SYMBOL_GPL(blk_queue_flag_test_and_set);
125
126 /**
127  * blk_queue_flag_test_and_clear - atomically test and clear a queue flag
128  * @flag: flag to be cleared
129  * @q: request queue
130  *
131  * Returns the previous value of @flag - 0 if the flag was not set and 1 if
132  * the flag was set.
133  */
134 bool blk_queue_flag_test_and_clear(unsigned int flag, struct request_queue *q)
135 {
136         unsigned long flags;
137         bool res;
138
139         spin_lock_irqsave(q->queue_lock, flags);
140         res = queue_flag_test_and_clear(flag, q);
141         spin_unlock_irqrestore(q->queue_lock, flags);
142
143         return res;
144 }
145 EXPORT_SYMBOL_GPL(blk_queue_flag_test_and_clear);
146
147 static void blk_clear_congested(struct request_list *rl, int sync)
148 {
149 #ifdef CONFIG_CGROUP_WRITEBACK
150         clear_wb_congested(rl->blkg->wb_congested, sync);
151 #else
152         /*
153          * If !CGROUP_WRITEBACK, all blkg's map to bdi->wb and we shouldn't
154          * flip its congestion state for events on other blkcgs.
155          */
156         if (rl == &rl->q->root_rl)
157                 clear_wb_congested(rl->q->backing_dev_info->wb.congested, sync);
158 #endif
159 }
160
161 static void blk_set_congested(struct request_list *rl, int sync)
162 {
163 #ifdef CONFIG_CGROUP_WRITEBACK
164         set_wb_congested(rl->blkg->wb_congested, sync);
165 #else
166         /* see blk_clear_congested() */
167         if (rl == &rl->q->root_rl)
168                 set_wb_congested(rl->q->backing_dev_info->wb.congested, sync);
169 #endif
170 }
171
172 void blk_queue_congestion_threshold(struct request_queue *q)
173 {
174         int nr;
175
176         nr = q->nr_requests - (q->nr_requests / 8) + 1;
177         if (nr > q->nr_requests)
178                 nr = q->nr_requests;
179         q->nr_congestion_on = nr;
180
181         nr = q->nr_requests - (q->nr_requests / 8) - (q->nr_requests / 16) - 1;
182         if (nr < 1)
183                 nr = 1;
184         q->nr_congestion_off = nr;
185 }
186
187 void blk_rq_init(struct request_queue *q, struct request *rq)
188 {
189         memset(rq, 0, sizeof(*rq));
190
191         INIT_LIST_HEAD(&rq->queuelist);
192         INIT_LIST_HEAD(&rq->timeout_list);
193         rq->cpu = -1;
194         rq->q = q;
195         rq->__sector = (sector_t) -1;
196         INIT_HLIST_NODE(&rq->hash);
197         RB_CLEAR_NODE(&rq->rb_node);
198         rq->tag = -1;
199         rq->internal_tag = -1;
200         rq->start_time_ns = ktime_get_ns();
201         rq->part = NULL;
202 }
203 EXPORT_SYMBOL(blk_rq_init);
204
205 static const struct {
206         int             errno;
207         const char      *name;
208 } blk_errors[] = {
209         [BLK_STS_OK]            = { 0,          "" },
210         [BLK_STS_NOTSUPP]       = { -EOPNOTSUPP, "operation not supported" },
211         [BLK_STS_TIMEOUT]       = { -ETIMEDOUT, "timeout" },
212         [BLK_STS_NOSPC]         = { -ENOSPC,    "critical space allocation" },
213         [BLK_STS_TRANSPORT]     = { -ENOLINK,   "recoverable transport" },
214         [BLK_STS_TARGET]        = { -EREMOTEIO, "critical target" },
215         [BLK_STS_NEXUS]         = { -EBADE,     "critical nexus" },
216         [BLK_STS_MEDIUM]        = { -ENODATA,   "critical medium" },
217         [BLK_STS_PROTECTION]    = { -EILSEQ,    "protection" },
218         [BLK_STS_RESOURCE]      = { -ENOMEM,    "kernel resource" },
219         [BLK_STS_DEV_RESOURCE]  = { -EBUSY,     "device resource" },
220         [BLK_STS_AGAIN]         = { -EAGAIN,    "nonblocking retry" },
221
222         /* device mapper special case, should not leak out: */
223         [BLK_STS_DM_REQUEUE]    = { -EREMCHG, "dm internal retry" },
224
225         /* everything else not covered above: */
226         [BLK_STS_IOERR]         = { -EIO,       "I/O" },
227 };
228
229 blk_status_t errno_to_blk_status(int errno)
230 {
231         int i;
232
233         for (i = 0; i < ARRAY_SIZE(blk_errors); i++) {
234                 if (blk_errors[i].errno == errno)
235                         return (__force blk_status_t)i;
236         }
237
238         return BLK_STS_IOERR;
239 }
240 EXPORT_SYMBOL_GPL(errno_to_blk_status);
241
242 int blk_status_to_errno(blk_status_t status)
243 {
244         int idx = (__force int)status;
245
246         if (WARN_ON_ONCE(idx >= ARRAY_SIZE(blk_errors)))
247                 return -EIO;
248         return blk_errors[idx].errno;
249 }
250 EXPORT_SYMBOL_GPL(blk_status_to_errno);
251
252 static void print_req_error(struct request *req, blk_status_t status)
253 {
254         int idx = (__force int)status;
255
256         if (WARN_ON_ONCE(idx >= ARRAY_SIZE(blk_errors)))
257                 return;
258
259         printk_ratelimited(KERN_ERR "%s: %s error, dev %s, sector %llu\n",
260                            __func__, blk_errors[idx].name, req->rq_disk ?
261                            req->rq_disk->disk_name : "?",
262                            (unsigned long long)blk_rq_pos(req));
263 }
264
265 static void req_bio_endio(struct request *rq, struct bio *bio,
266                           unsigned int nbytes, blk_status_t error)
267 {
268         if (error)
269                 bio->bi_status = error;
270
271         if (unlikely(rq->rq_flags & RQF_QUIET))
272                 bio_set_flag(bio, BIO_QUIET);
273
274         bio_advance(bio, nbytes);
275
276         /* don't actually finish bio if it's part of flush sequence */
277         if (bio->bi_iter.bi_size == 0 && !(rq->rq_flags & RQF_FLUSH_SEQ))
278                 bio_endio(bio);
279 }
280
281 void blk_dump_rq_flags(struct request *rq, char *msg)
282 {
283         printk(KERN_INFO "%s: dev %s: flags=%llx\n", msg,
284                 rq->rq_disk ? rq->rq_disk->disk_name : "?",
285                 (unsigned long long) rq->cmd_flags);
286
287         printk(KERN_INFO "  sector %llu, nr/cnr %u/%u\n",
288                (unsigned long long)blk_rq_pos(rq),
289                blk_rq_sectors(rq), blk_rq_cur_sectors(rq));
290         printk(KERN_INFO "  bio %p, biotail %p, len %u\n",
291                rq->bio, rq->biotail, blk_rq_bytes(rq));
292 }
293 EXPORT_SYMBOL(blk_dump_rq_flags);
294
295 static void blk_delay_work(struct work_struct *work)
296 {
297         struct request_queue *q;
298
299         q = container_of(work, struct request_queue, delay_work.work);
300         spin_lock_irq(q->queue_lock);
301         __blk_run_queue(q);
302         spin_unlock_irq(q->queue_lock);
303 }
304
305 /**
306  * blk_delay_queue - restart queueing after defined interval
307  * @q:          The &struct request_queue in question
308  * @msecs:      Delay in msecs
309  *
310  * Description:
311  *   Sometimes queueing needs to be postponed for a little while, to allow
312  *   resources to come back. This function will make sure that queueing is
313  *   restarted around the specified time.
314  */
315 void blk_delay_queue(struct request_queue *q, unsigned long msecs)
316 {
317         lockdep_assert_held(q->queue_lock);
318         WARN_ON_ONCE(q->mq_ops);
319
320         if (likely(!blk_queue_dead(q)))
321                 queue_delayed_work(kblockd_workqueue, &q->delay_work,
322                                    msecs_to_jiffies(msecs));
323 }
324 EXPORT_SYMBOL(blk_delay_queue);
325
326 /**
327  * blk_start_queue_async - asynchronously restart a previously stopped queue
328  * @q:    The &struct request_queue in question
329  *
330  * Description:
331  *   blk_start_queue_async() will clear the stop flag on the queue, and
332  *   ensure that the request_fn for the queue is run from an async
333  *   context.
334  **/
335 void blk_start_queue_async(struct request_queue *q)
336 {
337         lockdep_assert_held(q->queue_lock);
338         WARN_ON_ONCE(q->mq_ops);
339
340         queue_flag_clear(QUEUE_FLAG_STOPPED, q);
341         blk_run_queue_async(q);
342 }
343 EXPORT_SYMBOL(blk_start_queue_async);
344
345 /**
346  * blk_start_queue - restart a previously stopped queue
347  * @q:    The &struct request_queue in question
348  *
349  * Description:
350  *   blk_start_queue() will clear the stop flag on the queue, and call
351  *   the request_fn for the queue if it was in a stopped state when
352  *   entered. Also see blk_stop_queue().
353  **/
354 void blk_start_queue(struct request_queue *q)
355 {
356         lockdep_assert_held(q->queue_lock);
357         WARN_ON_ONCE(q->mq_ops);
358
359         queue_flag_clear(QUEUE_FLAG_STOPPED, q);
360         __blk_run_queue(q);
361 }
362 EXPORT_SYMBOL(blk_start_queue);
363
364 /**
365  * blk_stop_queue - stop a queue
366  * @q:    The &struct request_queue in question
367  *
368  * Description:
369  *   The Linux block layer assumes that a block driver will consume all
370  *   entries on the request queue when the request_fn strategy is called.
371  *   Often this will not happen, because of hardware limitations (queue
372  *   depth settings). If a device driver gets a 'queue full' response,
373  *   or if it simply chooses not to queue more I/O at one point, it can
374  *   call this function to prevent the request_fn from being called until
375  *   the driver has signalled it's ready to go again. This happens by calling
376  *   blk_start_queue() to restart queue operations.
377  **/
378 void blk_stop_queue(struct request_queue *q)
379 {
380         lockdep_assert_held(q->queue_lock);
381         WARN_ON_ONCE(q->mq_ops);
382
383         cancel_delayed_work(&q->delay_work);
384         queue_flag_set(QUEUE_FLAG_STOPPED, q);
385 }
386 EXPORT_SYMBOL(blk_stop_queue);
387
388 /**
389  * blk_sync_queue - cancel any pending callbacks on a queue
390  * @q: the queue
391  *
392  * Description:
393  *     The block layer may perform asynchronous callback activity
394  *     on a queue, such as calling the unplug function after a timeout.
395  *     A block device may call blk_sync_queue to ensure that any
396  *     such activity is cancelled, thus allowing it to release resources
397  *     that the callbacks might use. The caller must already have made sure
398  *     that its ->make_request_fn will not re-add plugging prior to calling
399  *     this function.
400  *
401  *     This function does not cancel any asynchronous activity arising
402  *     out of elevator or throttling code. That would require elevator_exit()
403  *     and blkcg_exit_queue() to be called with queue lock initialized.
404  *
405  */
406 void blk_sync_queue(struct request_queue *q)
407 {
408         del_timer_sync(&q->timeout);
409         cancel_work_sync(&q->timeout_work);
410
411         if (q->mq_ops) {
412                 struct blk_mq_hw_ctx *hctx;
413                 int i;
414
415                 cancel_delayed_work_sync(&q->requeue_work);
416                 queue_for_each_hw_ctx(q, hctx, i)
417                         cancel_delayed_work_sync(&hctx->run_work);
418         } else {
419                 cancel_delayed_work_sync(&q->delay_work);
420         }
421 }
422 EXPORT_SYMBOL(blk_sync_queue);
423
424 /**
425  * blk_set_pm_only - increment pm_only counter
426  * @q: request queue pointer
427  */
428 void blk_set_pm_only(struct request_queue *q)
429 {
430         atomic_inc(&q->pm_only);
431 }
432 EXPORT_SYMBOL_GPL(blk_set_pm_only);
433
434 void blk_clear_pm_only(struct request_queue *q)
435 {
436         int pm_only;
437
438         pm_only = atomic_dec_return(&q->pm_only);
439         WARN_ON_ONCE(pm_only < 0);
440         if (pm_only == 0)
441                 wake_up_all(&q->mq_freeze_wq);
442 }
443 EXPORT_SYMBOL_GPL(blk_clear_pm_only);
444
445 /**
446  * __blk_run_queue_uncond - run a queue whether or not it has been stopped
447  * @q:  The queue to run
448  *
449  * Description:
450  *    Invoke request handling on a queue if there are any pending requests.
451  *    May be used to restart request handling after a request has completed.
452  *    This variant runs the queue whether or not the queue has been
453  *    stopped. Must be called with the queue lock held and interrupts
454  *    disabled. See also @blk_run_queue.
455  */
456 inline void __blk_run_queue_uncond(struct request_queue *q)
457 {
458         lockdep_assert_held(q->queue_lock);
459         WARN_ON_ONCE(q->mq_ops);
460
461         if (unlikely(blk_queue_dead(q)))
462                 return;
463
464         /*
465          * Some request_fn implementations, e.g. scsi_request_fn(), unlock
466          * the queue lock internally. As a result multiple threads may be
467          * running such a request function concurrently. Keep track of the
468          * number of active request_fn invocations such that blk_drain_queue()
469          * can wait until all these request_fn calls have finished.
470          */
471         q->request_fn_active++;
472         q->request_fn(q);
473         q->request_fn_active--;
474 }
475 EXPORT_SYMBOL_GPL(__blk_run_queue_uncond);
476
477 /**
478  * __blk_run_queue - run a single device queue
479  * @q:  The queue to run
480  *
481  * Description:
482  *    See @blk_run_queue.
483  */
484 void __blk_run_queue(struct request_queue *q)
485 {
486         lockdep_assert_held(q->queue_lock);
487         WARN_ON_ONCE(q->mq_ops);
488
489         if (unlikely(blk_queue_stopped(q)))
490                 return;
491
492         __blk_run_queue_uncond(q);
493 }
494 EXPORT_SYMBOL(__blk_run_queue);
495
496 /**
497  * blk_run_queue_async - run a single device queue in workqueue context
498  * @q:  The queue to run
499  *
500  * Description:
501  *    Tells kblockd to perform the equivalent of @blk_run_queue on behalf
502  *    of us.
503  *
504  * Note:
505  *    Since it is not allowed to run q->delay_work after blk_cleanup_queue()
506  *    has canceled q->delay_work, callers must hold the queue lock to avoid
507  *    race conditions between blk_cleanup_queue() and blk_run_queue_async().
508  */
509 void blk_run_queue_async(struct request_queue *q)
510 {
511         lockdep_assert_held(q->queue_lock);
512         WARN_ON_ONCE(q->mq_ops);
513
514         if (likely(!blk_queue_stopped(q) && !blk_queue_dead(q)))
515                 mod_delayed_work(kblockd_workqueue, &q->delay_work, 0);
516 }
517 EXPORT_SYMBOL(blk_run_queue_async);
518
519 /**
520  * blk_run_queue - run a single device queue
521  * @q: The queue to run
522  *
523  * Description:
524  *    Invoke request handling on this queue, if it has pending work to do.
525  *    May be used to restart queueing when a request has completed.
526  */
527 void blk_run_queue(struct request_queue *q)
528 {
529         unsigned long flags;
530
531         WARN_ON_ONCE(q->mq_ops);
532
533         spin_lock_irqsave(q->queue_lock, flags);
534         __blk_run_queue(q);
535         spin_unlock_irqrestore(q->queue_lock, flags);
536 }
537 EXPORT_SYMBOL(blk_run_queue);
538
539 void blk_put_queue(struct request_queue *q)
540 {
541         kobject_put(&q->kobj);
542 }
543 EXPORT_SYMBOL(blk_put_queue);
544
545 /**
546  * __blk_drain_queue - drain requests from request_queue
547  * @q: queue to drain
548  * @drain_all: whether to drain all requests or only the ones w/ ELVPRIV
549  *
550  * Drain requests from @q.  If @drain_all is set, all requests are drained.
551  * If not, only ELVPRIV requests are drained.  The caller is responsible
552  * for ensuring that no new requests which need to be drained are queued.
553  */
554 static void __blk_drain_queue(struct request_queue *q, bool drain_all)
555         __releases(q->queue_lock)
556         __acquires(q->queue_lock)
557 {
558         int i;
559
560         lockdep_assert_held(q->queue_lock);
561         WARN_ON_ONCE(q->mq_ops);
562
563         while (true) {
564                 bool drain = false;
565
566                 /*
567                  * The caller might be trying to drain @q before its
568                  * elevator is initialized.
569                  */
570                 if (q->elevator)
571                         elv_drain_elevator(q);
572
573                 blkcg_drain_queue(q);
574
575                 /*
576                  * This function might be called on a queue which failed
577                  * driver init after queue creation or is not yet fully
578                  * active yet.  Some drivers (e.g. fd and loop) get unhappy
579                  * in such cases.  Kick queue iff dispatch queue has
580                  * something on it and @q has request_fn set.
581                  */
582                 if (!list_empty(&q->queue_head) && q->request_fn)
583                         __blk_run_queue(q);
584
585                 drain |= q->nr_rqs_elvpriv;
586                 drain |= q->request_fn_active;
587
588                 /*
589                  * Unfortunately, requests are queued at and tracked from
590                  * multiple places and there's no single counter which can
591                  * be drained.  Check all the queues and counters.
592                  */
593                 if (drain_all) {
594                         struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL);
595                         drain |= !list_empty(&q->queue_head);
596                         for (i = 0; i < 2; i++) {
597                                 drain |= q->nr_rqs[i];
598                                 drain |= q->in_flight[i];
599                                 if (fq)
600                                     drain |= !list_empty(&fq->flush_queue[i]);
601                         }
602                 }
603
604                 if (!drain)
605                         break;
606
607                 spin_unlock_irq(q->queue_lock);
608
609                 msleep(10);
610
611                 spin_lock_irq(q->queue_lock);
612         }
613
614         /*
615          * With queue marked dead, any woken up waiter will fail the
616          * allocation path, so the wakeup chaining is lost and we're
617          * left with hung waiters. We need to wake up those waiters.
618          */
619         if (q->request_fn) {
620                 struct request_list *rl;
621
622                 blk_queue_for_each_rl(rl, q)
623                         for (i = 0; i < ARRAY_SIZE(rl->wait); i++)
624                                 wake_up_all(&rl->wait[i]);
625         }
626 }
627
628 void blk_drain_queue(struct request_queue *q)
629 {
630         spin_lock_irq(q->queue_lock);
631         __blk_drain_queue(q, true);
632         spin_unlock_irq(q->queue_lock);
633 }
634
635 /**
636  * blk_queue_bypass_start - enter queue bypass mode
637  * @q: queue of interest
638  *
639  * In bypass mode, only the dispatch FIFO queue of @q is used.  This
640  * function makes @q enter bypass mode and drains all requests which were
641  * throttled or issued before.  On return, it's guaranteed that no request
642  * is being throttled or has ELVPRIV set and blk_queue_bypass() %true
643  * inside queue or RCU read lock.
644  */
645 void blk_queue_bypass_start(struct request_queue *q)
646 {
647         WARN_ON_ONCE(q->mq_ops);
648
649         spin_lock_irq(q->queue_lock);
650         q->bypass_depth++;
651         queue_flag_set(QUEUE_FLAG_BYPASS, q);
652         spin_unlock_irq(q->queue_lock);
653
654         /*
655          * Queues start drained.  Skip actual draining till init is
656          * complete.  This avoids lenghty delays during queue init which
657          * can happen many times during boot.
658          */
659         if (blk_queue_init_done(q)) {
660                 spin_lock_irq(q->queue_lock);
661                 __blk_drain_queue(q, false);
662                 spin_unlock_irq(q->queue_lock);
663
664                 /* ensure blk_queue_bypass() is %true inside RCU read lock */
665                 synchronize_rcu();
666         }
667 }
668 EXPORT_SYMBOL_GPL(blk_queue_bypass_start);
669
670 /**
671  * blk_queue_bypass_end - leave queue bypass mode
672  * @q: queue of interest
673  *
674  * Leave bypass mode and restore the normal queueing behavior.
675  *
676  * Note: although blk_queue_bypass_start() is only called for blk-sq queues,
677  * this function is called for both blk-sq and blk-mq queues.
678  */
679 void blk_queue_bypass_end(struct request_queue *q)
680 {
681         spin_lock_irq(q->queue_lock);
682         if (!--q->bypass_depth)
683                 queue_flag_clear(QUEUE_FLAG_BYPASS, q);
684         WARN_ON_ONCE(q->bypass_depth < 0);
685         spin_unlock_irq(q->queue_lock);
686 }
687 EXPORT_SYMBOL_GPL(blk_queue_bypass_end);
688
689 void blk_set_queue_dying(struct request_queue *q)
690 {
691         blk_queue_flag_set(QUEUE_FLAG_DYING, q);
692
693         /*
694          * When queue DYING flag is set, we need to block new req
695          * entering queue, so we call blk_freeze_queue_start() to
696          * prevent I/O from crossing blk_queue_enter().
697          */
698         blk_freeze_queue_start(q);
699
700         if (q->mq_ops)
701                 blk_mq_wake_waiters(q);
702         else {
703                 struct request_list *rl;
704
705                 spin_lock_irq(q->queue_lock);
706                 blk_queue_for_each_rl(rl, q) {
707                         if (rl->rq_pool) {
708                                 wake_up_all(&rl->wait[BLK_RW_SYNC]);
709                                 wake_up_all(&rl->wait[BLK_RW_ASYNC]);
710                         }
711                 }
712                 spin_unlock_irq(q->queue_lock);
713         }
714
715         /* Make blk_queue_enter() reexamine the DYING flag. */
716         wake_up_all(&q->mq_freeze_wq);
717 }
718 EXPORT_SYMBOL_GPL(blk_set_queue_dying);
719
720 /* Unconfigure the I/O scheduler and dissociate from the cgroup controller. */
721 void blk_exit_queue(struct request_queue *q)
722 {
723         /*
724          * Since the I/O scheduler exit code may access cgroup information,
725          * perform I/O scheduler exit before disassociating from the block
726          * cgroup controller.
727          */
728         if (q->elevator) {
729                 ioc_clear_queue(q);
730                 elevator_exit(q, q->elevator);
731                 q->elevator = NULL;
732         }
733
734         /*
735          * Remove all references to @q from the block cgroup controller before
736          * restoring @q->queue_lock to avoid that restoring this pointer causes
737          * e.g. blkcg_print_blkgs() to crash.
738          */
739         blkcg_exit_queue(q);
740
741         /*
742          * Since the cgroup code may dereference the @q->backing_dev_info
743          * pointer, only decrease its reference count after having removed the
744          * association with the block cgroup controller.
745          */
746         bdi_put(q->backing_dev_info);
747 }
748
749 /**
750  * blk_cleanup_queue - shutdown a request queue
751  * @q: request queue to shutdown
752  *
753  * Mark @q DYING, drain all pending requests, mark @q DEAD, destroy and
754  * put it.  All future requests will be failed immediately with -ENODEV.
755  */
756 void blk_cleanup_queue(struct request_queue *q)
757 {
758         spinlock_t *lock = q->queue_lock;
759
760         /* mark @q DYING, no new request or merges will be allowed afterwards */
761         mutex_lock(&q->sysfs_lock);
762         blk_set_queue_dying(q);
763         spin_lock_irq(lock);
764
765         /*
766          * A dying queue is permanently in bypass mode till released.  Note
767          * that, unlike blk_queue_bypass_start(), we aren't performing
768          * synchronize_rcu() after entering bypass mode to avoid the delay
769          * as some drivers create and destroy a lot of queues while
770          * probing.  This is still safe because blk_release_queue() will be
771          * called only after the queue refcnt drops to zero and nothing,
772          * RCU or not, would be traversing the queue by then.
773          */
774         q->bypass_depth++;
775         queue_flag_set(QUEUE_FLAG_BYPASS, q);
776
777         queue_flag_set(QUEUE_FLAG_NOMERGES, q);
778         queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
779         queue_flag_set(QUEUE_FLAG_DYING, q);
780         spin_unlock_irq(lock);
781         mutex_unlock(&q->sysfs_lock);
782
783         /*
784          * Drain all requests queued before DYING marking. Set DEAD flag to
785          * prevent that q->request_fn() gets invoked after draining finished.
786          */
787         blk_freeze_queue(q);
788
789         rq_qos_exit(q);
790
791         spin_lock_irq(lock);
792         queue_flag_set(QUEUE_FLAG_DEAD, q);
793         spin_unlock_irq(lock);
794
795         /*
796          * make sure all in-progress dispatch are completed because
797          * blk_freeze_queue() can only complete all requests, and
798          * dispatch may still be in-progress since we dispatch requests
799          * from more than one contexts.
800          *
801          * We rely on driver to deal with the race in case that queue
802          * initialization isn't done.
803          */
804         if (q->mq_ops && blk_queue_init_done(q))
805                 blk_mq_quiesce_queue(q);
806
807         /* for synchronous bio-based driver finish in-flight integrity i/o */
808         blk_flush_integrity();
809
810         /* @q won't process any more request, flush async actions */
811         del_timer_sync(&q->backing_dev_info->laptop_mode_wb_timer);
812         blk_sync_queue(q);
813
814         /*
815          * I/O scheduler exit is only safe after the sysfs scheduler attribute
816          * has been removed.
817          */
818         WARN_ON_ONCE(q->kobj.state_in_sysfs);
819
820         blk_exit_queue(q);
821
822         if (q->mq_ops)
823                 blk_mq_free_queue(q);
824         percpu_ref_exit(&q->q_usage_counter);
825
826         spin_lock_irq(lock);
827         if (q->queue_lock != &q->__queue_lock)
828                 q->queue_lock = &q->__queue_lock;
829         spin_unlock_irq(lock);
830
831         /* @q is and will stay empty, shutdown and put */
832         blk_put_queue(q);
833 }
834 EXPORT_SYMBOL(blk_cleanup_queue);
835
836 /* Allocate memory local to the request queue */
837 static void *alloc_request_simple(gfp_t gfp_mask, void *data)
838 {
839         struct request_queue *q = data;
840
841         return kmem_cache_alloc_node(request_cachep, gfp_mask, q->node);
842 }
843
844 static void free_request_simple(void *element, void *data)
845 {
846         kmem_cache_free(request_cachep, element);
847 }
848
849 static void *alloc_request_size(gfp_t gfp_mask, void *data)
850 {
851         struct request_queue *q = data;
852         struct request *rq;
853
854         rq = kmalloc_node(sizeof(struct request) + q->cmd_size, gfp_mask,
855                         q->node);
856         if (rq && q->init_rq_fn && q->init_rq_fn(q, rq, gfp_mask) < 0) {
857                 kfree(rq);
858                 rq = NULL;
859         }
860         return rq;
861 }
862
863 static void free_request_size(void *element, void *data)
864 {
865         struct request_queue *q = data;
866
867         if (q->exit_rq_fn)
868                 q->exit_rq_fn(q, element);
869         kfree(element);
870 }
871
872 int blk_init_rl(struct request_list *rl, struct request_queue *q,
873                 gfp_t gfp_mask)
874 {
875         if (unlikely(rl->rq_pool) || q->mq_ops)
876                 return 0;
877
878         rl->q = q;
879         rl->count[BLK_RW_SYNC] = rl->count[BLK_RW_ASYNC] = 0;
880         rl->starved[BLK_RW_SYNC] = rl->starved[BLK_RW_ASYNC] = 0;
881         init_waitqueue_head(&rl->wait[BLK_RW_SYNC]);
882         init_waitqueue_head(&rl->wait[BLK_RW_ASYNC]);
883
884         if (q->cmd_size) {
885                 rl->rq_pool = mempool_create_node(BLKDEV_MIN_RQ,
886                                 alloc_request_size, free_request_size,
887                                 q, gfp_mask, q->node);
888         } else {
889                 rl->rq_pool = mempool_create_node(BLKDEV_MIN_RQ,
890                                 alloc_request_simple, free_request_simple,
891                                 q, gfp_mask, q->node);
892         }
893         if (!rl->rq_pool)
894                 return -ENOMEM;
895
896         if (rl != &q->root_rl)
897                 WARN_ON_ONCE(!blk_get_queue(q));
898
899         return 0;
900 }
901
902 void blk_exit_rl(struct request_queue *q, struct request_list *rl)
903 {
904         if (rl->rq_pool) {
905                 mempool_destroy(rl->rq_pool);
906                 if (rl != &q->root_rl)
907                         blk_put_queue(q);
908         }
909 }
910
911 struct request_queue *blk_alloc_queue(gfp_t gfp_mask)
912 {
913         return blk_alloc_queue_node(gfp_mask, NUMA_NO_NODE, NULL);
914 }
915 EXPORT_SYMBOL(blk_alloc_queue);
916
917 /**
918  * blk_queue_enter() - try to increase q->q_usage_counter
919  * @q: request queue pointer
920  * @flags: BLK_MQ_REQ_NOWAIT and/or BLK_MQ_REQ_PREEMPT
921  */
922 int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags)
923 {
924         const bool pm = flags & BLK_MQ_REQ_PREEMPT;
925
926         while (true) {
927                 bool success = false;
928
929                 rcu_read_lock();
930                 if (percpu_ref_tryget_live(&q->q_usage_counter)) {
931                         /*
932                          * The code that increments the pm_only counter is
933                          * responsible for ensuring that that counter is
934                          * globally visible before the queue is unfrozen.
935                          */
936                         if (pm || !blk_queue_pm_only(q)) {
937                                 success = true;
938                         } else {
939                                 percpu_ref_put(&q->q_usage_counter);
940                         }
941                 }
942                 rcu_read_unlock();
943
944                 if (success)
945                         return 0;
946
947                 if (flags & BLK_MQ_REQ_NOWAIT)
948                         return -EBUSY;
949
950                 /*
951                  * read pair of barrier in blk_freeze_queue_start(),
952                  * we need to order reading __PERCPU_REF_DEAD flag of
953                  * .q_usage_counter and reading .mq_freeze_depth or
954                  * queue dying flag, otherwise the following wait may
955                  * never return if the two reads are reordered.
956                  */
957                 smp_rmb();
958
959                 wait_event(q->mq_freeze_wq,
960                            (atomic_read(&q->mq_freeze_depth) == 0 &&
961                             (pm || (blk_pm_request_resume(q),
962                                     !blk_queue_pm_only(q)))) ||
963                            blk_queue_dying(q));
964                 if (blk_queue_dying(q))
965                         return -ENODEV;
966         }
967 }
968
969 void blk_queue_exit(struct request_queue *q)
970 {
971         percpu_ref_put(&q->q_usage_counter);
972 }
973
974 static void blk_queue_usage_counter_release(struct percpu_ref *ref)
975 {
976         struct request_queue *q =
977                 container_of(ref, struct request_queue, q_usage_counter);
978
979         wake_up_all(&q->mq_freeze_wq);
980 }
981
982 static void blk_rq_timed_out_timer(struct timer_list *t)
983 {
984         struct request_queue *q = from_timer(q, t, timeout);
985
986         kblockd_schedule_work(&q->timeout_work);
987 }
988
989 /**
990  * blk_alloc_queue_node - allocate a request queue
991  * @gfp_mask: memory allocation flags
992  * @node_id: NUMA node to allocate memory from
993  * @lock: For legacy queues, pointer to a spinlock that will be used to e.g.
994  *        serialize calls to the legacy .request_fn() callback. Ignored for
995  *        blk-mq request queues.
996  *
997  * Note: pass the queue lock as the third argument to this function instead of
998  * setting the queue lock pointer explicitly to avoid triggering a sporadic
999  * crash in the blkcg code. This function namely calls blkcg_init_queue() and
1000  * the queue lock pointer must be set before blkcg_init_queue() is called.
1001  */
1002 struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id,
1003                                            spinlock_t *lock)
1004 {
1005         struct request_queue *q;
1006         int ret;
1007
1008         q = kmem_cache_alloc_node(blk_requestq_cachep,
1009                                 gfp_mask | __GFP_ZERO, node_id);
1010         if (!q)
1011                 return NULL;
1012
1013         INIT_LIST_HEAD(&q->queue_head);
1014         q->last_merge = NULL;
1015         q->end_sector = 0;
1016         q->boundary_rq = NULL;
1017
1018         q->id = ida_simple_get(&blk_queue_ida, 0, 0, gfp_mask);
1019         if (q->id < 0)
1020                 goto fail_q;
1021
1022         ret = bioset_init(&q->bio_split, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
1023         if (ret)
1024                 goto fail_id;
1025
1026         q->backing_dev_info = bdi_alloc_node(gfp_mask, node_id);
1027         if (!q->backing_dev_info)
1028                 goto fail_split;
1029
1030         q->stats = blk_alloc_queue_stats();
1031         if (!q->stats)
1032                 goto fail_stats;
1033
1034         q->backing_dev_info->ra_pages =
1035                         (VM_MAX_READAHEAD * 1024) / PAGE_SIZE;
1036         q->backing_dev_info->capabilities = BDI_CAP_CGROUP_WRITEBACK;
1037         q->backing_dev_info->name = "block";
1038         q->node = node_id;
1039
1040         timer_setup(&q->backing_dev_info->laptop_mode_wb_timer,
1041                     laptop_mode_timer_fn, 0);
1042         timer_setup(&q->timeout, blk_rq_timed_out_timer, 0);
1043         INIT_WORK(&q->timeout_work, NULL);
1044         INIT_LIST_HEAD(&q->timeout_list);
1045         INIT_LIST_HEAD(&q->icq_list);
1046 #ifdef CONFIG_BLK_CGROUP
1047         INIT_LIST_HEAD(&q->blkg_list);
1048 #endif
1049         INIT_DELAYED_WORK(&q->delay_work, blk_delay_work);
1050
1051         kobject_init(&q->kobj, &blk_queue_ktype);
1052
1053 #ifdef CONFIG_BLK_DEV_IO_TRACE
1054         mutex_init(&q->blk_trace_mutex);
1055 #endif
1056         mutex_init(&q->sysfs_lock);
1057         spin_lock_init(&q->__queue_lock);
1058
1059         q->queue_lock = lock ? : &q->__queue_lock;
1060
1061         /*
1062          * A queue starts its life with bypass turned on to avoid
1063          * unnecessary bypass on/off overhead and nasty surprises during
1064          * init.  The initial bypass will be finished when the queue is
1065          * registered by blk_register_queue().
1066          */
1067         q->bypass_depth = 1;
1068         queue_flag_set_unlocked(QUEUE_FLAG_BYPASS, q);
1069
1070         init_waitqueue_head(&q->mq_freeze_wq);
1071
1072         /*
1073          * Init percpu_ref in atomic mode so that it's faster to shutdown.
1074          * See blk_register_queue() for details.
1075          */
1076         if (percpu_ref_init(&q->q_usage_counter,
1077                                 blk_queue_usage_counter_release,
1078                                 PERCPU_REF_INIT_ATOMIC, GFP_KERNEL))
1079                 goto fail_bdi;
1080
1081         if (blkcg_init_queue(q))
1082                 goto fail_ref;
1083
1084         return q;
1085
1086 fail_ref:
1087         percpu_ref_exit(&q->q_usage_counter);
1088 fail_bdi:
1089         blk_free_queue_stats(q->stats);
1090 fail_stats:
1091         bdi_put(q->backing_dev_info);
1092 fail_split:
1093         bioset_exit(&q->bio_split);
1094 fail_id:
1095         ida_simple_remove(&blk_queue_ida, q->id);
1096 fail_q:
1097         kmem_cache_free(blk_requestq_cachep, q);
1098         return NULL;
1099 }
1100 EXPORT_SYMBOL(blk_alloc_queue_node);
1101
1102 /**
1103  * blk_init_queue  - prepare a request queue for use with a block device
1104  * @rfn:  The function to be called to process requests that have been
1105  *        placed on the queue.
1106  * @lock: Request queue spin lock
1107  *
1108  * Description:
1109  *    If a block device wishes to use the standard request handling procedures,
1110  *    which sorts requests and coalesces adjacent requests, then it must
1111  *    call blk_init_queue().  The function @rfn will be called when there
1112  *    are requests on the queue that need to be processed.  If the device
1113  *    supports plugging, then @rfn may not be called immediately when requests
1114  *    are available on the queue, but may be called at some time later instead.
1115  *    Plugged queues are generally unplugged when a buffer belonging to one
1116  *    of the requests on the queue is needed, or due to memory pressure.
1117  *
1118  *    @rfn is not required, or even expected, to remove all requests off the
1119  *    queue, but only as many as it can handle at a time.  If it does leave
1120  *    requests on the queue, it is responsible for arranging that the requests
1121  *    get dealt with eventually.
1122  *
1123  *    The queue spin lock must be held while manipulating the requests on the
1124  *    request queue; this lock will be taken also from interrupt context, so irq
1125  *    disabling is needed for it.
1126  *
1127  *    Function returns a pointer to the initialized request queue, or %NULL if
1128  *    it didn't succeed.
1129  *
1130  * Note:
1131  *    blk_init_queue() must be paired with a blk_cleanup_queue() call
1132  *    when the block device is deactivated (such as at module unload).
1133  **/
1134
1135 struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)
1136 {
1137         return blk_init_queue_node(rfn, lock, NUMA_NO_NODE);
1138 }
1139 EXPORT_SYMBOL(blk_init_queue);
1140
1141 struct request_queue *
1142 blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)
1143 {
1144         struct request_queue *q;
1145
1146         q = blk_alloc_queue_node(GFP_KERNEL, node_id, lock);
1147         if (!q)
1148                 return NULL;
1149
1150         q->request_fn = rfn;
1151         if (blk_init_allocated_queue(q) < 0) {
1152                 blk_cleanup_queue(q);
1153                 return NULL;
1154         }
1155
1156         return q;
1157 }
1158 EXPORT_SYMBOL(blk_init_queue_node);
1159
1160 static blk_qc_t blk_queue_bio(struct request_queue *q, struct bio *bio);
1161
1162
1163 int blk_init_allocated_queue(struct request_queue *q)
1164 {
1165         WARN_ON_ONCE(q->mq_ops);
1166
1167         q->fq = blk_alloc_flush_queue(q, NUMA_NO_NODE, q->cmd_size, GFP_KERNEL);
1168         if (!q->fq)
1169                 return -ENOMEM;
1170
1171         if (q->init_rq_fn && q->init_rq_fn(q, q->fq->flush_rq, GFP_KERNEL))
1172                 goto out_free_flush_queue;
1173
1174         if (blk_init_rl(&q->root_rl, q, GFP_KERNEL))
1175                 goto out_exit_flush_rq;
1176
1177         INIT_WORK(&q->timeout_work, blk_timeout_work);
1178         q->queue_flags          |= QUEUE_FLAG_DEFAULT;
1179
1180         /*
1181          * This also sets hw/phys segments, boundary and size
1182          */
1183         blk_queue_make_request(q, blk_queue_bio);
1184
1185         q->sg_reserved_size = INT_MAX;
1186
1187         if (elevator_init(q))
1188                 goto out_exit_flush_rq;
1189         return 0;
1190
1191 out_exit_flush_rq:
1192         if (q->exit_rq_fn)
1193                 q->exit_rq_fn(q, q->fq->flush_rq);
1194 out_free_flush_queue:
1195         blk_free_flush_queue(q->fq);
1196         q->fq = NULL;
1197         return -ENOMEM;
1198 }
1199 EXPORT_SYMBOL(blk_init_allocated_queue);
1200
1201 bool blk_get_queue(struct request_queue *q)
1202 {
1203         if (likely(!blk_queue_dying(q))) {
1204                 __blk_get_queue(q);
1205                 return true;
1206         }
1207
1208         return false;
1209 }
1210 EXPORT_SYMBOL(blk_get_queue);
1211
1212 static inline void blk_free_request(struct request_list *rl, struct request *rq)
1213 {
1214         if (rq->rq_flags & RQF_ELVPRIV) {
1215                 elv_put_request(rl->q, rq);
1216                 if (rq->elv.icq)
1217                         put_io_context(rq->elv.icq->ioc);
1218         }
1219
1220         mempool_free(rq, rl->rq_pool);
1221 }
1222
1223 /*
1224  * ioc_batching returns true if the ioc is a valid batching request and
1225  * should be given priority access to a request.
1226  */
1227 static inline int ioc_batching(struct request_queue *q, struct io_context *ioc)
1228 {
1229         if (!ioc)
1230                 return 0;
1231
1232         /*
1233          * Make sure the process is able to allocate at least 1 request
1234          * even if the batch times out, otherwise we could theoretically
1235          * lose wakeups.
1236          */
1237         return ioc->nr_batch_requests == q->nr_batching ||
1238                 (ioc->nr_batch_requests > 0
1239                 && time_before(jiffies, ioc->last_waited + BLK_BATCH_TIME));
1240 }
1241
1242 /*
1243  * ioc_set_batching sets ioc to be a new "batcher" if it is not one. This
1244  * will cause the process to be a "batcher" on all queues in the system. This
1245  * is the behaviour we want though - once it gets a wakeup it should be given
1246  * a nice run.
1247  */
1248 static void ioc_set_batching(struct request_queue *q, struct io_context *ioc)
1249 {
1250         if (!ioc || ioc_batching(q, ioc))
1251                 return;
1252
1253         ioc->nr_batch_requests = q->nr_batching;
1254         ioc->last_waited = jiffies;
1255 }
1256
1257 static void __freed_request(struct request_list *rl, int sync)
1258 {
1259         struct request_queue *q = rl->q;
1260
1261         if (rl->count[sync] < queue_congestion_off_threshold(q))
1262                 blk_clear_congested(rl, sync);
1263
1264         if (rl->count[sync] + 1 <= q->nr_requests) {
1265                 if (waitqueue_active(&rl->wait[sync]))
1266                         wake_up(&rl->wait[sync]);
1267
1268                 blk_clear_rl_full(rl, sync);
1269         }
1270 }
1271
1272 /*
1273  * A request has just been released.  Account for it, update the full and
1274  * congestion status, wake up any waiters.   Called under q->queue_lock.
1275  */
1276 static void freed_request(struct request_list *rl, bool sync,
1277                 req_flags_t rq_flags)
1278 {
1279         struct request_queue *q = rl->q;
1280
1281         q->nr_rqs[sync]--;
1282         rl->count[sync]--;
1283         if (rq_flags & RQF_ELVPRIV)
1284                 q->nr_rqs_elvpriv--;
1285
1286         __freed_request(rl, sync);
1287
1288         if (unlikely(rl->starved[sync ^ 1]))
1289                 __freed_request(rl, sync ^ 1);
1290 }
1291
1292 int blk_update_nr_requests(struct request_queue *q, unsigned int nr)
1293 {
1294         struct request_list *rl;
1295         int on_thresh, off_thresh;
1296
1297         WARN_ON_ONCE(q->mq_ops);
1298
1299         spin_lock_irq(q->queue_lock);
1300         q->nr_requests = nr;
1301         blk_queue_congestion_threshold(q);
1302         on_thresh = queue_congestion_on_threshold(q);
1303         off_thresh = queue_congestion_off_threshold(q);
1304
1305         blk_queue_for_each_rl(rl, q) {
1306                 if (rl->count[BLK_RW_SYNC] >= on_thresh)
1307                         blk_set_congested(rl, BLK_RW_SYNC);
1308                 else if (rl->count[BLK_RW_SYNC] < off_thresh)
1309                         blk_clear_congested(rl, BLK_RW_SYNC);
1310
1311                 if (rl->count[BLK_RW_ASYNC] >= on_thresh)
1312                         blk_set_congested(rl, BLK_RW_ASYNC);
1313                 else if (rl->count[BLK_RW_ASYNC] < off_thresh)
1314                         blk_clear_congested(rl, BLK_RW_ASYNC);
1315
1316                 if (rl->count[BLK_RW_SYNC] >= q->nr_requests) {
1317                         blk_set_rl_full(rl, BLK_RW_SYNC);
1318                 } else {
1319                         blk_clear_rl_full(rl, BLK_RW_SYNC);
1320                         wake_up(&rl->wait[BLK_RW_SYNC]);
1321                 }
1322
1323                 if (rl->count[BLK_RW_ASYNC] >= q->nr_requests) {
1324                         blk_set_rl_full(rl, BLK_RW_ASYNC);
1325                 } else {
1326                         blk_clear_rl_full(rl, BLK_RW_ASYNC);
1327                         wake_up(&rl->wait[BLK_RW_ASYNC]);
1328                 }
1329         }
1330
1331         spin_unlock_irq(q->queue_lock);
1332         return 0;
1333 }
1334
1335 /**
1336  * __get_request - get a free request
1337  * @rl: request list to allocate from
1338  * @op: operation and flags
1339  * @bio: bio to allocate request for (can be %NULL)
1340  * @flags: BLQ_MQ_REQ_* flags
1341  * @gfp_mask: allocator flags
1342  *
1343  * Get a free request from @q.  This function may fail under memory
1344  * pressure or if @q is dead.
1345  *
1346  * Must be called with @q->queue_lock held and,
1347  * Returns ERR_PTR on failure, with @q->queue_lock held.
1348  * Returns request pointer on success, with @q->queue_lock *not held*.
1349  */
1350 static struct request *__get_request(struct request_list *rl, unsigned int op,
1351                 struct bio *bio, blk_mq_req_flags_t flags, gfp_t gfp_mask)
1352 {
1353         struct request_queue *q = rl->q;
1354         struct request *rq;
1355         struct elevator_type *et = q->elevator->type;
1356         struct io_context *ioc = rq_ioc(bio);
1357         struct io_cq *icq = NULL;
1358         const bool is_sync = op_is_sync(op);
1359         int may_queue;
1360         req_flags_t rq_flags = RQF_ALLOCED;
1361
1362         lockdep_assert_held(q->queue_lock);
1363
1364         if (unlikely(blk_queue_dying(q)))
1365                 return ERR_PTR(-ENODEV);
1366
1367         may_queue = elv_may_queue(q, op);
1368         if (may_queue == ELV_MQUEUE_NO)
1369                 goto rq_starved;
1370
1371         if (rl->count[is_sync]+1 >= queue_congestion_on_threshold(q)) {
1372                 if (rl->count[is_sync]+1 >= q->nr_requests) {
1373                         /*
1374                          * The queue will fill after this allocation, so set
1375                          * it as full, and mark this process as "batching".
1376                          * This process will be allowed to complete a batch of
1377                          * requests, others will be blocked.
1378                          */
1379                         if (!blk_rl_full(rl, is_sync)) {
1380                                 ioc_set_batching(q, ioc);
1381                                 blk_set_rl_full(rl, is_sync);
1382                         } else {
1383                                 if (may_queue != ELV_MQUEUE_MUST
1384                                                 && !ioc_batching(q, ioc)) {
1385                                         /*
1386                                          * The queue is full and the allocating
1387                                          * process is not a "batcher", and not
1388                                          * exempted by the IO scheduler
1389                                          */
1390                                         return ERR_PTR(-ENOMEM);
1391                                 }
1392                         }
1393                 }
1394                 blk_set_congested(rl, is_sync);
1395         }
1396
1397         /*
1398          * Only allow batching queuers to allocate up to 50% over the defined
1399          * limit of requests, otherwise we could have thousands of requests
1400          * allocated with any setting of ->nr_requests
1401          */
1402         if (rl->count[is_sync] >= (3 * q->nr_requests / 2))
1403                 return ERR_PTR(-ENOMEM);
1404
1405         q->nr_rqs[is_sync]++;
1406         rl->count[is_sync]++;
1407         rl->starved[is_sync] = 0;
1408
1409         /*
1410          * Decide whether the new request will be managed by elevator.  If
1411          * so, mark @rq_flags and increment elvpriv.  Non-zero elvpriv will
1412          * prevent the current elevator from being destroyed until the new
1413          * request is freed.  This guarantees icq's won't be destroyed and
1414          * makes creating new ones safe.
1415          *
1416          * Flush requests do not use the elevator so skip initialization.
1417          * This allows a request to share the flush and elevator data.
1418          *
1419          * Also, lookup icq while holding queue_lock.  If it doesn't exist,
1420          * it will be created after releasing queue_lock.
1421          */
1422         if (!op_is_flush(op) && !blk_queue_bypass(q)) {
1423                 rq_flags |= RQF_ELVPRIV;
1424                 q->nr_rqs_elvpriv++;
1425                 if (et->icq_cache && ioc)
1426                         icq = ioc_lookup_icq(ioc, q);
1427         }
1428
1429         if (blk_queue_io_stat(q))
1430                 rq_flags |= RQF_IO_STAT;
1431         spin_unlock_irq(q->queue_lock);
1432
1433         /* allocate and init request */
1434         rq = mempool_alloc(rl->rq_pool, gfp_mask);
1435         if (!rq)
1436                 goto fail_alloc;
1437
1438         blk_rq_init(q, rq);
1439         blk_rq_set_rl(rq, rl);
1440         rq->cmd_flags = op;
1441         rq->rq_flags = rq_flags;
1442         if (flags & BLK_MQ_REQ_PREEMPT)
1443                 rq->rq_flags |= RQF_PREEMPT;
1444
1445         /* init elvpriv */
1446         if (rq_flags & RQF_ELVPRIV) {
1447                 if (unlikely(et->icq_cache && !icq)) {
1448                         if (ioc)
1449                                 icq = ioc_create_icq(ioc, q, gfp_mask);
1450                         if (!icq)
1451                                 goto fail_elvpriv;
1452                 }
1453
1454                 rq->elv.icq = icq;
1455                 if (unlikely(elv_set_request(q, rq, bio, gfp_mask)))
1456                         goto fail_elvpriv;
1457
1458                 /* @rq->elv.icq holds io_context until @rq is freed */
1459                 if (icq)
1460                         get_io_context(icq->ioc);
1461         }
1462 out:
1463         /*
1464          * ioc may be NULL here, and ioc_batching will be false. That's
1465          * OK, if the queue is under the request limit then requests need
1466          * not count toward the nr_batch_requests limit. There will always
1467          * be some limit enforced by BLK_BATCH_TIME.
1468          */
1469         if (ioc_batching(q, ioc))
1470                 ioc->nr_batch_requests--;
1471
1472         trace_block_getrq(q, bio, op);
1473         return rq;
1474
1475 fail_elvpriv:
1476         /*
1477          * elvpriv init failed.  ioc, icq and elvpriv aren't mempool backed
1478          * and may fail indefinitely under memory pressure and thus
1479          * shouldn't stall IO.  Treat this request as !elvpriv.  This will
1480          * disturb iosched and blkcg but weird is bettern than dead.
1481          */
1482         printk_ratelimited(KERN_WARNING "%s: dev %s: request aux data allocation failed, iosched may be disturbed\n",
1483                            __func__, dev_name(q->backing_dev_info->dev));
1484
1485         rq->rq_flags &= ~RQF_ELVPRIV;
1486         rq->elv.icq = NULL;
1487
1488         spin_lock_irq(q->queue_lock);
1489         q->nr_rqs_elvpriv--;
1490         spin_unlock_irq(q->queue_lock);
1491         goto out;
1492
1493 fail_alloc:
1494         /*
1495          * Allocation failed presumably due to memory. Undo anything we
1496          * might have messed up.
1497          *
1498          * Allocating task should really be put onto the front of the wait
1499          * queue, but this is pretty rare.
1500          */
1501         spin_lock_irq(q->queue_lock);
1502         freed_request(rl, is_sync, rq_flags);
1503
1504         /*
1505          * in the very unlikely event that allocation failed and no
1506          * requests for this direction was pending, mark us starved so that
1507          * freeing of a request in the other direction will notice
1508          * us. another possible fix would be to split the rq mempool into
1509          * READ and WRITE
1510          */
1511 rq_starved:
1512         if (unlikely(rl->count[is_sync] == 0))
1513                 rl->starved[is_sync] = 1;
1514         return ERR_PTR(-ENOMEM);
1515 }
1516
1517 /**
1518  * get_request - get a free request
1519  * @q: request_queue to allocate request from
1520  * @op: operation and flags
1521  * @bio: bio to allocate request for (can be %NULL)
1522  * @flags: BLK_MQ_REQ_* flags.
1523  * @gfp: allocator flags
1524  *
1525  * Get a free request from @q.  If %BLK_MQ_REQ_NOWAIT is set in @flags,
1526  * this function keeps retrying under memory pressure and fails iff @q is dead.
1527  *
1528  * Must be called with @q->queue_lock held and,
1529  * Returns ERR_PTR on failure, with @q->queue_lock held.
1530  * Returns request pointer on success, with @q->queue_lock *not held*.
1531  */
1532 static struct request *get_request(struct request_queue *q, unsigned int op,
1533                 struct bio *bio, blk_mq_req_flags_t flags, gfp_t gfp)
1534 {
1535         const bool is_sync = op_is_sync(op);
1536         DEFINE_WAIT(wait);
1537         struct request_list *rl;
1538         struct request *rq;
1539
1540         lockdep_assert_held(q->queue_lock);
1541         WARN_ON_ONCE(q->mq_ops);
1542
1543         rl = blk_get_rl(q, bio);        /* transferred to @rq on success */
1544 retry:
1545         rq = __get_request(rl, op, bio, flags, gfp);
1546         if (!IS_ERR(rq))
1547                 return rq;
1548
1549         if (op & REQ_NOWAIT) {
1550                 blk_put_rl(rl);
1551                 return ERR_PTR(-EAGAIN);
1552         }
1553
1554         if ((flags & BLK_MQ_REQ_NOWAIT) || unlikely(blk_queue_dying(q))) {
1555                 blk_put_rl(rl);
1556                 return rq;
1557         }
1558
1559         /* wait on @rl and retry */
1560         prepare_to_wait_exclusive(&rl->wait[is_sync], &wait,
1561                                   TASK_UNINTERRUPTIBLE);
1562
1563         trace_block_sleeprq(q, bio, op);
1564
1565         spin_unlock_irq(q->queue_lock);
1566         io_schedule();
1567
1568         /*
1569          * After sleeping, we become a "batching" process and will be able
1570          * to allocate at least one request, and up to a big batch of them
1571          * for a small period time.  See ioc_batching, ioc_set_batching
1572          */
1573         ioc_set_batching(q, current->io_context);
1574
1575         spin_lock_irq(q->queue_lock);
1576         finish_wait(&rl->wait[is_sync], &wait);
1577
1578         goto retry;
1579 }
1580
1581 /* flags: BLK_MQ_REQ_PREEMPT and/or BLK_MQ_REQ_NOWAIT. */
1582 static struct request *blk_old_get_request(struct request_queue *q,
1583                                 unsigned int op, blk_mq_req_flags_t flags)
1584 {
1585         struct request *rq;
1586         gfp_t gfp_mask = flags & BLK_MQ_REQ_NOWAIT ? GFP_ATOMIC : GFP_NOIO;
1587         int ret = 0;
1588
1589         WARN_ON_ONCE(q->mq_ops);
1590
1591         /* create ioc upfront */
1592         create_io_context(gfp_mask, q->node);
1593
1594         ret = blk_queue_enter(q, flags);
1595         if (ret)
1596                 return ERR_PTR(ret);
1597         spin_lock_irq(q->queue_lock);
1598         rq = get_request(q, op, NULL, flags, gfp_mask);
1599         if (IS_ERR(rq)) {
1600                 spin_unlock_irq(q->queue_lock);
1601                 blk_queue_exit(q);
1602                 return rq;
1603         }
1604
1605         /* q->queue_lock is unlocked at this point */
1606         rq->__data_len = 0;
1607         rq->__sector = (sector_t) -1;
1608         rq->bio = rq->biotail = NULL;
1609         return rq;
1610 }
1611
1612 /**
1613  * blk_get_request - allocate a request
1614  * @q: request queue to allocate a request for
1615  * @op: operation (REQ_OP_*) and REQ_* flags, e.g. REQ_SYNC.
1616  * @flags: BLK_MQ_REQ_* flags, e.g. BLK_MQ_REQ_NOWAIT.
1617  */
1618 struct request *blk_get_request(struct request_queue *q, unsigned int op,
1619                                 blk_mq_req_flags_t flags)
1620 {
1621         struct request *req;
1622
1623         WARN_ON_ONCE(op & REQ_NOWAIT);
1624         WARN_ON_ONCE(flags & ~(BLK_MQ_REQ_NOWAIT | BLK_MQ_REQ_PREEMPT));
1625
1626         if (q->mq_ops) {
1627                 req = blk_mq_alloc_request(q, op, flags);
1628                 if (!IS_ERR(req) && q->mq_ops->initialize_rq_fn)
1629                         q->mq_ops->initialize_rq_fn(req);
1630         } else {
1631                 req = blk_old_get_request(q, op, flags);
1632                 if (!IS_ERR(req) && q->initialize_rq_fn)
1633                         q->initialize_rq_fn(req);
1634         }
1635
1636         return req;
1637 }
1638 EXPORT_SYMBOL(blk_get_request);
1639
1640 /**
1641  * blk_requeue_request - put a request back on queue
1642  * @q:          request queue where request should be inserted
1643  * @rq:         request to be inserted
1644  *
1645  * Description:
1646  *    Drivers often keep queueing requests until the hardware cannot accept
1647  *    more, when that condition happens we need to put the request back
1648  *    on the queue. Must be called with queue lock held.
1649  */
1650 void blk_requeue_request(struct request_queue *q, struct request *rq)
1651 {
1652         lockdep_assert_held(q->queue_lock);
1653         WARN_ON_ONCE(q->mq_ops);
1654
1655         blk_delete_timer(rq);
1656         blk_clear_rq_complete(rq);
1657         trace_block_rq_requeue(q, rq);
1658         rq_qos_requeue(q, rq);
1659
1660         if (rq->rq_flags & RQF_QUEUED)
1661                 blk_queue_end_tag(q, rq);
1662
1663         BUG_ON(blk_queued_rq(rq));
1664
1665         elv_requeue_request(q, rq);
1666 }
1667 EXPORT_SYMBOL(blk_requeue_request);
1668
1669 static void add_acct_request(struct request_queue *q, struct request *rq,
1670                              int where)
1671 {
1672         blk_account_io_start(rq, true);
1673         __elv_add_request(q, rq, where);
1674 }
1675
1676 static void part_round_stats_single(struct request_queue *q, int cpu,
1677                                     struct hd_struct *part, unsigned long now,
1678                                     unsigned int inflight)
1679 {
1680         if (inflight) {
1681                 __part_stat_add(cpu, part, time_in_queue,
1682                                 inflight * (now - part->stamp));
1683                 __part_stat_add(cpu, part, io_ticks, (now - part->stamp));
1684         }
1685         part->stamp = now;
1686 }
1687
1688 /**
1689  * part_round_stats() - Round off the performance stats on a struct disk_stats.
1690  * @q: target block queue
1691  * @cpu: cpu number for stats access
1692  * @part: target partition
1693  *
1694  * The average IO queue length and utilisation statistics are maintained
1695  * by observing the current state of the queue length and the amount of
1696  * time it has been in this state for.
1697  *
1698  * Normally, that accounting is done on IO completion, but that can result
1699  * in more than a second's worth of IO being accounted for within any one
1700  * second, leading to >100% utilisation.  To deal with that, we call this
1701  * function to do a round-off before returning the results when reading
1702  * /proc/diskstats.  This accounts immediately for all queue usage up to
1703  * the current jiffies and restarts the counters again.
1704  */
1705 void part_round_stats(struct request_queue *q, int cpu, struct hd_struct *part)
1706 {
1707         struct hd_struct *part2 = NULL;
1708         unsigned long now = jiffies;
1709         unsigned int inflight[2];
1710         int stats = 0;
1711
1712         if (part->stamp != now)
1713                 stats |= 1;
1714
1715         if (part->partno) {
1716                 part2 = &part_to_disk(part)->part0;
1717                 if (part2->stamp != now)
1718                         stats |= 2;
1719         }
1720
1721         if (!stats)
1722                 return;
1723
1724         part_in_flight(q, part, inflight);
1725
1726         if (stats & 2)
1727                 part_round_stats_single(q, cpu, part2, now, inflight[1]);
1728         if (stats & 1)
1729                 part_round_stats_single(q, cpu, part, now, inflight[0]);
1730 }
1731 EXPORT_SYMBOL_GPL(part_round_stats);
1732
1733 void __blk_put_request(struct request_queue *q, struct request *req)
1734 {
1735         req_flags_t rq_flags = req->rq_flags;
1736
1737         if (unlikely(!q))
1738                 return;
1739
1740         if (q->mq_ops) {
1741                 blk_mq_free_request(req);
1742                 return;
1743         }
1744
1745         lockdep_assert_held(q->queue_lock);
1746
1747         blk_req_zone_write_unlock(req);
1748         blk_pm_put_request(req);
1749         blk_pm_mark_last_busy(req);
1750
1751         elv_completed_request(q, req);
1752
1753         /* this is a bio leak */
1754         WARN_ON(req->bio != NULL);
1755
1756         rq_qos_done(q, req);
1757
1758         /*
1759          * Request may not have originated from ll_rw_blk. if not,
1760          * it didn't come out of our reserved rq pools
1761          */
1762         if (rq_flags & RQF_ALLOCED) {
1763                 struct request_list *rl = blk_rq_rl(req);
1764                 bool sync = op_is_sync(req->cmd_flags);
1765
1766                 BUG_ON(!list_empty(&req->queuelist));
1767                 BUG_ON(ELV_ON_HASH(req));
1768
1769                 blk_free_request(rl, req);
1770                 freed_request(rl, sync, rq_flags);
1771                 blk_put_rl(rl);
1772                 blk_queue_exit(q);
1773         }
1774 }
1775 EXPORT_SYMBOL_GPL(__blk_put_request);
1776
1777 void blk_put_request(struct request *req)
1778 {
1779         struct request_queue *q = req->q;
1780
1781         if (q->mq_ops)
1782                 blk_mq_free_request(req);
1783         else {
1784                 unsigned long flags;
1785
1786                 spin_lock_irqsave(q->queue_lock, flags);
1787                 __blk_put_request(q, req);
1788                 spin_unlock_irqrestore(q->queue_lock, flags);
1789         }
1790 }
1791 EXPORT_SYMBOL(blk_put_request);
1792
1793 bool bio_attempt_back_merge(struct request_queue *q, struct request *req,
1794                             struct bio *bio)
1795 {
1796         const int ff = bio->bi_opf & REQ_FAILFAST_MASK;
1797
1798         if (!ll_back_merge_fn(q, req, bio))
1799                 return false;
1800
1801         trace_block_bio_backmerge(q, req, bio);
1802
1803         if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff)
1804                 blk_rq_set_mixed_merge(req);
1805
1806         req->biotail->bi_next = bio;
1807         req->biotail = bio;
1808         req->__data_len += bio->bi_iter.bi_size;
1809         req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));
1810
1811         blk_account_io_start(req, false);
1812         return true;
1813 }
1814
1815 bool bio_attempt_front_merge(struct request_queue *q, struct request *req,
1816                              struct bio *bio)
1817 {
1818         const int ff = bio->bi_opf & REQ_FAILFAST_MASK;
1819
1820         if (!ll_front_merge_fn(q, req, bio))
1821                 return false;
1822
1823         trace_block_bio_frontmerge(q, req, bio);
1824
1825         if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff)
1826                 blk_rq_set_mixed_merge(req);
1827
1828         bio->bi_next = req->bio;
1829         req->bio = bio;
1830
1831         req->__sector = bio->bi_iter.bi_sector;
1832         req->__data_len += bio->bi_iter.bi_size;
1833         req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));
1834
1835         blk_account_io_start(req, false);
1836         return true;
1837 }
1838
1839 bool bio_attempt_discard_merge(struct request_queue *q, struct request *req,
1840                 struct bio *bio)
1841 {
1842         unsigned short segments = blk_rq_nr_discard_segments(req);
1843
1844         if (segments >= queue_max_discard_segments(q))
1845                 goto no_merge;
1846         if (blk_rq_sectors(req) + bio_sectors(bio) >
1847             blk_rq_get_max_sectors(req, blk_rq_pos(req)))
1848                 goto no_merge;
1849
1850         req->biotail->bi_next = bio;
1851         req->biotail = bio;
1852         req->__data_len += bio->bi_iter.bi_size;
1853         req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));
1854         req->nr_phys_segments = segments + 1;
1855
1856         blk_account_io_start(req, false);
1857         return true;
1858 no_merge:
1859         req_set_nomerge(q, req);
1860         return false;
1861 }
1862
1863 /**
1864  * blk_attempt_plug_merge - try to merge with %current's plugged list
1865  * @q: request_queue new bio is being queued at
1866  * @bio: new bio being queued
1867  * @request_count: out parameter for number of traversed plugged requests
1868  * @same_queue_rq: pointer to &struct request that gets filled in when
1869  * another request associated with @q is found on the plug list
1870  * (optional, may be %NULL)
1871  *
1872  * Determine whether @bio being queued on @q can be merged with a request
1873  * on %current's plugged list.  Returns %true if merge was successful,
1874  * otherwise %false.
1875  *
1876  * Plugging coalesces IOs from the same issuer for the same purpose without
1877  * going through @q->queue_lock.  As such it's more of an issuing mechanism
1878  * than scheduling, and the request, while may have elvpriv data, is not
1879  * added on the elevator at this point.  In addition, we don't have
1880  * reliable access to the elevator outside queue lock.  Only check basic
1881  * merging parameters without querying the elevator.
1882  *
1883  * Caller must ensure !blk_queue_nomerges(q) beforehand.
1884  */
1885 bool blk_attempt_plug_merge(struct request_queue *q, struct bio *bio,
1886                             unsigned int *request_count,
1887                             struct request **same_queue_rq)
1888 {
1889         struct blk_plug *plug;
1890         struct request *rq;
1891         struct list_head *plug_list;
1892
1893         plug = current->plug;
1894         if (!plug)
1895                 return false;
1896         *request_count = 0;
1897
1898         if (q->mq_ops)
1899                 plug_list = &plug->mq_list;
1900         else
1901                 plug_list = &plug->list;
1902
1903         list_for_each_entry_reverse(rq, plug_list, queuelist) {
1904                 bool merged = false;
1905
1906                 if (rq->q == q) {
1907                         (*request_count)++;
1908                         /*
1909                          * Only blk-mq multiple hardware queues case checks the
1910                          * rq in the same queue, there should be only one such
1911                          * rq in a queue
1912                          **/
1913                         if (same_queue_rq)
1914                                 *same_queue_rq = rq;
1915                 }
1916
1917                 if (rq->q != q || !blk_rq_merge_ok(rq, bio))
1918                         continue;
1919
1920                 switch (blk_try_merge(rq, bio)) {
1921                 case ELEVATOR_BACK_MERGE:
1922                         merged = bio_attempt_back_merge(q, rq, bio);
1923                         break;
1924                 case ELEVATOR_FRONT_MERGE:
1925                         merged = bio_attempt_front_merge(q, rq, bio);
1926                         break;
1927                 case ELEVATOR_DISCARD_MERGE:
1928                         merged = bio_attempt_discard_merge(q, rq, bio);
1929                         break;
1930                 default:
1931                         break;
1932                 }
1933
1934                 if (merged)
1935                         return true;
1936         }
1937
1938         return false;
1939 }
1940
1941 unsigned int blk_plug_queued_count(struct request_queue *q)
1942 {
1943         struct blk_plug *plug;
1944         struct request *rq;
1945         struct list_head *plug_list;
1946         unsigned int ret = 0;
1947
1948         plug = current->plug;
1949         if (!plug)
1950                 goto out;
1951
1952         if (q->mq_ops)
1953                 plug_list = &plug->mq_list;
1954         else
1955                 plug_list = &plug->list;
1956
1957         list_for_each_entry(rq, plug_list, queuelist) {
1958                 if (rq->q == q)
1959                         ret++;
1960         }
1961 out:
1962         return ret;
1963 }
1964
1965 void blk_init_request_from_bio(struct request *req, struct bio *bio)
1966 {
1967         struct io_context *ioc = rq_ioc(bio);
1968
1969         if (bio->bi_opf & REQ_RAHEAD)
1970                 req->cmd_flags |= REQ_FAILFAST_MASK;
1971
1972         req->__sector = bio->bi_iter.bi_sector;
1973         if (ioprio_valid(bio_prio(bio)))
1974                 req->ioprio = bio_prio(bio);
1975         else if (ioc)
1976                 req->ioprio = ioc->ioprio;
1977         else
1978                 req->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0);
1979         req->write_hint = bio->bi_write_hint;
1980         blk_rq_bio_prep(req->q, req, bio);
1981 }
1982 EXPORT_SYMBOL_GPL(blk_init_request_from_bio);
1983
1984 static blk_qc_t blk_queue_bio(struct request_queue *q, struct bio *bio)
1985 {
1986         struct blk_plug *plug;
1987         int where = ELEVATOR_INSERT_SORT;
1988         struct request *req, *free;
1989         unsigned int request_count = 0;
1990
1991         /*
1992          * low level driver can indicate that it wants pages above a
1993          * certain limit bounced to low memory (ie for highmem, or even
1994          * ISA dma in theory)
1995          */
1996         blk_queue_bounce(q, &bio);
1997
1998         blk_queue_split(q, &bio);
1999
2000         if (!bio_integrity_prep(bio))
2001                 return BLK_QC_T_NONE;
2002
2003         if (op_is_flush(bio->bi_opf)) {
2004                 spin_lock_irq(q->queue_lock);
2005                 where = ELEVATOR_INSERT_FLUSH;
2006                 goto get_rq;
2007         }
2008
2009         /*
2010          * Check if we can merge with the plugged list before grabbing
2011          * any locks.
2012          */
2013         if (!blk_queue_nomerges(q)) {
2014                 if (blk_attempt_plug_merge(q, bio, &request_count, NULL))
2015                         return BLK_QC_T_NONE;
2016         } else
2017                 request_count = blk_plug_queued_count(q);
2018
2019         spin_lock_irq(q->queue_lock);
2020
2021         switch (elv_merge(q, &req, bio)) {
2022         case ELEVATOR_BACK_MERGE:
2023                 if (!bio_attempt_back_merge(q, req, bio))
2024                         break;
2025                 elv_bio_merged(q, req, bio);
2026                 free = attempt_back_merge(q, req);
2027                 if (free)
2028                         __blk_put_request(q, free);
2029                 else
2030                         elv_merged_request(q, req, ELEVATOR_BACK_MERGE);
2031                 goto out_unlock;
2032         case ELEVATOR_FRONT_MERGE:
2033                 if (!bio_attempt_front_merge(q, req, bio))
2034                         break;
2035                 elv_bio_merged(q, req, bio);
2036                 free = attempt_front_merge(q, req);
2037                 if (free)
2038                         __blk_put_request(q, free);
2039                 else
2040                         elv_merged_request(q, req, ELEVATOR_FRONT_MERGE);
2041                 goto out_unlock;
2042         default:
2043                 break;
2044         }
2045
2046 get_rq:
2047         rq_qos_throttle(q, bio, q->queue_lock);
2048
2049         /*
2050          * Grab a free request. This is might sleep but can not fail.
2051          * Returns with the queue unlocked.
2052          */
2053         blk_queue_enter_live(q);
2054         req = get_request(q, bio->bi_opf, bio, 0, GFP_NOIO);
2055         if (IS_ERR(req)) {
2056                 blk_queue_exit(q);
2057                 rq_qos_cleanup(q, bio);
2058                 if (PTR_ERR(req) == -ENOMEM)
2059                         bio->bi_status = BLK_STS_RESOURCE;
2060                 else
2061                         bio->bi_status = BLK_STS_IOERR;
2062                 bio_endio(bio);
2063                 goto out_unlock;
2064         }
2065
2066         rq_qos_track(q, req, bio);
2067
2068         /*
2069          * After dropping the lock and possibly sleeping here, our request
2070          * may now be mergeable after it had proven unmergeable (above).
2071          * We don't worry about that case for efficiency. It won't happen
2072          * often, and the elevators are able to handle it.
2073          */
2074         blk_init_request_from_bio(req, bio);
2075
2076         if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags))
2077                 req->cpu = raw_smp_processor_id();
2078
2079         plug = current->plug;
2080         if (plug) {
2081                 /*
2082                  * If this is the first request added after a plug, fire
2083                  * of a plug trace.
2084                  *
2085                  * @request_count may become stale because of schedule
2086                  * out, so check plug list again.
2087                  */
2088                 if (!request_count || list_empty(&plug->list))
2089                         trace_block_plug(q);
2090                 else {
2091                         struct request *last = list_entry_rq(plug->list.prev);
2092                         if (request_count >= BLK_MAX_REQUEST_COUNT ||
2093                             blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE) {
2094                                 blk_flush_plug_list(plug, false);
2095                                 trace_block_plug(q);
2096                         }
2097                 }
2098                 list_add_tail(&req->queuelist, &plug->list);
2099                 blk_account_io_start(req, true);
2100         } else {
2101                 spin_lock_irq(q->queue_lock);
2102                 add_acct_request(q, req, where);
2103                 __blk_run_queue(q);
2104 out_unlock:
2105                 spin_unlock_irq(q->queue_lock);
2106         }
2107
2108         return BLK_QC_T_NONE;
2109 }
2110
2111 static void handle_bad_sector(struct bio *bio, sector_t maxsector)
2112 {
2113         char b[BDEVNAME_SIZE];
2114
2115         printk(KERN_INFO "attempt to access beyond end of device\n");
2116         printk(KERN_INFO "%s: rw=%d, want=%Lu, limit=%Lu\n",
2117                         bio_devname(bio, b), bio->bi_opf,
2118                         (unsigned long long)bio_end_sector(bio),
2119                         (long long)maxsector);
2120 }
2121
2122 #ifdef CONFIG_FAIL_MAKE_REQUEST
2123
2124 static DECLARE_FAULT_ATTR(fail_make_request);
2125
2126 static int __init setup_fail_make_request(char *str)
2127 {
2128         return setup_fault_attr(&fail_make_request, str);
2129 }
2130 __setup("fail_make_request=", setup_fail_make_request);
2131
2132 static bool should_fail_request(struct hd_struct *part, unsigned int bytes)
2133 {
2134         return part->make_it_fail && should_fail(&fail_make_request, bytes);
2135 }
2136
2137 static int __init fail_make_request_debugfs(void)
2138 {
2139         struct dentry *dir = fault_create_debugfs_attr("fail_make_request",
2140                                                 NULL, &fail_make_request);
2141
2142         return PTR_ERR_OR_ZERO(dir);
2143 }
2144
2145 late_initcall(fail_make_request_debugfs);
2146
2147 #else /* CONFIG_FAIL_MAKE_REQUEST */
2148
2149 static inline bool should_fail_request(struct hd_struct *part,
2150                                         unsigned int bytes)
2151 {
2152         return false;
2153 }
2154
2155 #endif /* CONFIG_FAIL_MAKE_REQUEST */
2156
2157 static inline bool bio_check_ro(struct bio *bio, struct hd_struct *part)
2158 {
2159         const int op = bio_op(bio);
2160
2161         if (part->policy && op_is_write(op)) {
2162                 char b[BDEVNAME_SIZE];
2163
2164                 if (op_is_flush(bio->bi_opf) && !bio_sectors(bio))
2165                         return false;
2166
2167                 WARN_ONCE(1,
2168                        "generic_make_request: Trying to write "
2169                         "to read-only block-device %s (partno %d)\n",
2170                         bio_devname(bio, b), part->partno);
2171                 /* Older lvm-tools actually trigger this */
2172                 return false;
2173         }
2174
2175         return false;
2176 }
2177
2178 static noinline int should_fail_bio(struct bio *bio)
2179 {
2180         if (should_fail_request(&bio->bi_disk->part0, bio->bi_iter.bi_size))
2181                 return -EIO;
2182         return 0;
2183 }
2184 ALLOW_ERROR_INJECTION(should_fail_bio, ERRNO);
2185
2186 /*
2187  * Check whether this bio extends beyond the end of the device or partition.
2188  * This may well happen - the kernel calls bread() without checking the size of
2189  * the device, e.g., when mounting a file system.
2190  */
2191 static inline int bio_check_eod(struct bio *bio, sector_t maxsector)
2192 {
2193         unsigned int nr_sectors = bio_sectors(bio);
2194
2195         if (nr_sectors && maxsector &&
2196             (nr_sectors > maxsector ||
2197              bio->bi_iter.bi_sector > maxsector - nr_sectors)) {
2198                 handle_bad_sector(bio, maxsector);
2199                 return -EIO;
2200         }
2201         return 0;
2202 }
2203
2204 /*
2205  * Remap block n of partition p to block n+start(p) of the disk.
2206  */
2207 static inline int blk_partition_remap(struct bio *bio)
2208 {
2209         struct hd_struct *p;
2210         int ret = -EIO;
2211
2212         rcu_read_lock();
2213         p = __disk_get_part(bio->bi_disk, bio->bi_partno);
2214         if (unlikely(!p))
2215                 goto out;
2216         if (unlikely(should_fail_request(p, bio->bi_iter.bi_size)))
2217                 goto out;
2218         if (unlikely(bio_check_ro(bio, p)))
2219                 goto out;
2220
2221         /*
2222          * Zone reset does not include bi_size so bio_sectors() is always 0.
2223          * Include a test for the reset op code and perform the remap if needed.
2224          */
2225         if (bio_sectors(bio) || bio_op(bio) == REQ_OP_ZONE_RESET) {
2226                 if (bio_check_eod(bio, part_nr_sects_read(p)))
2227                         goto out;
2228                 bio->bi_iter.bi_sector += p->start_sect;
2229                 trace_block_bio_remap(bio->bi_disk->queue, bio, part_devt(p),
2230                                       bio->bi_iter.bi_sector - p->start_sect);
2231         }
2232         bio->bi_partno = 0;
2233         ret = 0;
2234 out:
2235         rcu_read_unlock();
2236         return ret;
2237 }
2238
2239 static noinline_for_stack bool
2240 generic_make_request_checks(struct bio *bio)
2241 {
2242         struct request_queue *q;
2243         int nr_sectors = bio_sectors(bio);
2244         blk_status_t status = BLK_STS_IOERR;
2245         char b[BDEVNAME_SIZE];
2246
2247         might_sleep();
2248
2249         q = bio->bi_disk->queue;
2250         if (unlikely(!q)) {
2251                 printk(KERN_ERR
2252                        "generic_make_request: Trying to access "
2253                         "nonexistent block-device %s (%Lu)\n",
2254                         bio_devname(bio, b), (long long)bio->bi_iter.bi_sector);
2255                 goto end_io;
2256         }
2257
2258         /*
2259          * For a REQ_NOWAIT based request, return -EOPNOTSUPP
2260          * if queue is not a request based queue.
2261          */
2262         if ((bio->bi_opf & REQ_NOWAIT) && !queue_is_rq_based(q))
2263                 goto not_supported;
2264
2265         if (should_fail_bio(bio))
2266                 goto end_io;
2267
2268         if (bio->bi_partno) {
2269                 if (unlikely(blk_partition_remap(bio)))
2270                         goto end_io;
2271         } else {
2272                 if (unlikely(bio_check_ro(bio, &bio->bi_disk->part0)))
2273                         goto end_io;
2274                 if (unlikely(bio_check_eod(bio, get_capacity(bio->bi_disk))))
2275                         goto end_io;
2276         }
2277
2278         /*
2279          * Filter flush bio's early so that make_request based
2280          * drivers without flush support don't have to worry
2281          * about them.
2282          */
2283         if (op_is_flush(bio->bi_opf) &&
2284             !test_bit(QUEUE_FLAG_WC, &q->queue_flags)) {
2285                 bio->bi_opf &= ~(REQ_PREFLUSH | REQ_FUA);
2286                 if (!nr_sectors) {
2287                         status = BLK_STS_OK;
2288                         goto end_io;
2289                 }
2290         }
2291
2292         switch (bio_op(bio)) {
2293         case REQ_OP_DISCARD:
2294                 if (!blk_queue_discard(q))
2295                         goto not_supported;
2296                 break;
2297         case REQ_OP_SECURE_ERASE:
2298                 if (!blk_queue_secure_erase(q))
2299                         goto not_supported;
2300                 break;
2301         case REQ_OP_WRITE_SAME:
2302                 if (!q->limits.max_write_same_sectors)
2303                         goto not_supported;
2304                 break;
2305         case REQ_OP_ZONE_RESET:
2306                 if (!blk_queue_is_zoned(q))
2307                         goto not_supported;
2308                 break;
2309         case REQ_OP_WRITE_ZEROES:
2310                 if (!q->limits.max_write_zeroes_sectors)
2311                         goto not_supported;
2312                 break;
2313         default:
2314                 break;
2315         }
2316
2317         /*
2318          * Various block parts want %current->io_context and lazy ioc
2319          * allocation ends up trading a lot of pain for a small amount of
2320          * memory.  Just allocate it upfront.  This may fail and block
2321          * layer knows how to live with it.
2322          */
2323         create_io_context(GFP_ATOMIC, q->node);
2324
2325         if (!blkcg_bio_issue_check(q, bio))
2326                 return false;
2327
2328         if (!bio_flagged(bio, BIO_TRACE_COMPLETION)) {
2329                 trace_block_bio_queue(q, bio);
2330                 /* Now that enqueuing has been traced, we need to trace
2331                  * completion as well.
2332                  */
2333                 bio_set_flag(bio, BIO_TRACE_COMPLETION);
2334         }
2335         return true;
2336
2337 not_supported:
2338         status = BLK_STS_NOTSUPP;
2339 end_io:
2340         bio->bi_status = status;
2341         bio_endio(bio);
2342         return false;
2343 }
2344
2345 /**
2346  * generic_make_request - hand a buffer to its device driver for I/O
2347  * @bio:  The bio describing the location in memory and on the device.
2348  *
2349  * generic_make_request() is used to make I/O requests of block
2350  * devices. It is passed a &struct bio, which describes the I/O that needs
2351  * to be done.
2352  *
2353  * generic_make_request() does not return any status.  The
2354  * success/failure status of the request, along with notification of
2355  * completion, is delivered asynchronously through the bio->bi_end_io
2356  * function described (one day) else where.
2357  *
2358  * The caller of generic_make_request must make sure that bi_io_vec
2359  * are set to describe the memory buffer, and that bi_dev and bi_sector are
2360  * set to describe the device address, and the
2361  * bi_end_io and optionally bi_private are set to describe how
2362  * completion notification should be signaled.
2363  *
2364  * generic_make_request and the drivers it calls may use bi_next if this
2365  * bio happens to be merged with someone else, and may resubmit the bio to
2366  * a lower device by calling into generic_make_request recursively, which
2367  * means the bio should NOT be touched after the call to ->make_request_fn.
2368  */
2369 blk_qc_t generic_make_request(struct bio *bio)
2370 {
2371         /*
2372          * bio_list_on_stack[0] contains bios submitted by the current
2373          * make_request_fn.
2374          * bio_list_on_stack[1] contains bios that were submitted before
2375          * the current make_request_fn, but that haven't been processed
2376          * yet.
2377          */
2378         struct bio_list bio_list_on_stack[2];
2379         blk_mq_req_flags_t flags = 0;
2380         struct request_queue *q = bio->bi_disk->queue;
2381         blk_qc_t ret = BLK_QC_T_NONE;
2382
2383         if (bio->bi_opf & REQ_NOWAIT)
2384                 flags = BLK_MQ_REQ_NOWAIT;
2385         if (bio_flagged(bio, BIO_QUEUE_ENTERED))
2386                 blk_queue_enter_live(q);
2387         else if (blk_queue_enter(q, flags) < 0) {
2388                 if (!blk_queue_dying(q) && (bio->bi_opf & REQ_NOWAIT))
2389                         bio_wouldblock_error(bio);
2390                 else
2391                         bio_io_error(bio);
2392                 return ret;
2393         }
2394
2395         if (!generic_make_request_checks(bio))
2396                 goto out;
2397
2398         /*
2399          * We only want one ->make_request_fn to be active at a time, else
2400          * stack usage with stacked devices could be a problem.  So use
2401          * current->bio_list to keep a list of requests submited by a
2402          * make_request_fn function.  current->bio_list is also used as a
2403          * flag to say if generic_make_request is currently active in this
2404          * task or not.  If it is NULL, then no make_request is active.  If
2405          * it is non-NULL, then a make_request is active, and new requests
2406          * should be added at the tail
2407          */
2408         if (current->bio_list) {
2409                 bio_list_add(&current->bio_list[0], bio);
2410                 goto out;
2411         }
2412
2413         /* following loop may be a bit non-obvious, and so deserves some
2414          * explanation.
2415          * Before entering the loop, bio->bi_next is NULL (as all callers
2416          * ensure that) so we have a list with a single bio.
2417          * We pretend that we have just taken it off a longer list, so
2418          * we assign bio_list to a pointer to the bio_list_on_stack,
2419          * thus initialising the bio_list of new bios to be
2420          * added.  ->make_request() may indeed add some more bios
2421          * through a recursive call to generic_make_request.  If it
2422          * did, we find a non-NULL value in bio_list and re-enter the loop
2423          * from the top.  In this case we really did just take the bio
2424          * of the top of the list (no pretending) and so remove it from
2425          * bio_list, and call into ->make_request() again.
2426          */
2427         BUG_ON(bio->bi_next);
2428         bio_list_init(&bio_list_on_stack[0]);
2429         current->bio_list = bio_list_on_stack;
2430         do {
2431                 bool enter_succeeded = true;
2432
2433                 if (unlikely(q != bio->bi_disk->queue)) {
2434                         if (q)
2435                                 blk_queue_exit(q);
2436                         q = bio->bi_disk->queue;
2437                         flags = 0;
2438                         if (bio->bi_opf & REQ_NOWAIT)
2439                                 flags = BLK_MQ_REQ_NOWAIT;
2440                         if (blk_queue_enter(q, flags) < 0) {
2441                                 enter_succeeded = false;
2442                                 q = NULL;
2443                         }
2444                 }
2445
2446                 if (enter_succeeded) {
2447                         struct bio_list lower, same;
2448
2449                         /* Create a fresh bio_list for all subordinate requests */
2450                         bio_list_on_stack[1] = bio_list_on_stack[0];
2451                         bio_list_init(&bio_list_on_stack[0]);
2452                         ret = q->make_request_fn(q, bio);
2453
2454                         /* sort new bios into those for a lower level
2455                          * and those for the same level
2456                          */
2457                         bio_list_init(&lower);
2458                         bio_list_init(&same);
2459                         while ((bio = bio_list_pop(&bio_list_on_stack[0])) != NULL)
2460                                 if (q == bio->bi_disk->queue)
2461                                         bio_list_add(&same, bio);
2462                                 else
2463                                         bio_list_add(&lower, bio);
2464                         /* now assemble so we handle the lowest level first */
2465                         bio_list_merge(&bio_list_on_stack[0], &lower);
2466                         bio_list_merge(&bio_list_on_stack[0], &same);
2467                         bio_list_merge(&bio_list_on_stack[0], &bio_list_on_stack[1]);
2468                 } else {
2469                         if (unlikely(!blk_queue_dying(q) &&
2470                                         (bio->bi_opf & REQ_NOWAIT)))
2471                                 bio_wouldblock_error(bio);
2472                         else
2473                                 bio_io_error(bio);
2474                 }
2475                 bio = bio_list_pop(&bio_list_on_stack[0]);
2476         } while (bio);
2477         current->bio_list = NULL; /* deactivate */
2478
2479 out:
2480         if (q)
2481                 blk_queue_exit(q);
2482         return ret;
2483 }
2484 EXPORT_SYMBOL(generic_make_request);
2485
2486 /**
2487  * direct_make_request - hand a buffer directly to its device driver for I/O
2488  * @bio:  The bio describing the location in memory and on the device.
2489  *
2490  * This function behaves like generic_make_request(), but does not protect
2491  * against recursion.  Must only be used if the called driver is known
2492  * to not call generic_make_request (or direct_make_request) again from
2493  * its make_request function.  (Calling direct_make_request again from
2494  * a workqueue is perfectly fine as that doesn't recurse).
2495  */
2496 blk_qc_t direct_make_request(struct bio *bio)
2497 {
2498         struct request_queue *q = bio->bi_disk->queue;
2499         bool nowait = bio->bi_opf & REQ_NOWAIT;
2500         blk_qc_t ret;
2501
2502         if (!generic_make_request_checks(bio))
2503                 return BLK_QC_T_NONE;
2504
2505         if (unlikely(blk_queue_enter(q, nowait ? BLK_MQ_REQ_NOWAIT : 0))) {
2506                 if (nowait && !blk_queue_dying(q))
2507                         bio->bi_status = BLK_STS_AGAIN;
2508                 else
2509                         bio->bi_status = BLK_STS_IOERR;
2510                 bio_endio(bio);
2511                 return BLK_QC_T_NONE;
2512         }
2513
2514         ret = q->make_request_fn(q, bio);
2515         blk_queue_exit(q);
2516         return ret;
2517 }
2518 EXPORT_SYMBOL_GPL(direct_make_request);
2519
2520 /**
2521  * submit_bio - submit a bio to the block device layer for I/O
2522  * @bio: The &struct bio which describes the I/O
2523  *
2524  * submit_bio() is very similar in purpose to generic_make_request(), and
2525  * uses that function to do most of the work. Both are fairly rough
2526  * interfaces; @bio must be presetup and ready for I/O.
2527  *
2528  */
2529 blk_qc_t submit_bio(struct bio *bio)
2530 {
2531         /*
2532          * If it's a regular read/write or a barrier with data attached,
2533          * go through the normal accounting stuff before submission.
2534          */
2535         if (bio_has_data(bio)) {
2536                 unsigned int count;
2537
2538                 if (unlikely(bio_op(bio) == REQ_OP_WRITE_SAME))
2539                         count = queue_logical_block_size(bio->bi_disk->queue) >> 9;
2540                 else
2541                         count = bio_sectors(bio);
2542
2543                 if (op_is_write(bio_op(bio))) {
2544                         count_vm_events(PGPGOUT, count);
2545                 } else {
2546                         task_io_account_read(bio->bi_iter.bi_size);
2547                         count_vm_events(PGPGIN, count);
2548                 }
2549
2550                 if (unlikely(block_dump)) {
2551                         char b[BDEVNAME_SIZE];
2552                         printk(KERN_DEBUG "%s(%d): %s block %Lu on %s (%u sectors)\n",
2553                         current->comm, task_pid_nr(current),
2554                                 op_is_write(bio_op(bio)) ? "WRITE" : "READ",
2555                                 (unsigned long long)bio->bi_iter.bi_sector,
2556                                 bio_devname(bio, b), count);
2557                 }
2558         }
2559
2560         return generic_make_request(bio);
2561 }
2562 EXPORT_SYMBOL(submit_bio);
2563
2564 bool blk_poll(struct request_queue *q, blk_qc_t cookie)
2565 {
2566         if (!q->poll_fn || !blk_qc_t_valid(cookie))
2567                 return false;
2568
2569         if (current->plug)
2570                 blk_flush_plug_list(current->plug, false);
2571         return q->poll_fn(q, cookie);
2572 }
2573 EXPORT_SYMBOL_GPL(blk_poll);
2574
2575 /**
2576  * blk_cloned_rq_check_limits - Helper function to check a cloned request
2577  *                              for new the queue limits
2578  * @q:  the queue
2579  * @rq: the request being checked
2580  *
2581  * Description:
2582  *    @rq may have been made based on weaker limitations of upper-level queues
2583  *    in request stacking drivers, and it may violate the limitation of @q.
2584  *    Since the block layer and the underlying device driver trust @rq
2585  *    after it is inserted to @q, it should be checked against @q before
2586  *    the insertion using this generic function.
2587  *
2588  *    Request stacking drivers like request-based dm may change the queue
2589  *    limits when retrying requests on other queues. Those requests need
2590  *    to be checked against the new queue limits again during dispatch.
2591  */
2592 static int blk_cloned_rq_check_limits(struct request_queue *q,
2593                                       struct request *rq)
2594 {
2595         if (blk_rq_sectors(rq) > blk_queue_get_max_sectors(q, req_op(rq))) {
2596                 printk(KERN_ERR "%s: over max size limit.\n", __func__);
2597                 return -EIO;
2598         }
2599
2600         /*
2601          * queue's settings related to segment counting like q->bounce_pfn
2602          * may differ from that of other stacking queues.
2603          * Recalculate it to check the request correctly on this queue's
2604          * limitation.
2605          */
2606         blk_recalc_rq_segments(rq);
2607         if (rq->nr_phys_segments > queue_max_segments(q)) {
2608                 printk(KERN_ERR "%s: over max segments limit.\n", __func__);
2609                 return -EIO;
2610         }
2611
2612         return 0;
2613 }
2614
2615 /**
2616  * blk_insert_cloned_request - Helper for stacking drivers to submit a request
2617  * @q:  the queue to submit the request
2618  * @rq: the request being queued
2619  */
2620 blk_status_t blk_insert_cloned_request(struct request_queue *q, struct request *rq)
2621 {
2622         unsigned long flags;
2623         int where = ELEVATOR_INSERT_BACK;
2624
2625         if (blk_cloned_rq_check_limits(q, rq))
2626                 return BLK_STS_IOERR;
2627
2628         if (rq->rq_disk &&
2629             should_fail_request(&rq->rq_disk->part0, blk_rq_bytes(rq)))
2630                 return BLK_STS_IOERR;
2631
2632         if (q->mq_ops) {
2633                 if (blk_queue_io_stat(q))
2634                         blk_account_io_start(rq, true);
2635                 /*
2636                  * Since we have a scheduler attached on the top device,
2637                  * bypass a potential scheduler on the bottom device for
2638                  * insert.
2639                  */
2640                 return blk_mq_request_issue_directly(rq);
2641         }
2642
2643         spin_lock_irqsave(q->queue_lock, flags);
2644         if (unlikely(blk_queue_dying(q))) {
2645                 spin_unlock_irqrestore(q->queue_lock, flags);
2646                 return BLK_STS_IOERR;
2647         }
2648
2649         /*
2650          * Submitting request must be dequeued before calling this function
2651          * because it will be linked to another request_queue
2652          */
2653         BUG_ON(blk_queued_rq(rq));
2654
2655         if (op_is_flush(rq->cmd_flags))
2656                 where = ELEVATOR_INSERT_FLUSH;
2657
2658         add_acct_request(q, rq, where);
2659         if (where == ELEVATOR_INSERT_FLUSH)
2660                 __blk_run_queue(q);
2661         spin_unlock_irqrestore(q->queue_lock, flags);
2662
2663         return BLK_STS_OK;
2664 }
2665 EXPORT_SYMBOL_GPL(blk_insert_cloned_request);
2666
2667 /**
2668  * blk_rq_err_bytes - determine number of bytes till the next failure boundary
2669  * @rq: request to examine
2670  *
2671  * Description:
2672  *     A request could be merge of IOs which require different failure
2673  *     handling.  This function determines the number of bytes which
2674  *     can be failed from the beginning of the request without
2675  *     crossing into area which need to be retried further.
2676  *
2677  * Return:
2678  *     The number of bytes to fail.
2679  */
2680 unsigned int blk_rq_err_bytes(const struct request *rq)
2681 {
2682         unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK;
2683         unsigned int bytes = 0;
2684         struct bio *bio;
2685
2686         if (!(rq->rq_flags & RQF_MIXED_MERGE))
2687                 return blk_rq_bytes(rq);
2688
2689         /*
2690          * Currently the only 'mixing' which can happen is between
2691          * different fastfail types.  We can safely fail portions
2692          * which have all the failfast bits that the first one has -
2693          * the ones which are at least as eager to fail as the first
2694          * one.
2695          */
2696         for (bio = rq->bio; bio; bio = bio->bi_next) {
2697                 if ((bio->bi_opf & ff) != ff)
2698                         break;
2699                 bytes += bio->bi_iter.bi_size;
2700         }
2701
2702         /* this could lead to infinite loop */
2703         BUG_ON(blk_rq_bytes(rq) && !bytes);
2704         return bytes;
2705 }
2706 EXPORT_SYMBOL_GPL(blk_rq_err_bytes);
2707
2708 void blk_account_io_completion(struct request *req, unsigned int bytes)
2709 {
2710         if (blk_do_io_stat(req)) {
2711                 const int sgrp = op_stat_group(req_op(req));
2712                 struct hd_struct *part;
2713                 int cpu;
2714
2715                 cpu = part_stat_lock();
2716                 part = req->part;
2717                 part_stat_add(cpu, part, sectors[sgrp], bytes >> 9);
2718                 part_stat_unlock();
2719         }
2720 }
2721
2722 void blk_account_io_done(struct request *req, u64 now)
2723 {
2724         /*
2725          * Account IO completion.  flush_rq isn't accounted as a
2726          * normal IO on queueing nor completion.  Accounting the
2727          * containing request is enough.
2728          */
2729         if (blk_do_io_stat(req) && !(req->rq_flags & RQF_FLUSH_SEQ)) {
2730                 const int sgrp = op_stat_group(req_op(req));
2731                 struct hd_struct *part;
2732                 int cpu;
2733
2734                 cpu = part_stat_lock();
2735                 part = req->part;
2736
2737                 part_stat_inc(cpu, part, ios[sgrp]);
2738                 part_stat_add(cpu, part, nsecs[sgrp], now - req->start_time_ns);
2739                 part_round_stats(req->q, cpu, part);
2740                 part_dec_in_flight(req->q, part, rq_data_dir(req));
2741
2742                 hd_struct_put(part);
2743                 part_stat_unlock();
2744         }
2745 }
2746
2747 void blk_account_io_start(struct request *rq, bool new_io)
2748 {
2749         struct hd_struct *part;
2750         int rw = rq_data_dir(rq);
2751         int cpu;
2752
2753         if (!blk_do_io_stat(rq))
2754                 return;
2755
2756         cpu = part_stat_lock();
2757
2758         if (!new_io) {
2759                 part = rq->part;
2760                 part_stat_inc(cpu, part, merges[rw]);
2761         } else {
2762                 part = disk_map_sector_rcu(rq->rq_disk, blk_rq_pos(rq));
2763                 if (!hd_struct_try_get(part)) {
2764                         /*
2765                          * The partition is already being removed,
2766                          * the request will be accounted on the disk only
2767                          *
2768                          * We take a reference on disk->part0 although that
2769                          * partition will never be deleted, so we can treat
2770                          * it as any other partition.
2771                          */
2772                         part = &rq->rq_disk->part0;
2773                         hd_struct_get(part);
2774                 }
2775                 part_round_stats(rq->q, cpu, part);
2776                 part_inc_in_flight(rq->q, part, rw);
2777                 rq->part = part;
2778         }
2779
2780         part_stat_unlock();
2781 }
2782
2783 static struct request *elv_next_request(struct request_queue *q)
2784 {
2785         struct request *rq;
2786         struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL);
2787
2788         WARN_ON_ONCE(q->mq_ops);
2789
2790         while (1) {
2791                 list_for_each_entry(rq, &q->queue_head, queuelist) {
2792 #ifdef CONFIG_PM
2793                         /*
2794                          * If a request gets queued in state RPM_SUSPENDED
2795                          * then that's a kernel bug.
2796                          */
2797                         WARN_ON_ONCE(q->rpm_status == RPM_SUSPENDED);
2798 #endif
2799                         return rq;
2800                 }
2801
2802                 /*
2803                  * Flush request is running and flush request isn't queueable
2804                  * in the drive, we can hold the queue till flush request is
2805                  * finished. Even we don't do this, driver can't dispatch next
2806                  * requests and will requeue them. And this can improve
2807                  * throughput too. For example, we have request flush1, write1,
2808                  * flush 2. flush1 is dispatched, then queue is hold, write1
2809                  * isn't inserted to queue. After flush1 is finished, flush2
2810                  * will be dispatched. Since disk cache is already clean,
2811                  * flush2 will be finished very soon, so looks like flush2 is
2812                  * folded to flush1.
2813                  * Since the queue is hold, a flag is set to indicate the queue
2814                  * should be restarted later. Please see flush_end_io() for
2815                  * details.
2816                  */
2817                 if (fq->flush_pending_idx != fq->flush_running_idx &&
2818                                 !queue_flush_queueable(q)) {
2819                         fq->flush_queue_delayed = 1;
2820                         return NULL;
2821                 }
2822                 if (unlikely(blk_queue_bypass(q)) ||
2823                     !q->elevator->type->ops.sq.elevator_dispatch_fn(q, 0))
2824                         return NULL;
2825         }
2826 }
2827
2828 /**
2829  * blk_peek_request - peek at the top of a request queue
2830  * @q: request queue to peek at
2831  *
2832  * Description:
2833  *     Return the request at the top of @q.  The returned request
2834  *     should be started using blk_start_request() before LLD starts
2835  *     processing it.
2836  *
2837  * Return:
2838  *     Pointer to the request at the top of @q if available.  Null
2839  *     otherwise.
2840  */
2841 struct request *blk_peek_request(struct request_queue *q)
2842 {
2843         struct request *rq;
2844         int ret;
2845
2846         lockdep_assert_held(q->queue_lock);
2847         WARN_ON_ONCE(q->mq_ops);
2848
2849         while ((rq = elv_next_request(q)) != NULL) {
2850                 if (!(rq->rq_flags & RQF_STARTED)) {
2851                         /*
2852                          * This is the first time the device driver
2853                          * sees this request (possibly after
2854                          * requeueing).  Notify IO scheduler.
2855                          */
2856                         if (rq->rq_flags & RQF_SORTED)
2857                                 elv_activate_rq(q, rq);
2858
2859                         /*
2860                          * just mark as started even if we don't start
2861                          * it, a request that has been delayed should
2862                          * not be passed by new incoming requests
2863                          */
2864                         rq->rq_flags |= RQF_STARTED;
2865                         trace_block_rq_issue(q, rq);
2866                 }
2867
2868                 if (!q->boundary_rq || q->boundary_rq == rq) {
2869                         q->end_sector = rq_end_sector(rq);
2870                         q->boundary_rq = NULL;
2871                 }
2872
2873                 if (rq->rq_flags & RQF_DONTPREP)
2874                         break;
2875
2876                 if (q->dma_drain_size && blk_rq_bytes(rq)) {
2877                         /*
2878                          * make sure space for the drain appears we
2879                          * know we can do this because max_hw_segments
2880                          * has been adjusted to be one fewer than the
2881                          * device can handle
2882                          */
2883                         rq->nr_phys_segments++;
2884                 }
2885
2886                 if (!q->prep_rq_fn)
2887                         break;
2888
2889                 ret = q->prep_rq_fn(q, rq);
2890                 if (ret == BLKPREP_OK) {
2891                         break;
2892                 } else if (ret == BLKPREP_DEFER) {
2893                         /*
2894                          * the request may have been (partially) prepped.
2895                          * we need to keep this request in the front to
2896                          * avoid resource deadlock.  RQF_STARTED will
2897                          * prevent other fs requests from passing this one.
2898                          */
2899                         if (q->dma_drain_size && blk_rq_bytes(rq) &&
2900                             !(rq->rq_flags & RQF_DONTPREP)) {
2901                                 /*
2902                                  * remove the space for the drain we added
2903                                  * so that we don't add it again
2904                                  */
2905                                 --rq->nr_phys_segments;
2906                         }
2907
2908                         rq = NULL;
2909                         break;
2910                 } else if (ret == BLKPREP_KILL || ret == BLKPREP_INVALID) {
2911                         rq->rq_flags |= RQF_QUIET;
2912                         /*
2913                          * Mark this request as started so we don't trigger
2914                          * any debug logic in the end I/O path.
2915                          */
2916                         blk_start_request(rq);
2917                         __blk_end_request_all(rq, ret == BLKPREP_INVALID ?
2918                                         BLK_STS_TARGET : BLK_STS_IOERR);
2919                 } else {
2920                         printk(KERN_ERR "%s: bad return=%d\n", __func__, ret);
2921                         break;
2922                 }
2923         }
2924
2925         return rq;
2926 }
2927 EXPORT_SYMBOL(blk_peek_request);
2928
2929 static void blk_dequeue_request(struct request *rq)
2930 {
2931         struct request_queue *q = rq->q;
2932
2933         BUG_ON(list_empty(&rq->queuelist));
2934         BUG_ON(ELV_ON_HASH(rq));
2935
2936         list_del_init(&rq->queuelist);
2937
2938         /*
2939          * the time frame between a request being removed from the lists
2940          * and to it is freed is accounted as io that is in progress at
2941          * the driver side.
2942          */
2943         if (blk_account_rq(rq))
2944                 q->in_flight[rq_is_sync(rq)]++;
2945 }
2946
2947 /**
2948  * blk_start_request - start request processing on the driver
2949  * @req: request to dequeue
2950  *
2951  * Description:
2952  *     Dequeue @req and start timeout timer on it.  This hands off the
2953  *     request to the driver.
2954  */
2955 void blk_start_request(struct request *req)
2956 {
2957         lockdep_assert_held(req->q->queue_lock);
2958         WARN_ON_ONCE(req->q->mq_ops);
2959
2960         blk_dequeue_request(req);
2961
2962         if (test_bit(QUEUE_FLAG_STATS, &req->q->queue_flags)) {
2963                 req->io_start_time_ns = ktime_get_ns();
2964 #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
2965                 req->throtl_size = blk_rq_sectors(req);
2966 #endif
2967                 req->rq_flags |= RQF_STATS;
2968                 rq_qos_issue(req->q, req);
2969         }
2970
2971         BUG_ON(blk_rq_is_complete(req));
2972         blk_add_timer(req);
2973 }
2974 EXPORT_SYMBOL(blk_start_request);
2975
2976 /**
2977  * blk_fetch_request - fetch a request from a request queue
2978  * @q: request queue to fetch a request from
2979  *
2980  * Description:
2981  *     Return the request at the top of @q.  The request is started on
2982  *     return and LLD can start processing it immediately.
2983  *
2984  * Return:
2985  *     Pointer to the request at the top of @q if available.  Null
2986  *     otherwise.
2987  */
2988 struct request *blk_fetch_request(struct request_queue *q)
2989 {
2990         struct request *rq;
2991
2992         lockdep_assert_held(q->queue_lock);
2993         WARN_ON_ONCE(q->mq_ops);
2994
2995         rq = blk_peek_request(q);
2996         if (rq)
2997                 blk_start_request(rq);
2998         return rq;
2999 }
3000 EXPORT_SYMBOL(blk_fetch_request);
3001
3002 /*
3003  * Steal bios from a request and add them to a bio list.
3004  * The request must not have been partially completed before.
3005  */
3006 void blk_steal_bios(struct bio_list *list, struct request *rq)
3007 {
3008         if (rq->bio) {
3009                 if (list->tail)
3010                         list->tail->bi_next = rq->bio;
3011                 else
3012                         list->head = rq->bio;
3013                 list->tail = rq->biotail;
3014
3015                 rq->bio = NULL;
3016                 rq->biotail = NULL;
3017         }
3018
3019         rq->__data_len = 0;
3020 }
3021 EXPORT_SYMBOL_GPL(blk_steal_bios);
3022
3023 /**
3024  * blk_update_request - Special helper function for request stacking drivers
3025  * @req:      the request being processed
3026  * @error:    block status code
3027  * @nr_bytes: number of bytes to complete @req
3028  *
3029  * Description:
3030  *     Ends I/O on a number of bytes attached to @req, but doesn't complete
3031  *     the request structure even if @req doesn't have leftover.
3032  *     If @req has leftover, sets it up for the next range of segments.
3033  *
3034  *     This special helper function is only for request stacking drivers
3035  *     (e.g. request-based dm) so that they can handle partial completion.
3036  *     Actual device drivers should use blk_end_request instead.
3037  *
3038  *     Passing the result of blk_rq_bytes() as @nr_bytes guarantees
3039  *     %false return from this function.
3040  *
3041  * Note:
3042  *      The RQF_SPECIAL_PAYLOAD flag is ignored on purpose in both
3043  *      blk_rq_bytes() and in blk_update_request().
3044  *
3045  * Return:
3046  *     %false - this request doesn't have any more data
3047  *     %true  - this request has more data
3048  **/
3049 bool blk_update_request(struct request *req, blk_status_t error,
3050                 unsigned int nr_bytes)
3051 {
3052         int total_bytes;
3053
3054         trace_block_rq_complete(req, blk_status_to_errno(error), nr_bytes);
3055
3056         if (!req->bio)
3057                 return false;
3058
3059         if (unlikely(error && !blk_rq_is_passthrough(req) &&
3060                      !(req->rq_flags & RQF_QUIET)))
3061                 print_req_error(req, error);
3062
3063         blk_account_io_completion(req, nr_bytes);
3064
3065         total_bytes = 0;
3066         while (req->bio) {
3067                 struct bio *bio = req->bio;
3068                 unsigned bio_bytes = min(bio->bi_iter.bi_size, nr_bytes);
3069
3070                 if (bio_bytes == bio->bi_iter.bi_size)
3071                         req->bio = bio->bi_next;
3072
3073                 /* Completion has already been traced */
3074                 bio_clear_flag(bio, BIO_TRACE_COMPLETION);
3075                 req_bio_endio(req, bio, bio_bytes, error);
3076
3077                 total_bytes += bio_bytes;
3078                 nr_bytes -= bio_bytes;
3079
3080                 if (!nr_bytes)
3081                         break;
3082         }
3083
3084         /*
3085          * completely done
3086          */
3087         if (!req->bio) {
3088                 /*
3089                  * Reset counters so that the request stacking driver
3090                  * can find how many bytes remain in the request
3091                  * later.
3092                  */
3093                 req->__data_len = 0;
3094                 return false;
3095         }
3096
3097         req->__data_len -= total_bytes;
3098
3099         /* update sector only for requests with clear definition of sector */
3100         if (!blk_rq_is_passthrough(req))
3101                 req->__sector += total_bytes >> 9;
3102
3103         /* mixed attributes always follow the first bio */
3104         if (req->rq_flags & RQF_MIXED_MERGE) {
3105                 req->cmd_flags &= ~REQ_FAILFAST_MASK;
3106                 req->cmd_flags |= req->bio->bi_opf & REQ_FAILFAST_MASK;
3107         }
3108
3109         if (!(req->rq_flags & RQF_SPECIAL_PAYLOAD)) {
3110                 /*
3111                  * If total number of sectors is less than the first segment
3112                  * size, something has gone terribly wrong.
3113                  */
3114                 if (blk_rq_bytes(req) < blk_rq_cur_bytes(req)) {
3115                         blk_dump_rq_flags(req, "request botched");
3116                         req->__data_len = blk_rq_cur_bytes(req);
3117                 }
3118
3119                 /* recalculate the number of segments */
3120                 blk_recalc_rq_segments(req);
3121         }
3122
3123         return true;
3124 }
3125 EXPORT_SYMBOL_GPL(blk_update_request);
3126
3127 static bool blk_update_bidi_request(struct request *rq, blk_status_t error,
3128                                     unsigned int nr_bytes,
3129                                     unsigned int bidi_bytes)
3130 {
3131         if (blk_update_request(rq, error, nr_bytes))
3132                 return true;
3133
3134         /* Bidi request must be completed as a whole */
3135         if (unlikely(blk_bidi_rq(rq)) &&
3136             blk_update_request(rq->next_rq, error, bidi_bytes))
3137                 return true;
3138
3139         if (blk_queue_add_random(rq->q))
3140                 add_disk_randomness(rq->rq_disk);
3141
3142         return false;
3143 }
3144
3145 /**
3146  * blk_unprep_request - unprepare a request
3147  * @req:        the request
3148  *
3149  * This function makes a request ready for complete resubmission (or
3150  * completion).  It happens only after all error handling is complete,
3151  * so represents the appropriate moment to deallocate any resources
3152  * that were allocated to the request in the prep_rq_fn.  The queue
3153  * lock is held when calling this.
3154  */
3155 void blk_unprep_request(struct request *req)
3156 {
3157         struct request_queue *q = req->q;
3158
3159         req->rq_flags &= ~RQF_DONTPREP;
3160         if (q->unprep_rq_fn)
3161                 q->unprep_rq_fn(q, req);
3162 }
3163 EXPORT_SYMBOL_GPL(blk_unprep_request);
3164
3165 void blk_finish_request(struct request *req, blk_status_t error)
3166 {
3167         struct request_queue *q = req->q;
3168         u64 now = ktime_get_ns();
3169
3170         lockdep_assert_held(req->q->queue_lock);
3171         WARN_ON_ONCE(q->mq_ops);
3172
3173         if (req->rq_flags & RQF_STATS)
3174                 blk_stat_add(req, now);
3175
3176         if (req->rq_flags & RQF_QUEUED)
3177                 blk_queue_end_tag(q, req);
3178
3179         BUG_ON(blk_queued_rq(req));
3180
3181         if (unlikely(laptop_mode) && !blk_rq_is_passthrough(req))
3182                 laptop_io_completion(req->q->backing_dev_info);
3183
3184         blk_delete_timer(req);
3185
3186         if (req->rq_flags & RQF_DONTPREP)
3187                 blk_unprep_request(req);
3188
3189         blk_account_io_done(req, now);
3190
3191         if (req->end_io) {
3192                 rq_qos_done(q, req);
3193                 req->end_io(req, error);
3194         } else {
3195                 if (blk_bidi_rq(req))
3196                         __blk_put_request(req->next_rq->q, req->next_rq);
3197
3198                 __blk_put_request(q, req);
3199         }
3200 }
3201 EXPORT_SYMBOL(blk_finish_request);
3202
3203 /**
3204  * blk_end_bidi_request - Complete a bidi request
3205  * @rq:         the request to complete
3206  * @error:      block status code
3207  * @nr_bytes:   number of bytes to complete @rq
3208  * @bidi_bytes: number of bytes to complete @rq->next_rq
3209  *
3210  * Description:
3211  *     Ends I/O on a number of bytes attached to @rq and @rq->next_rq.
3212  *     Drivers that supports bidi can safely call this member for any
3213  *     type of request, bidi or uni.  In the later case @bidi_bytes is
3214  *     just ignored.
3215  *
3216  * Return:
3217  *     %false - we are done with this request
3218  *     %true  - still buffers pending for this request
3219  **/
3220 static bool blk_end_bidi_request(struct request *rq, blk_status_t error,
3221                                  unsigned int nr_bytes, unsigned int bidi_bytes)
3222 {
3223         struct request_queue *q = rq->q;
3224         unsigned long flags;
3225
3226         WARN_ON_ONCE(q->mq_ops);
3227
3228         if (blk_update_bidi_request(rq, error, nr_bytes, bidi_bytes))
3229                 return true;
3230
3231         spin_lock_irqsave(q->queue_lock, flags);
3232         blk_finish_request(rq, error);
3233         spin_unlock_irqrestore(q->queue_lock, flags);
3234
3235         return false;
3236 }
3237
3238 /**
3239  * __blk_end_bidi_request - Complete a bidi request with queue lock held
3240  * @rq:         the request to complete
3241  * @error:      block status code
3242  * @nr_bytes:   number of bytes to complete @rq
3243  * @bidi_bytes: number of bytes to complete @rq->next_rq
3244  *
3245  * Description:
3246  *     Identical to blk_end_bidi_request() except that queue lock is
3247  *     assumed to be locked on entry and remains so on return.
3248  *
3249  * Return:
3250  *     %false - we are done with this request
3251  *     %true  - still buffers pending for this request
3252  **/
3253 static bool __blk_end_bidi_request(struct request *rq, blk_status_t error,
3254                                    unsigned int nr_bytes, unsigned int bidi_bytes)
3255 {
3256         lockdep_assert_held(rq->q->queue_lock);
3257         WARN_ON_ONCE(rq->q->mq_ops);
3258
3259         if (blk_update_bidi_request(rq, error, nr_bytes, bidi_bytes))
3260                 return true;
3261
3262         blk_finish_request(rq, error);
3263
3264         return false;
3265 }
3266
3267 /**
3268  * blk_end_request - Helper function for drivers to complete the request.
3269  * @rq:       the request being processed
3270  * @error:    block status code
3271  * @nr_bytes: number of bytes to complete
3272  *
3273  * Description:
3274  *     Ends I/O on a number of bytes attached to @rq.
3275  *     If @rq has leftover, sets it up for the next range of segments.
3276  *
3277  * Return:
3278  *     %false - we are done with this request
3279  *     %true  - still buffers pending for this request
3280  **/
3281 bool blk_end_request(struct request *rq, blk_status_t error,
3282                 unsigned int nr_bytes)
3283 {
3284         WARN_ON_ONCE(rq->q->mq_ops);
3285         return blk_end_bidi_request(rq, error, nr_bytes, 0);
3286 }
3287 EXPORT_SYMBOL(blk_end_request);
3288
3289 /**
3290  * blk_end_request_all - Helper function for drives to finish the request.
3291  * @rq: the request to finish
3292  * @error: block status code
3293  *
3294  * Description:
3295  *     Completely finish @rq.
3296  */
3297 void blk_end_request_all(struct request *rq, blk_status_t error)
3298 {
3299         bool pending;
3300         unsigned int bidi_bytes = 0;
3301
3302         if (unlikely(blk_bidi_rq(rq)))
3303                 bidi_bytes = blk_rq_bytes(rq->next_rq);
3304
3305         pending = blk_end_bidi_request(rq, error, blk_rq_bytes(rq), bidi_bytes);
3306         BUG_ON(pending);
3307 }
3308 EXPORT_SYMBOL(blk_end_request_all);
3309
3310 /**
3311  * __blk_end_request - Helper function for drivers to complete the request.
3312  * @rq:       the request being processed
3313  * @error:    block status code
3314  * @nr_bytes: number of bytes to complete
3315  *
3316  * Description:
3317  *     Must be called with queue lock held unlike blk_end_request().
3318  *
3319  * Return:
3320  *     %false - we are done with this request
3321  *     %true  - still buffers pending for this request
3322  **/
3323 bool __blk_end_request(struct request *rq, blk_status_t error,
3324                 unsigned int nr_bytes)
3325 {
3326         lockdep_assert_held(rq->q->queue_lock);
3327         WARN_ON_ONCE(rq->q->mq_ops);
3328
3329         return __blk_end_bidi_request(rq, error, nr_bytes, 0);
3330 }
3331 EXPORT_SYMBOL(__blk_end_request);
3332
3333 /**
3334  * __blk_end_request_all - Helper function for drives to finish the request.
3335  * @rq: the request to finish
3336  * @error:    block status code
3337  *
3338  * Description:
3339  *     Completely finish @rq.  Must be called with queue lock held.
3340  */
3341 void __blk_end_request_all(struct request *rq, blk_status_t error)
3342 {
3343         bool pending;
3344         unsigned int bidi_bytes = 0;
3345
3346         lockdep_assert_held(rq->q->queue_lock);
3347         WARN_ON_ONCE(rq->q->mq_ops);
3348
3349         if (unlikely(blk_bidi_rq(rq)))
3350                 bidi_bytes = blk_rq_bytes(rq->next_rq);
3351
3352         pending = __blk_end_bidi_request(rq, error, blk_rq_bytes(rq), bidi_bytes);
3353         BUG_ON(pending);
3354 }
3355 EXPORT_SYMBOL(__blk_end_request_all);
3356
3357 /**
3358  * __blk_end_request_cur - Helper function to finish the current request chunk.
3359  * @rq: the request to finish the current chunk for
3360  * @error:    block status code
3361  *
3362  * Description:
3363  *     Complete the current consecutively mapped chunk from @rq.  Must
3364  *     be called with queue lock held.
3365  *
3366  * Return:
3367  *     %false - we are done with this request
3368  *     %true  - still buffers pending for this request
3369  */
3370 bool __blk_end_request_cur(struct request *rq, blk_status_t error)
3371 {
3372         return __blk_end_request(rq, error, blk_rq_cur_bytes(rq));
3373 }
3374 EXPORT_SYMBOL(__blk_end_request_cur);
3375
3376 void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
3377                      struct bio *bio)
3378 {
3379         if (bio_has_data(bio))
3380                 rq->nr_phys_segments = bio_phys_segments(q, bio);
3381         else if (bio_op(bio) == REQ_OP_DISCARD)
3382                 rq->nr_phys_segments = 1;
3383
3384         rq->__data_len = bio->bi_iter.bi_size;
3385         rq->bio = rq->biotail = bio;
3386
3387         if (bio->bi_disk)
3388                 rq->rq_disk = bio->bi_disk;
3389 }
3390
3391 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
3392 /**
3393  * rq_flush_dcache_pages - Helper function to flush all pages in a request
3394  * @rq: the request to be flushed
3395  *
3396  * Description:
3397  *     Flush all pages in @rq.
3398  */
3399 void rq_flush_dcache_pages(struct request *rq)
3400 {
3401         struct req_iterator iter;
3402         struct bio_vec bvec;
3403
3404         rq_for_each_segment(bvec, rq, iter)
3405                 flush_dcache_page(bvec.bv_page);
3406 }
3407 EXPORT_SYMBOL_GPL(rq_flush_dcache_pages);
3408 #endif
3409
3410 /**
3411  * blk_lld_busy - Check if underlying low-level drivers of a device are busy