ce12515f9b9b9930da4515ed8f70a4cf5f5b946f
[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          * No need to quiesce queue if it isn't initialized yet since
802          * blk_freeze_queue() should be enough for cases of passthrough
803          * request.
804          */
805         if (q->mq_ops && blk_queue_init_done(q))
806                 blk_mq_quiesce_queue(q);
807
808         /* for synchronous bio-based driver finish in-flight integrity i/o */
809         blk_flush_integrity();
810
811         /* @q won't process any more request, flush async actions */
812         del_timer_sync(&q->backing_dev_info->laptop_mode_wb_timer);
813         blk_sync_queue(q);
814
815         /*
816          * I/O scheduler exit is only safe after the sysfs scheduler attribute
817          * has been removed.
818          */
819         WARN_ON_ONCE(q->kobj.state_in_sysfs);
820
821         blk_exit_queue(q);
822
823         if (q->mq_ops)
824                 blk_mq_free_queue(q);
825         percpu_ref_exit(&q->q_usage_counter);
826
827         spin_lock_irq(lock);
828         if (q->queue_lock != &q->__queue_lock)
829                 q->queue_lock = &q->__queue_lock;
830         spin_unlock_irq(lock);
831
832         /* @q is and will stay empty, shutdown and put */
833         blk_put_queue(q);
834 }
835 EXPORT_SYMBOL(blk_cleanup_queue);
836
837 /* Allocate memory local to the request queue */
838 static void *alloc_request_simple(gfp_t gfp_mask, void *data)
839 {
840         struct request_queue *q = data;
841
842         return kmem_cache_alloc_node(request_cachep, gfp_mask, q->node);
843 }
844
845 static void free_request_simple(void *element, void *data)
846 {
847         kmem_cache_free(request_cachep, element);
848 }
849
850 static void *alloc_request_size(gfp_t gfp_mask, void *data)
851 {
852         struct request_queue *q = data;
853         struct request *rq;
854
855         rq = kmalloc_node(sizeof(struct request) + q->cmd_size, gfp_mask,
856                         q->node);
857         if (rq && q->init_rq_fn && q->init_rq_fn(q, rq, gfp_mask) < 0) {
858                 kfree(rq);
859                 rq = NULL;
860         }
861         return rq;
862 }
863
864 static void free_request_size(void *element, void *data)
865 {
866         struct request_queue *q = data;
867
868         if (q->exit_rq_fn)
869                 q->exit_rq_fn(q, element);
870         kfree(element);
871 }
872
873 int blk_init_rl(struct request_list *rl, struct request_queue *q,
874                 gfp_t gfp_mask)
875 {
876         if (unlikely(rl->rq_pool) || q->mq_ops)
877                 return 0;
878
879         rl->q = q;
880         rl->count[BLK_RW_SYNC] = rl->count[BLK_RW_ASYNC] = 0;
881         rl->starved[BLK_RW_SYNC] = rl->starved[BLK_RW_ASYNC] = 0;
882         init_waitqueue_head(&rl->wait[BLK_RW_SYNC]);
883         init_waitqueue_head(&rl->wait[BLK_RW_ASYNC]);
884
885         if (q->cmd_size) {
886                 rl->rq_pool = mempool_create_node(BLKDEV_MIN_RQ,
887                                 alloc_request_size, free_request_size,
888                                 q, gfp_mask, q->node);
889         } else {
890                 rl->rq_pool = mempool_create_node(BLKDEV_MIN_RQ,
891                                 alloc_request_simple, free_request_simple,
892                                 q, gfp_mask, q->node);
893         }
894         if (!rl->rq_pool)
895                 return -ENOMEM;
896
897         if (rl != &q->root_rl)
898                 WARN_ON_ONCE(!blk_get_queue(q));
899
900         return 0;
901 }
902
903 void blk_exit_rl(struct request_queue *q, struct request_list *rl)
904 {
905         if (rl->rq_pool) {
906                 mempool_destroy(rl->rq_pool);
907                 if (rl != &q->root_rl)
908                         blk_put_queue(q);
909         }
910 }
911
912 struct request_queue *blk_alloc_queue(gfp_t gfp_mask)
913 {
914         return blk_alloc_queue_node(gfp_mask, NUMA_NO_NODE, NULL);
915 }
916 EXPORT_SYMBOL(blk_alloc_queue);
917
918 /**
919  * blk_queue_enter() - try to increase q->q_usage_counter
920  * @q: request queue pointer
921  * @flags: BLK_MQ_REQ_NOWAIT and/or BLK_MQ_REQ_PREEMPT
922  */
923 int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags)
924 {
925         const bool pm = flags & BLK_MQ_REQ_PREEMPT;
926
927         while (true) {
928                 bool success = false;
929
930                 rcu_read_lock();
931                 if (percpu_ref_tryget_live(&q->q_usage_counter)) {
932                         /*
933                          * The code that increments the pm_only counter is
934                          * responsible for ensuring that that counter is
935                          * globally visible before the queue is unfrozen.
936                          */
937                         if (pm || !blk_queue_pm_only(q)) {
938                                 success = true;
939                         } else {
940                                 percpu_ref_put(&q->q_usage_counter);
941                         }
942                 }
943                 rcu_read_unlock();
944
945                 if (success)
946                         return 0;
947
948                 if (flags & BLK_MQ_REQ_NOWAIT)
949                         return -EBUSY;
950
951                 /*
952                  * read pair of barrier in blk_freeze_queue_start(),
953                  * we need to order reading __PERCPU_REF_DEAD flag of
954                  * .q_usage_counter and reading .mq_freeze_depth or
955                  * queue dying flag, otherwise the following wait may
956                  * never return if the two reads are reordered.
957                  */
958                 smp_rmb();
959
960                 wait_event(q->mq_freeze_wq,
961                            (atomic_read(&q->mq_freeze_depth) == 0 &&
962                             (pm || (blk_pm_request_resume(q),
963                                     !blk_queue_pm_only(q)))) ||
964                            blk_queue_dying(q));
965                 if (blk_queue_dying(q))
966                         return -ENODEV;
967         }
968 }
969
970 void blk_queue_exit(struct request_queue *q)
971 {
972         percpu_ref_put(&q->q_usage_counter);
973 }
974
975 static void blk_queue_usage_counter_release(struct percpu_ref *ref)
976 {
977         struct request_queue *q =
978                 container_of(ref, struct request_queue, q_usage_counter);
979
980         wake_up_all(&q->mq_freeze_wq);
981 }
982
983 static void blk_rq_timed_out_timer(struct timer_list *t)
984 {
985         struct request_queue *q = from_timer(q, t, timeout);
986
987         kblockd_schedule_work(&q->timeout_work);
988 }
989
990 /**
991  * blk_alloc_queue_node - allocate a request queue
992  * @gfp_mask: memory allocation flags
993  * @node_id: NUMA node to allocate memory from
994  * @lock: For legacy queues, pointer to a spinlock that will be used to e.g.
995  *        serialize calls to the legacy .request_fn() callback. Ignored for
996  *        blk-mq request queues.
997  *
998  * Note: pass the queue lock as the third argument to this function instead of
999  * setting the queue lock pointer explicitly to avoid triggering a sporadic
1000  * crash in the blkcg code. This function namely calls blkcg_init_queue() and
1001  * the queue lock pointer must be set before blkcg_init_queue() is called.
1002  */
1003 struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id,
1004                                            spinlock_t *lock)
1005 {
1006         struct request_queue *q;
1007         int ret;
1008
1009         q = kmem_cache_alloc_node(blk_requestq_cachep,
1010                                 gfp_mask | __GFP_ZERO, node_id);
1011         if (!q)
1012                 return NULL;
1013
1014         INIT_LIST_HEAD(&q->queue_head);
1015         q->last_merge = NULL;
1016         q->end_sector = 0;
1017         q->boundary_rq = NULL;
1018
1019         q->id = ida_simple_get(&blk_queue_ida, 0, 0, gfp_mask);
1020         if (q->id < 0)
1021                 goto fail_q;
1022
1023         ret = bioset_init(&q->bio_split, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
1024         if (ret)
1025                 goto fail_id;
1026
1027         q->backing_dev_info = bdi_alloc_node(gfp_mask, node_id);
1028         if (!q->backing_dev_info)
1029                 goto fail_split;
1030
1031         q->stats = blk_alloc_queue_stats();
1032         if (!q->stats)
1033                 goto fail_stats;
1034
1035         q->backing_dev_info->ra_pages =
1036                         (VM_MAX_READAHEAD * 1024) / PAGE_SIZE;
1037         q->backing_dev_info->capabilities = BDI_CAP_CGROUP_WRITEBACK;
1038         q->backing_dev_info->name = "block";
1039         q->node = node_id;
1040
1041         timer_setup(&q->backing_dev_info->laptop_mode_wb_timer,
1042                     laptop_mode_timer_fn, 0);
1043         timer_setup(&q->timeout, blk_rq_timed_out_timer, 0);
1044         INIT_WORK(&q->timeout_work, NULL);
1045         INIT_LIST_HEAD(&q->timeout_list);
1046         INIT_LIST_HEAD(&q->icq_list);
1047 #ifdef CONFIG_BLK_CGROUP
1048         INIT_LIST_HEAD(&q->blkg_list);
1049 #endif
1050         INIT_DELAYED_WORK(&q->delay_work, blk_delay_work);
1051
1052         kobject_init(&q->kobj, &blk_queue_ktype);
1053
1054 #ifdef CONFIG_BLK_DEV_IO_TRACE
1055         mutex_init(&q->blk_trace_mutex);
1056 #endif
1057         mutex_init(&q->sysfs_lock);
1058         spin_lock_init(&q->__queue_lock);
1059
1060         q->queue_lock = lock ? : &q->__queue_lock;
1061
1062         /*
1063          * A queue starts its life with bypass turned on to avoid
1064          * unnecessary bypass on/off overhead and nasty surprises during
1065          * init.  The initial bypass will be finished when the queue is
1066          * registered by blk_register_queue().
1067          */
1068         q->bypass_depth = 1;
1069         queue_flag_set_unlocked(QUEUE_FLAG_BYPASS, q);
1070
1071         init_waitqueue_head(&q->mq_freeze_wq);
1072
1073         /*
1074          * Init percpu_ref in atomic mode so that it's faster to shutdown.
1075          * See blk_register_queue() for details.
1076          */
1077         if (percpu_ref_init(&q->q_usage_counter,
1078                                 blk_queue_usage_counter_release,
1079                                 PERCPU_REF_INIT_ATOMIC, GFP_KERNEL))
1080                 goto fail_bdi;
1081
1082         if (blkcg_init_queue(q))
1083                 goto fail_ref;
1084
1085         return q;
1086
1087 fail_ref:
1088         percpu_ref_exit(&q->q_usage_counter);
1089 fail_bdi:
1090         blk_free_queue_stats(q->stats);
1091 fail_stats:
1092         bdi_put(q->backing_dev_info);
1093 fail_split:
1094         bioset_exit(&q->bio_split);
1095 fail_id:
1096         ida_simple_remove(&blk_queue_ida, q->id);
1097 fail_q:
1098         kmem_cache_free(blk_requestq_cachep, q);
1099         return NULL;
1100 }
1101 EXPORT_SYMBOL(blk_alloc_queue_node);
1102
1103 /**
1104  * blk_init_queue  - prepare a request queue for use with a block device
1105  * @rfn:  The function to be called to process requests that have been
1106  *        placed on the queue.
1107  * @lock: Request queue spin lock
1108  *
1109  * Description:
1110  *    If a block device wishes to use the standard request handling procedures,
1111  *    which sorts requests and coalesces adjacent requests, then it must
1112  *    call blk_init_queue().  The function @rfn will be called when there
1113  *    are requests on the queue that need to be processed.  If the device
1114  *    supports plugging, then @rfn may not be called immediately when requests
1115  *    are available on the queue, but may be called at some time later instead.
1116  *    Plugged queues are generally unplugged when a buffer belonging to one
1117  *    of the requests on the queue is needed, or due to memory pressure.
1118  *
1119  *    @rfn is not required, or even expected, to remove all requests off the
1120  *    queue, but only as many as it can handle at a time.  If it does leave
1121  *    requests on the queue, it is responsible for arranging that the requests
1122  *    get dealt with eventually.
1123  *
1124  *    The queue spin lock must be held while manipulating the requests on the
1125  *    request queue; this lock will be taken also from interrupt context, so irq
1126  *    disabling is needed for it.
1127  *
1128  *    Function returns a pointer to the initialized request queue, or %NULL if
1129  *    it didn't succeed.
1130  *
1131  * Note:
1132  *    blk_init_queue() must be paired with a blk_cleanup_queue() call
1133  *    when the block device is deactivated (such as at module unload).
1134  **/
1135
1136 struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)
1137 {
1138         return blk_init_queue_node(rfn, lock, NUMA_NO_NODE);
1139 }
1140 EXPORT_SYMBOL(blk_init_queue);
1141
1142 struct request_queue *
1143 blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)
1144 {
1145         struct request_queue *q;
1146
1147         q = blk_alloc_queue_node(GFP_KERNEL, node_id, lock);
1148         if (!q)
1149                 return NULL;
1150
1151         q->request_fn = rfn;
1152         if (blk_init_allocated_queue(q) < 0) {
1153                 blk_cleanup_queue(q);
1154                 return NULL;
1155         }
1156
1157         return q;
1158 }
1159 EXPORT_SYMBOL(blk_init_queue_node);
1160
1161 static blk_qc_t blk_queue_bio(struct request_queue *q, struct bio *bio);
1162
1163
1164 int blk_init_allocated_queue(struct request_queue *q)
1165 {
1166         WARN_ON_ONCE(q->mq_ops);
1167
1168         q->fq = blk_alloc_flush_queue(q, NUMA_NO_NODE, q->cmd_size, GFP_KERNEL);
1169         if (!q->fq)
1170                 return -ENOMEM;
1171
1172         if (q->init_rq_fn && q->init_rq_fn(q, q->fq->flush_rq, GFP_KERNEL))
1173                 goto out_free_flush_queue;
1174
1175         if (blk_init_rl(&q->root_rl, q, GFP_KERNEL))
1176                 goto out_exit_flush_rq;
1177
1178         INIT_WORK(&q->timeout_work, blk_timeout_work);
1179         q->queue_flags          |= QUEUE_FLAG_DEFAULT;
1180
1181         /*
1182          * This also sets hw/phys segments, boundary and size
1183          */
1184         blk_queue_make_request(q, blk_queue_bio);
1185
1186         q->sg_reserved_size = INT_MAX;
1187
1188         if (elevator_init(q))
1189                 goto out_exit_flush_rq;
1190         return 0;
1191
1192 out_exit_flush_rq:
1193         if (q->exit_rq_fn)
1194                 q->exit_rq_fn(q, q->fq->flush_rq);
1195 out_free_flush_queue:
1196         blk_free_flush_queue(q->fq);
1197         q->fq = NULL;
1198         return -ENOMEM;
1199 }
1200 EXPORT_SYMBOL(blk_init_allocated_queue);
1201
1202 bool blk_get_queue(struct request_queue *q)
1203 {
1204         if (likely(!blk_queue_dying(q))) {
1205                 __blk_get_queue(q);
1206                 return true;
1207         }
1208
1209         return false;
1210 }
1211 EXPORT_SYMBOL(blk_get_queue);
1212
1213 static inline void blk_free_request(struct request_list *rl, struct request *rq)
1214 {
1215         if (rq->rq_flags & RQF_ELVPRIV) {
1216                 elv_put_request(rl->q, rq);
1217                 if (rq->elv.icq)
1218                         put_io_context(rq->elv.icq->ioc);
1219         }
1220
1221         mempool_free(rq, rl->rq_pool);
1222 }
1223
1224 /*
1225  * ioc_batching returns true if the ioc is a valid batching request and
1226  * should be given priority access to a request.
1227  */
1228 static inline int ioc_batching(struct request_queue *q, struct io_context *ioc)
1229 {
1230         if (!ioc)
1231                 return 0;
1232
1233         /*
1234          * Make sure the process is able to allocate at least 1 request
1235          * even if the batch times out, otherwise we could theoretically
1236          * lose wakeups.
1237          */
1238         return ioc->nr_batch_requests == q->nr_batching ||
1239                 (ioc->nr_batch_requests > 0
1240                 && time_before(jiffies, ioc->last_waited + BLK_BATCH_TIME));
1241 }
1242
1243 /*
1244  * ioc_set_batching sets ioc to be a new "batcher" if it is not one. This
1245  * will cause the process to be a "batcher" on all queues in the system. This
1246  * is the behaviour we want though - once it gets a wakeup it should be given
1247  * a nice run.
1248  */
1249 static void ioc_set_batching(struct request_queue *q, struct io_context *ioc)
1250 {
1251         if (!ioc || ioc_batching(q, ioc))
1252                 return;
1253
1254         ioc->nr_batch_requests = q->nr_batching;
1255         ioc->last_waited = jiffies;
1256 }
1257
1258 static void __freed_request(struct request_list *rl, int sync)
1259 {
1260         struct request_queue *q = rl->q;
1261
1262         if (rl->count[sync] < queue_congestion_off_threshold(q))
1263                 blk_clear_congested(rl, sync);
1264
1265         if (rl->count[sync] + 1 <= q->nr_requests) {
1266                 if (waitqueue_active(&rl->wait[sync]))
1267                         wake_up(&rl->wait[sync]);
1268
1269                 blk_clear_rl_full(rl, sync);
1270         }
1271 }
1272
1273 /*
1274  * A request has just been released.  Account for it, update the full and
1275  * congestion status, wake up any waiters.   Called under q->queue_lock.
1276  */
1277 static void freed_request(struct request_list *rl, bool sync,
1278                 req_flags_t rq_flags)
1279 {
1280         struct request_queue *q = rl->q;
1281
1282         q->nr_rqs[sync]--;
1283         rl->count[sync]--;
1284         if (rq_flags & RQF_ELVPRIV)
1285                 q->nr_rqs_elvpriv--;
1286
1287         __freed_request(rl, sync);
1288
1289         if (unlikely(rl->starved[sync ^ 1]))
1290                 __freed_request(rl, sync ^ 1);
1291 }
1292
1293 int blk_update_nr_requests(struct request_queue *q, unsigned int nr)
1294 {
1295         struct request_list *rl;
1296         int on_thresh, off_thresh;
1297
1298         WARN_ON_ONCE(q->mq_ops);
1299
1300         spin_lock_irq(q->queue_lock);
1301         q->nr_requests = nr;
1302         blk_queue_congestion_threshold(q);
1303         on_thresh = queue_congestion_on_threshold(q);
1304         off_thresh = queue_congestion_off_threshold(q);
1305
1306         blk_queue_for_each_rl(rl, q) {
1307                 if (rl->count[BLK_RW_SYNC] >= on_thresh)
1308                         blk_set_congested(rl, BLK_RW_SYNC);
1309                 else if (rl->count[BLK_RW_SYNC] < off_thresh)
1310                         blk_clear_congested(rl, BLK_RW_SYNC);
1311
1312                 if (rl->count[BLK_RW_ASYNC] >= on_thresh)
1313                         blk_set_congested(rl, BLK_RW_ASYNC);
1314                 else if (rl->count[BLK_RW_ASYNC] < off_thresh)
1315                         blk_clear_congested(rl, BLK_RW_ASYNC);
1316
1317                 if (rl->count[BLK_RW_SYNC] >= q->nr_requests) {
1318                         blk_set_rl_full(rl, BLK_RW_SYNC);
1319                 } else {
1320                         blk_clear_rl_full(rl, BLK_RW_SYNC);
1321                         wake_up(&rl->wait[BLK_RW_SYNC]);
1322                 }
1323
1324                 if (rl->count[BLK_RW_ASYNC] >= q->nr_requests) {
1325                         blk_set_rl_full(rl, BLK_RW_ASYNC);
1326                 } else {
1327                         blk_clear_rl_full(rl, BLK_RW_ASYNC);
1328                         wake_up(&rl->wait[BLK_RW_ASYNC]);
1329                 }
1330         }
1331
1332         spin_unlock_irq(q->queue_lock);
1333         return 0;
1334 }
1335
1336 /**
1337  * __get_request - get a free request
1338  * @rl: request list to allocate from
1339  * @op: operation and flags
1340  * @bio: bio to allocate request for (can be %NULL)
1341  * @flags: BLQ_MQ_REQ_* flags
1342  * @gfp_mask: allocator flags
1343  *
1344  * Get a free request from @q.  This function may fail under memory
1345  * pressure or if @q is dead.
1346  *
1347  * Must be called with @q->queue_lock held and,
1348  * Returns ERR_PTR on failure, with @q->queue_lock held.
1349  * Returns request pointer on success, with @q->queue_lock *not held*.
1350  */
1351 static struct request *__get_request(struct request_list *rl, unsigned int op,
1352                 struct bio *bio, blk_mq_req_flags_t flags, gfp_t gfp_mask)
1353 {
1354         struct request_queue *q = rl->q;
1355         struct request *rq;
1356         struct elevator_type *et = q->elevator->type;
1357         struct io_context *ioc = rq_ioc(bio);
1358         struct io_cq *icq = NULL;
1359         const bool is_sync = op_is_sync(op);
1360         int may_queue;
1361         req_flags_t rq_flags = RQF_ALLOCED;
1362
1363         lockdep_assert_held(q->queue_lock);
1364
1365         if (unlikely(blk_queue_dying(q)))
1366                 return ERR_PTR(-ENODEV);
1367
1368         may_queue = elv_may_queue(q, op);
1369         if (may_queue == ELV_MQUEUE_NO)
1370                 goto rq_starved;
1371
1372         if (rl->count[is_sync]+1 >= queue_congestion_on_threshold(q)) {
1373                 if (rl->count[is_sync]+1 >= q->nr_requests) {
1374                         /*
1375                          * The queue will fill after this allocation, so set
1376                          * it as full, and mark this process as "batching".
1377                          * This process will be allowed to complete a batch of
1378                          * requests, others will be blocked.
1379                          */
1380                         if (!blk_rl_full(rl, is_sync)) {
1381                                 ioc_set_batching(q, ioc);
1382                                 blk_set_rl_full(rl, is_sync);
1383                         } else {
1384                                 if (may_queue != ELV_MQUEUE_MUST
1385                                                 && !ioc_batching(q, ioc)) {
1386                                         /*
1387                                          * The queue is full and the allocating
1388                                          * process is not a "batcher", and not
1389                                          * exempted by the IO scheduler
1390                                          */
1391                                         return ERR_PTR(-ENOMEM);
1392                                 }
1393                         }
1394                 }
1395                 blk_set_congested(rl, is_sync);
1396         }
1397
1398         /*
1399          * Only allow batching queuers to allocate up to 50% over the defined
1400          * limit of requests, otherwise we could have thousands of requests
1401          * allocated with any setting of ->nr_requests
1402          */
1403         if (rl->count[is_sync] >= (3 * q->nr_requests / 2))
1404                 return ERR_PTR(-ENOMEM);
1405
1406         q->nr_rqs[is_sync]++;
1407         rl->count[is_sync]++;
1408         rl->starved[is_sync] = 0;
1409
1410         /*
1411          * Decide whether the new request will be managed by elevator.  If
1412          * so, mark @rq_flags and increment elvpriv.  Non-zero elvpriv will
1413          * prevent the current elevator from being destroyed until the new
1414          * request is freed.  This guarantees icq's won't be destroyed and
1415          * makes creating new ones safe.
1416          *
1417          * Flush requests do not use the elevator so skip initialization.
1418          * This allows a request to share the flush and elevator data.
1419          *
1420          * Also, lookup icq while holding queue_lock.  If it doesn't exist,
1421          * it will be created after releasing queue_lock.
1422          */
1423         if (!op_is_flush(op) && !blk_queue_bypass(q)) {
1424                 rq_flags |= RQF_ELVPRIV;
1425                 q->nr_rqs_elvpriv++;
1426                 if (et->icq_cache && ioc)
1427                         icq = ioc_lookup_icq(ioc, q);
1428         }
1429
1430         if (blk_queue_io_stat(q))
1431                 rq_flags |= RQF_IO_STAT;
1432         spin_unlock_irq(q->queue_lock);
1433
1434         /* allocate and init request */
1435         rq = mempool_alloc(rl->rq_pool, gfp_mask);
1436         if (!rq)
1437                 goto fail_alloc;
1438
1439         blk_rq_init(q, rq);
1440         blk_rq_set_rl(rq, rl);
1441         rq->cmd_flags = op;
1442         rq->rq_flags = rq_flags;
1443         if (flags & BLK_MQ_REQ_PREEMPT)
1444                 rq->rq_flags |= RQF_PREEMPT;
1445
1446         /* init elvpriv */
1447         if (rq_flags & RQF_ELVPRIV) {
1448                 if (unlikely(et->icq_cache && !icq)) {
1449                         if (ioc)
1450                                 icq = ioc_create_icq(ioc, q, gfp_mask);
1451                         if (!icq)
1452                                 goto fail_elvpriv;
1453                 }
1454
1455                 rq->elv.icq = icq;
1456                 if (unlikely(elv_set_request(q, rq, bio, gfp_mask)))
1457                         goto fail_elvpriv;
1458
1459                 /* @rq->elv.icq holds io_context until @rq is freed */
1460                 if (icq)
1461                         get_io_context(icq->ioc);
1462         }
1463 out:
1464         /*
1465          * ioc may be NULL here, and ioc_batching will be false. That's
1466          * OK, if the queue is under the request limit then requests need
1467          * not count toward the nr_batch_requests limit. There will always
1468          * be some limit enforced by BLK_BATCH_TIME.
1469          */
1470         if (ioc_batching(q, ioc))
1471                 ioc->nr_batch_requests--;
1472
1473         trace_block_getrq(q, bio, op);
1474         return rq;
1475
1476 fail_elvpriv:
1477         /*
1478          * elvpriv init failed.  ioc, icq and elvpriv aren't mempool backed
1479          * and may fail indefinitely under memory pressure and thus
1480          * shouldn't stall IO.  Treat this request as !elvpriv.  This will
1481          * disturb iosched and blkcg but weird is bettern than dead.
1482          */
1483         printk_ratelimited(KERN_WARNING "%s: dev %s: request aux data allocation failed, iosched may be disturbed\n",
1484                            __func__, dev_name(q->backing_dev_info->dev));
1485
1486         rq->rq_flags &= ~RQF_ELVPRIV;
1487         rq->elv.icq = NULL;
1488
1489         spin_lock_irq(q->queue_lock);
1490         q->nr_rqs_elvpriv--;
1491         spin_unlock_irq(q->queue_lock);
1492         goto out;
1493
1494 fail_alloc:
1495         /*
1496          * Allocation failed presumably due to memory. Undo anything we
1497          * might have messed up.
1498          *
1499          * Allocating task should really be put onto the front of the wait
1500          * queue, but this is pretty rare.
1501          */
1502         spin_lock_irq(q->queue_lock);
1503         freed_request(rl, is_sync, rq_flags);
1504
1505         /*
1506          * in the very unlikely event that allocation failed and no
1507          * requests for this direction was pending, mark us starved so that
1508          * freeing of a request in the other direction will notice
1509          * us. another possible fix would be to split the rq mempool into
1510          * READ and WRITE
1511          */
1512 rq_starved:
1513         if (unlikely(rl->count[is_sync] == 0))
1514                 rl->starved[is_sync] = 1;
1515         return ERR_PTR(-ENOMEM);
1516 }
1517
1518 /**
1519  * get_request - get a free request
1520  * @q: request_queue to allocate request from
1521  * @op: operation and flags
1522  * @bio: bio to allocate request for (can be %NULL)
1523  * @flags: BLK_MQ_REQ_* flags.
1524  * @gfp: allocator flags
1525  *
1526  * Get a free request from @q.  If %BLK_MQ_REQ_NOWAIT is set in @flags,
1527  * this function keeps retrying under memory pressure and fails iff @q is dead.
1528  *
1529  * Must be called with @q->queue_lock held and,
1530  * Returns ERR_PTR on failure, with @q->queue_lock held.
1531  * Returns request pointer on success, with @q->queue_lock *not held*.
1532  */
1533 static struct request *get_request(struct request_queue *q, unsigned int op,
1534                 struct bio *bio, blk_mq_req_flags_t flags, gfp_t gfp)
1535 {
1536         const bool is_sync = op_is_sync(op);
1537         DEFINE_WAIT(wait);
1538         struct request_list *rl;
1539         struct request *rq;
1540
1541         lockdep_assert_held(q->queue_lock);
1542         WARN_ON_ONCE(q->mq_ops);
1543
1544         rl = blk_get_rl(q, bio);        /* transferred to @rq on success */
1545 retry:
1546         rq = __get_request(rl, op, bio, flags, gfp);
1547         if (!IS_ERR(rq))
1548                 return rq;
1549
1550         if (op & REQ_NOWAIT) {
1551                 blk_put_rl(rl);
1552                 return ERR_PTR(-EAGAIN);
1553         }
1554
1555         if ((flags & BLK_MQ_REQ_NOWAIT) || unlikely(blk_queue_dying(q))) {
1556                 blk_put_rl(rl);
1557                 return rq;
1558         }
1559
1560         /* wait on @rl and retry */
1561         prepare_to_wait_exclusive(&rl->wait[is_sync], &wait,
1562                                   TASK_UNINTERRUPTIBLE);
1563
1564         trace_block_sleeprq(q, bio, op);
1565
1566         spin_unlock_irq(q->queue_lock);
1567         io_schedule();
1568
1569         /*
1570          * After sleeping, we become a "batching" process and will be able
1571          * to allocate at least one request, and up to a big batch of them
1572          * for a small period time.  See ioc_batching, ioc_set_batching
1573          */
1574         ioc_set_batching(q, current->io_context);
1575
1576         spin_lock_irq(q->queue_lock);
1577         finish_wait(&rl->wait[is_sync], &wait);
1578
1579         goto retry;
1580 }
1581
1582 /* flags: BLK_MQ_REQ_PREEMPT and/or BLK_MQ_REQ_NOWAIT. */
1583 static struct request *blk_old_get_request(struct request_queue *q,
1584                                 unsigned int op, blk_mq_req_flags_t flags)
1585 {
1586         struct request *rq;
1587         gfp_t gfp_mask = flags & BLK_MQ_REQ_NOWAIT ? GFP_ATOMIC : GFP_NOIO;
1588         int ret = 0;
1589
1590         WARN_ON_ONCE(q->mq_ops);
1591
1592         /* create ioc upfront */
1593         create_io_context(gfp_mask, q->node);
1594
1595         ret = blk_queue_enter(q, flags);
1596         if (ret)
1597                 return ERR_PTR(ret);
1598         spin_lock_irq(q->queue_lock);
1599         rq = get_request(q, op, NULL, flags, gfp_mask);
1600         if (IS_ERR(rq)) {
1601                 spin_unlock_irq(q->queue_lock);
1602                 blk_queue_exit(q);
1603                 return rq;
1604         }
1605
1606         /* q->queue_lock is unlocked at this point */
1607         rq->__data_len = 0;
1608         rq->__sector = (sector_t) -1;
1609         rq->bio = rq->biotail = NULL;
1610         return rq;
1611 }
1612
1613 /**
1614  * blk_get_request - allocate a request
1615  * @q: request queue to allocate a request for
1616  * @op: operation (REQ_OP_*) and REQ_* flags, e.g. REQ_SYNC.
1617  * @flags: BLK_MQ_REQ_* flags, e.g. BLK_MQ_REQ_NOWAIT.
1618  */
1619 struct request *blk_get_request(struct request_queue *q, unsigned int op,
1620                                 blk_mq_req_flags_t flags)
1621 {
1622         struct request *req;
1623
1624         WARN_ON_ONCE(op & REQ_NOWAIT);
1625         WARN_ON_ONCE(flags & ~(BLK_MQ_REQ_NOWAIT | BLK_MQ_REQ_PREEMPT));
1626
1627         if (q->mq_ops) {
1628                 req = blk_mq_alloc_request(q, op, flags);
1629                 if (!IS_ERR(req) && q->mq_ops->initialize_rq_fn)
1630                         q->mq_ops->initialize_rq_fn(req);
1631         } else {
1632                 req = blk_old_get_request(q, op, flags);
1633                 if (!IS_ERR(req) && q->initialize_rq_fn)
1634                         q->initialize_rq_fn(req);
1635         }
1636
1637         return req;
1638 }
1639 EXPORT_SYMBOL(blk_get_request);
1640
1641 /**
1642  * blk_requeue_request - put a request back on queue
1643  * @q:          request queue where request should be inserted
1644  * @rq:         request to be inserted
1645  *
1646  * Description:
1647  *    Drivers often keep queueing requests until the hardware cannot accept
1648  *    more, when that condition happens we need to put the request back
1649  *    on the queue. Must be called with queue lock held.
1650  */
1651 void blk_requeue_request(struct request_queue *q, struct request *rq)
1652 {
1653         lockdep_assert_held(q->queue_lock);
1654         WARN_ON_ONCE(q->mq_ops);
1655
1656         blk_delete_timer(rq);
1657         blk_clear_rq_complete(rq);
1658         trace_block_rq_requeue(q, rq);
1659         rq_qos_requeue(q, rq);
1660
1661         if (rq->rq_flags & RQF_QUEUED)
1662                 blk_queue_end_tag(q, rq);
1663
1664         BUG_ON(blk_queued_rq(rq));
1665
1666         elv_requeue_request(q, rq);
1667 }
1668 EXPORT_SYMBOL(blk_requeue_request);
1669
1670 static void add_acct_request(struct request_queue *q, struct request *rq,
1671                              int where)
1672 {
1673         blk_account_io_start(rq, true);
1674         __elv_add_request(q, rq, where);
1675 }
1676
1677 static void part_round_stats_single(struct request_queue *q, int cpu,
1678                                     struct hd_struct *part, unsigned long now,
1679                                     unsigned int inflight)
1680 {
1681         if (inflight) {
1682                 __part_stat_add(cpu, part, time_in_queue,
1683                                 inflight * (now - part->stamp));
1684                 __part_stat_add(cpu, part, io_ticks, (now - part->stamp));
1685         }
1686         part->stamp = now;
1687 }
1688
1689 /**
1690  * part_round_stats() - Round off the performance stats on a struct disk_stats.
1691  * @q: target block queue
1692  * @cpu: cpu number for stats access
1693  * @part: target partition
1694  *
1695  * The average IO queue length and utilisation statistics are maintained
1696  * by observing the current state of the queue length and the amount of
1697  * time it has been in this state for.
1698  *
1699  * Normally, that accounting is done on IO completion, but that can result
1700  * in more than a second's worth of IO being accounted for within any one
1701  * second, leading to >100% utilisation.  To deal with that, we call this
1702  * function to do a round-off before returning the results when reading
1703  * /proc/diskstats.  This accounts immediately for all queue usage up to
1704  * the current jiffies and restarts the counters again.
1705  */
1706 void part_round_stats(struct request_queue *q, int cpu, struct hd_struct *part)
1707 {
1708         struct hd_struct *part2 = NULL;
1709         unsigned long now = jiffies;
1710         unsigned int inflight[2];
1711         int stats = 0;
1712
1713         if (part->stamp != now)
1714                 stats |= 1;
1715
1716         if (part->partno) {
1717                 part2 = &part_to_disk(part)->part0;
1718                 if (part2->stamp != now)
1719                         stats |= 2;
1720         }
1721
1722         if (!stats)
1723                 return;
1724
1725         part_in_flight(q, part, inflight);
1726
1727         if (stats & 2)
1728                 part_round_stats_single(q, cpu, part2, now, inflight[1]);
1729         if (stats & 1)
1730                 part_round_stats_single(q, cpu, part, now, inflight[0]);
1731 }
1732 EXPORT_SYMBOL_GPL(part_round_stats);
1733
1734 void __blk_put_request(struct request_queue *q, struct request *req)
1735 {
1736         req_flags_t rq_flags = req->rq_flags;
1737
1738         if (unlikely(!q))
1739                 return;
1740
1741         if (q->mq_ops) {
1742                 blk_mq_free_request(req);
1743                 return;
1744         }
1745
1746         lockdep_assert_held(q->queue_lock);
1747
1748         blk_req_zone_write_unlock(req);
1749         blk_pm_put_request(req);
1750         blk_pm_mark_last_busy(req);
1751
1752         elv_completed_request(q, req);
1753
1754         /* this is a bio leak */
1755         WARN_ON(req->bio != NULL);
1756
1757         rq_qos_done(q, req);
1758
1759         /*
1760          * Request may not have originated from ll_rw_blk. if not,
1761          * it didn't come out of our reserved rq pools
1762          */
1763         if (rq_flags & RQF_ALLOCED) {
1764                 struct request_list *rl = blk_rq_rl(req);
1765                 bool sync = op_is_sync(req->cmd_flags);
1766
1767                 BUG_ON(!list_empty(&req->queuelist));
1768                 BUG_ON(ELV_ON_HASH(req));
1769
1770                 blk_free_request(rl, req);
1771                 freed_request(rl, sync, rq_flags);
1772                 blk_put_rl(rl);
1773                 blk_queue_exit(q);
1774         }
1775 }
1776 EXPORT_SYMBOL_GPL(__blk_put_request);
1777
1778 void blk_put_request(struct request *req)
1779 {
1780         struct request_queue *q = req->q;
1781
1782         if (q->mq_ops)
1783                 blk_mq_free_request(req);
1784         else {
1785                 unsigned long flags;
1786
1787                 spin_lock_irqsave(q->queue_lock, flags);
1788                 __blk_put_request(q, req);
1789                 spin_unlock_irqrestore(q->queue_lock, flags);
1790         }
1791 }
1792 EXPORT_SYMBOL(blk_put_request);
1793
1794 bool bio_attempt_back_merge(struct request_queue *q, struct request *req,
1795                             struct bio *bio)
1796 {
1797         const int ff = bio->bi_opf & REQ_FAILFAST_MASK;
1798
1799         if (!ll_back_merge_fn(q, req, bio))
1800                 return false;
1801
1802         trace_block_bio_backmerge(q, req, bio);
1803
1804         if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff)
1805                 blk_rq_set_mixed_merge(req);
1806
1807         req->biotail->bi_next = bio;
1808         req->biotail = bio;
1809         req->__data_len += bio->bi_iter.bi_size;
1810         req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));
1811
1812         blk_account_io_start(req, false);
1813         return true;
1814 }
1815
1816 bool bio_attempt_front_merge(struct request_queue *q, struct request *req,
1817                              struct bio *bio)
1818 {
1819         const int ff = bio->bi_opf & REQ_FAILFAST_MASK;
1820
1821         if (!ll_front_merge_fn(q, req, bio))
1822                 return false;
1823
1824         trace_block_bio_frontmerge(q, req, bio);
1825
1826         if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff)
1827                 blk_rq_set_mixed_merge(req);
1828
1829         bio->bi_next = req->bio;
1830         req->bio = bio;
1831
1832         req->__sector = bio->bi_iter.bi_sector;
1833         req->__data_len += bio->bi_iter.bi_size;
1834         req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));
1835
1836         blk_account_io_start(req, false);
1837         return true;
1838 }
1839
1840 bool bio_attempt_discard_merge(struct request_queue *q, struct request *req,
1841                 struct bio *bio)
1842 {
1843         unsigned short segments = blk_rq_nr_discard_segments(req);
1844
1845         if (segments >= queue_max_discard_segments(q))
1846                 goto no_merge;
1847         if (blk_rq_sectors(req) + bio_sectors(bio) >
1848             blk_rq_get_max_sectors(req, blk_rq_pos(req)))
1849                 goto no_merge;
1850
1851         req->biotail->bi_next = bio;
1852         req->biotail = bio;
1853         req->__data_len += bio->bi_iter.bi_size;
1854         req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));
1855         req->nr_phys_segments = segments + 1;
1856
1857         blk_account_io_start(req, false);
1858         return true;
1859 no_merge:
1860         req_set_nomerge(q, req);
1861         return false;
1862 }
1863
1864 /**
1865  * blk_attempt_plug_merge - try to merge with %current's plugged list
1866  * @q: request_queue new bio is being queued at
1867  * @bio: new bio being queued
1868  * @request_count: out parameter for number of traversed plugged requests
1869  * @same_queue_rq: pointer to &struct request that gets filled in when
1870  * another request associated with @q is found on the plug list
1871  * (optional, may be %NULL)
1872  *
1873  * Determine whether @bio being queued on @q can be merged with a request
1874  * on %current's plugged list.  Returns %true if merge was successful,
1875  * otherwise %false.
1876  *
1877  * Plugging coalesces IOs from the same issuer for the same purpose without
1878  * going through @q->queue_lock.  As such it's more of an issuing mechanism
1879  * than scheduling, and the request, while may have elvpriv data, is not
1880  * added on the elevator at this point.  In addition, we don't have
1881  * reliable access to the elevator outside queue lock.  Only check basic
1882  * merging parameters without querying the elevator.
1883  *
1884  * Caller must ensure !blk_queue_nomerges(q) beforehand.
1885  */
1886 bool blk_attempt_plug_merge(struct request_queue *q, struct bio *bio,
1887                             unsigned int *request_count,
1888                             struct request **same_queue_rq)
1889 {
1890         struct blk_plug *plug;
1891         struct request *rq;
1892         struct list_head *plug_list;
1893
1894         plug = current->plug;
1895         if (!plug)
1896                 return false;
1897         *request_count = 0;
1898
1899         if (q->mq_ops)
1900                 plug_list = &plug->mq_list;
1901         else
1902                 plug_list = &plug->list;
1903
1904         list_for_each_entry_reverse(rq, plug_list, queuelist) {
1905                 bool merged = false;
1906
1907                 if (rq->q == q) {
1908                         (*request_count)++;
1909                         /*
1910                          * Only blk-mq multiple hardware queues case checks the
1911                          * rq in the same queue, there should be only one such
1912                          * rq in a queue
1913                          **/
1914                         if (same_queue_rq)
1915                                 *same_queue_rq = rq;
1916                 }
1917
1918                 if (rq->q != q || !blk_rq_merge_ok(rq, bio))
1919                         continue;
1920
1921                 switch (blk_try_merge(rq, bio)) {
1922                 case ELEVATOR_BACK_MERGE:
1923                         merged = bio_attempt_back_merge(q, rq, bio);
1924                         break;
1925                 case ELEVATOR_FRONT_MERGE:
1926                         merged = bio_attempt_front_merge(q, rq, bio);
1927                         break;
1928                 case ELEVATOR_DISCARD_MERGE:
1929                         merged = bio_attempt_discard_merge(q, rq, bio);
1930                         break;
1931                 default:
1932                         break;
1933                 }
1934
1935                 if (merged)
1936                         return true;
1937         }
1938
1939         return false;
1940 }
1941
1942 unsigned int blk_plug_queued_count(struct request_queue *q)
1943 {
1944         struct blk_plug *plug;
1945         struct request *rq;
1946         struct list_head *plug_list;
1947         unsigned int ret = 0;
1948
1949         plug = current->plug;
1950         if (!plug)
1951                 goto out;
1952
1953         if (q->mq_ops)
1954                 plug_list = &plug->mq_list;
1955         else
1956                 plug_list = &plug->list;
1957
1958         list_for_each_entry(rq, plug_list, queuelist) {
1959                 if (rq->q == q)
1960                         ret++;
1961         }
1962 out:
1963         return ret;
1964 }
1965
1966 void blk_init_request_from_bio(struct request *req, struct bio *bio)
1967 {
1968         struct io_context *ioc = rq_ioc(bio);
1969
1970         if (bio->bi_opf & REQ_RAHEAD)
1971                 req->cmd_flags |= REQ_FAILFAST_MASK;
1972
1973         req->__sector = bio->bi_iter.bi_sector;
1974         if (ioprio_valid(bio_prio(bio)))
1975                 req->ioprio = bio_prio(bio);
1976         else if (ioc)
1977                 req->ioprio = ioc->ioprio;
1978         else
1979                 req->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0);
1980         req->write_hint = bio->bi_write_hint;
1981         blk_rq_bio_prep(req->q, req, bio);
1982 }
1983 EXPORT_SYMBOL_GPL(blk_init_request_from_bio);
1984
1985 static blk_qc_t blk_queue_bio(struct request_queue *q, struct bio *bio)
1986 {
1987         struct blk_plug *plug;
1988         int where = ELEVATOR_INSERT_SORT;
1989         struct request *req, *free;
1990         unsigned int request_count = 0;
1991
1992         /*
1993          * low level driver can indicate that it wants pages above a
1994          * certain limit bounced to low memory (ie for highmem, or even
1995          * ISA dma in theory)
1996          */
1997         blk_queue_bounce(q, &bio);
1998
1999         blk_queue_split(q, &bio);
2000
2001         if (!bio_integrity_prep(bio))
2002                 return BLK_QC_T_NONE;
2003
2004         if (op_is_flush(bio->bi_opf)) {
2005                 spin_lock_irq(q->queue_lock);
2006                 where = ELEVATOR_INSERT_FLUSH;
2007                 goto get_rq;
2008         }
2009
2010         /*
2011          * Check if we can merge with the plugged list before grabbing
2012          * any locks.
2013          */
2014         if (!blk_queue_nomerges(q)) {
2015                 if (blk_attempt_plug_merge(q, bio, &request_count, NULL))
2016                         return BLK_QC_T_NONE;
2017         } else
2018                 request_count = blk_plug_queued_count(q);
2019
2020         spin_lock_irq(q->queue_lock);
2021
2022         switch (elv_merge(q, &req, bio)) {
2023         case ELEVATOR_BACK_MERGE:
2024                 if (!bio_attempt_back_merge(q, req, bio))
2025                         break;
2026                 elv_bio_merged(q, req, bio);
2027                 free = attempt_back_merge(q, req);
2028                 if (free)
2029                         __blk_put_request(q, free);
2030                 else
2031                         elv_merged_request(q, req, ELEVATOR_BACK_MERGE);
2032                 goto out_unlock;
2033         case ELEVATOR_FRONT_MERGE:
2034                 if (!bio_attempt_front_merge(q, req, bio))
2035                         break;
2036                 elv_bio_merged(q, req, bio);
2037                 free = attempt_front_merge(q, req);
2038                 if (free)
2039                         __blk_put_request(q, free);
2040                 else
2041                         elv_merged_request(q, req, ELEVATOR_FRONT_MERGE);
2042                 goto out_unlock;
2043         default:
2044                 break;
2045         }
2046
2047 get_rq:
2048         rq_qos_throttle(q, bio, q->queue_lock);
2049
2050         /*
2051          * Grab a free request. This is might sleep but can not fail.
2052          * Returns with the queue unlocked.
2053          */
2054         blk_queue_enter_live(q);
2055         req = get_request(q, bio->bi_opf, bio, 0, GFP_NOIO);
2056         if (IS_ERR(req)) {
2057                 blk_queue_exit(q);
2058                 rq_qos_cleanup(q, bio);
2059                 if (PTR_ERR(req) == -ENOMEM)
2060                         bio->bi_status = BLK_STS_RESOURCE;
2061                 else
2062                         bio->bi_status = BLK_STS_IOERR;
2063                 bio_endio(bio);
2064                 goto out_unlock;
2065         }
2066
2067         rq_qos_track(q, req, bio);
2068
2069         /*
2070          * After dropping the lock and possibly sleeping here, our request
2071          * may now be mergeable after it had proven unmergeable (above).
2072          * We don't worry about that case for efficiency. It won't happen
2073          * often, and the elevators are able to handle it.
2074          */
2075         blk_init_request_from_bio(req, bio);
2076
2077         if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags))
2078                 req->cpu = raw_smp_processor_id();
2079
2080         plug = current->plug;
2081         if (plug) {
2082                 /*
2083                  * If this is the first request added after a plug, fire
2084                  * of a plug trace.
2085                  *
2086                  * @request_count may become stale because of schedule
2087                  * out, so check plug list again.
2088                  */
2089                 if (!request_count || list_empty(&plug->list))
2090                         trace_block_plug(q);
2091                 else {
2092                         struct request *last = list_entry_rq(plug->list.prev);
2093                         if (request_count >= BLK_MAX_REQUEST_COUNT ||
2094                             blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE) {
2095                                 blk_flush_plug_list(plug, false);
2096                                 trace_block_plug(q);
2097                         }
2098                 }
2099                 list_add_tail(&req->queuelist, &plug->list);
2100                 blk_account_io_start(req, true);
2101         } else {
2102                 spin_lock_irq(q->queue_lock);
2103                 add_acct_request(q, req, where);
2104                 __blk_run_queue(q);
2105 out_unlock:
2106                 spin_unlock_irq(q->queue_lock);
2107         }
2108
2109         return BLK_QC_T_NONE;
2110 }
2111
2112 static void handle_bad_sector(struct bio *bio, sector_t maxsector)
2113 {
2114         char b[BDEVNAME_SIZE];
2115
2116         printk(KERN_INFO "attempt to access beyond end of device\n");
2117         printk(KERN_INFO "%s: rw=%d, want=%Lu, limit=%Lu\n",
2118                         bio_devname(bio, b), bio->bi_opf,
2119                         (unsigned long long)bio_end_sector(bio),
2120                         (long long)maxsector);
2121 }
2122
2123 #ifdef CONFIG_FAIL_MAKE_REQUEST
2124
2125 static DECLARE_FAULT_ATTR(fail_make_request);
2126
2127 static int __init setup_fail_make_request(char *str)
2128 {
2129         return setup_fault_attr(&fail_make_request, str);
2130 }
2131 __setup("fail_make_request=", setup_fail_make_request);
2132
2133 static bool should_fail_request(struct hd_struct *part, unsigned int bytes)
2134 {
2135         return part->make_it_fail && should_fail(&fail_make_request, bytes);
2136 }
2137
2138 static int __init fail_make_request_debugfs(void)
2139 {
2140         struct dentry *dir = fault_create_debugfs_attr("fail_make_request",
2141                                                 NULL, &fail_make_request);
2142
2143         return PTR_ERR_OR_ZERO(dir);
2144 }
2145
2146 late_initcall(fail_make_request_debugfs);
2147
2148 #else /* CONFIG_FAIL_MAKE_REQUEST */
2149
2150 static inline bool should_fail_request(struct hd_struct *part,
2151                                         unsigned int bytes)
2152 {
2153         return false;
2154 }
2155
2156 #endif /* CONFIG_FAIL_MAKE_REQUEST */
2157
2158 static inline bool bio_check_ro(struct bio *bio, struct hd_struct *part)
2159 {
2160         const int op = bio_op(bio);
2161
2162         if (part->policy && op_is_write(op)) {
2163                 char b[BDEVNAME_SIZE];
2164
2165                 if (op_is_flush(bio->bi_opf) && !bio_sectors(bio))
2166                         return false;
2167
2168                 WARN_ONCE(1,
2169                        "generic_make_request: Trying to write "
2170                         "to read-only block-device %s (partno %d)\n",
2171                         bio_devname(bio, b), part->partno);
2172                 /* Older lvm-tools actually trigger this */
2173                 return false;
2174         }
2175
2176         return false;
2177 }
2178
2179 static noinline int should_fail_bio(struct bio *bio)
2180 {
2181         if (should_fail_request(&bio->bi_disk->part0, bio->bi_iter.bi_size))
2182                 return -EIO;
2183         return 0;
2184 }
2185 ALLOW_ERROR_INJECTION(should_fail_bio, ERRNO);
2186
2187 /*
2188  * Check whether this bio extends beyond the end of the device or partition.
2189  * This may well happen - the kernel calls bread() without checking the size of
2190  * the device, e.g., when mounting a file system.
2191  */
2192 static inline int bio_check_eod(struct bio *bio, sector_t maxsector)
2193 {
2194         unsigned int nr_sectors = bio_sectors(bio);
2195
2196         if (nr_sectors && maxsector &&
2197             (nr_sectors > maxsector ||
2198              bio->bi_iter.bi_sector > maxsector - nr_sectors)) {
2199                 handle_bad_sector(bio, maxsector);
2200                 return -EIO;
2201         }
2202         return 0;
2203 }
2204
2205 /*
2206  * Remap block n of partition p to block n+start(p) of the disk.
2207  */
2208 static inline int blk_partition_remap(struct bio *bio)
2209 {
2210         struct hd_struct *p;
2211         int ret = -EIO;
2212
2213         rcu_read_lock();
2214         p = __disk_get_part(bio->bi_disk, bio->bi_partno);
2215         if (unlikely(!p))
2216                 goto out;
2217         if (unlikely(should_fail_request(p, bio->bi_iter.bi_size)))
2218                 goto out;
2219         if (unlikely(bio_check_ro(bio, p)))
2220                 goto out;
2221
2222         /*
2223          * Zone reset does not include bi_size so bio_sectors() is always 0.
2224          * Include a test for the reset op code and perform the remap if needed.
2225          */
2226         if (bio_sectors(bio) || bio_op(bio) == REQ_OP_ZONE_RESET) {
2227                 if (bio_check_eod(bio, part_nr_sects_read(p)))
2228                         goto out;
2229                 bio->bi_iter.bi_sector += p->start_sect;
2230                 trace_block_bio_remap(bio->bi_disk->queue, bio, part_devt(p),
2231                                       bio->bi_iter.bi_sector - p->start_sect);
2232         }
2233         bio->bi_partno = 0;
2234         ret = 0;
2235 out:
2236         rcu_read_unlock();
2237         return ret;
2238 }
2239
2240 static noinline_for_stack bool
2241 generic_make_request_checks(struct bio *bio)
2242 {
2243         struct request_queue *q;
2244         int nr_sectors = bio_sectors(bio);
2245         blk_status_t status = BLK_STS_IOERR;
2246         char b[BDEVNAME_SIZE];
2247
2248         might_sleep();
2249
2250         q = bio->bi_disk->queue;
2251         if (unlikely(!q)) {
2252                 printk(KERN_ERR
2253                        "generic_make_request: Trying to access "
2254                         "nonexistent block-device %s (%Lu)\n",
2255                         bio_devname(bio, b), (long long)bio->bi_iter.bi_sector);
2256                 goto end_io;
2257         }
2258
2259         /*
2260          * For a REQ_NOWAIT based request, return -EOPNOTSUPP
2261          * if queue is not a request based queue.
2262          */
2263         if ((bio->bi_opf & REQ_NOWAIT) && !queue_is_rq_based(q))
2264                 goto not_supported;
2265
2266         if (should_fail_bio(bio))
2267                 goto end_io;
2268
2269         if (bio->bi_partno) {
2270                 if (unlikely(blk_partition_remap(bio)))
2271                         goto end_io;
2272         } else {
2273                 if (unlikely(bio_check_ro(bio, &bio->bi_disk->part0)))
2274                         goto end_io;
2275                 if (unlikely(bio_check_eod(bio, get_capacity(bio->bi_disk))))
2276                         goto end_io;
2277         }
2278
2279         /*
2280          * Filter flush bio's early so that make_request based
2281          * drivers without flush support don't have to worry
2282          * about them.
2283          */
2284         if (op_is_flush(bio->bi_opf) &&
2285             !test_bit(QUEUE_FLAG_WC, &q->queue_flags)) {
2286                 bio->bi_opf &= ~(REQ_PREFLUSH | REQ_FUA);
2287                 if (!nr_sectors) {
2288                         status = BLK_STS_OK;
2289                         goto end_io;
2290                 }
2291         }
2292
2293         switch (bio_op(bio)) {
2294         case REQ_OP_DISCARD:
2295                 if (!blk_queue_discard(q))
2296                         goto not_supported;
2297                 break;
2298         case REQ_OP_SECURE_ERASE:
2299                 if (!blk_queue_secure_erase(q))
2300                         goto not_supported;
2301                 break;
2302         case REQ_OP_WRITE_SAME:
2303                 if (!q->limits.max_write_same_sectors)
2304                         goto not_supported;
2305                 break;
2306         case REQ_OP_ZONE_RESET:
2307                 if (!blk_queue_is_zoned(q))
2308                         goto not_supported;
2309                 break;
2310         case REQ_OP_WRITE_ZEROES:
2311                 if (!q->limits.max_write_zeroes_sectors)
2312                         goto not_supported;
2313                 break;
2314         default:
2315                 break;
2316         }
2317
2318         /*
2319          * Various block parts want %current->io_context and lazy ioc
2320          * allocation ends up trading a lot of pain for a small amount of
2321          * memory.  Just allocate it upfront.  This may fail and block
2322          * layer knows how to live with it.
2323          */
2324         create_io_context(GFP_ATOMIC, q->node);
2325
2326         if (!blkcg_bio_issue_check(q, bio))
2327                 return false;
2328
2329         if (!bio_flagged(bio, BIO_TRACE_COMPLETION)) {
2330                 trace_block_bio_queue(q, bio);
2331                 /* Now that enqueuing has been traced, we need to trace
2332                  * completion as well.
2333                  */
2334                 bio_set_flag(bio, BIO_TRACE_COMPLETION);
2335         }
2336         return true;
2337
2338 not_supported:
2339         status = BLK_STS_NOTSUPP;
2340 end_io:
2341         bio->bi_status = status;
2342         bio_endio(bio);
2343         return false;
2344 }
2345
2346 /**
2347  * generic_make_request - hand a buffer to its device driver for I/O
2348  * @bio:  The bio describing the location in memory and on the device.
2349  *
2350  * generic_make_request() is used to make I/O requests of block
2351  * devices. It is passed a &struct bio, which describes the I/O that needs
2352  * to be done.
2353  *
2354  * generic_make_request() does not return any status.  The
2355  * success/failure status of the request, along with notification of
2356  * completion, is delivered asynchronously through the bio->bi_end_io
2357  * function described (one day) else where.
2358  *
2359  * The caller of generic_make_request must make sure that bi_io_vec
2360  * are set to describe the memory buffer, and that bi_dev and bi_sector are
2361  * set to describe the device address, and the
2362  * bi_end_io and optionally bi_private are set to describe how
2363  * completion notification should be signaled.
2364  *
2365  * generic_make_request and the drivers it calls may use bi_next if this
2366  * bio happens to be merged with someone else, and may resubmit the bio to
2367  * a lower device by calling into generic_make_request recursively, which
2368  * means the bio should NOT be touched after the call to ->make_request_fn.
2369  */
2370 blk_qc_t generic_make_request(struct bio *bio)
2371 {
2372         /*
2373          * bio_list_on_stack[0] contains bios submitted by the current
2374          * make_request_fn.
2375          * bio_list_on_stack[1] contains bios that were submitted before
2376          * the current make_request_fn, but that haven't been processed
2377          * yet.
2378          */
2379         struct bio_list bio_list_on_stack[2];
2380         blk_mq_req_flags_t flags = 0;
2381         struct request_queue *q = bio->bi_disk->queue;
2382         blk_qc_t ret = BLK_QC_T_NONE;
2383
2384         if (bio->bi_opf & REQ_NOWAIT)
2385                 flags = BLK_MQ_REQ_NOWAIT;
2386         if (bio_flagged(bio, BIO_QUEUE_ENTERED))
2387                 blk_queue_enter_live(q);
2388         else if (blk_queue_enter(q, flags) < 0) {
2389                 if (!blk_queue_dying(q) && (bio->bi_opf & REQ_NOWAIT))
2390                         bio_wouldblock_error(bio);
2391                 else
2392                         bio_io_error(bio);
2393                 return ret;
2394         }
2395
2396         if (!generic_make_request_checks(bio))
2397                 goto out;
2398
2399         /*
2400          * We only want one ->make_request_fn to be active at a time, else
2401          * stack usage with stacked devices could be a problem.  So use
2402          * current->bio_list to keep a list of requests submited by a
2403          * make_request_fn function.  current->bio_list is also used as a
2404          * flag to say if generic_make_request is currently active in this
2405          * task or not.  If it is NULL, then no make_request is active.  If
2406          * it is non-NULL, then a make_request is active, and new requests
2407          * should be added at the tail
2408          */
2409         if (current->bio_list) {
2410                 bio_list_add(&current->bio_list[0], bio);
2411                 goto out;
2412         }
2413
2414         /* following loop may be a bit non-obvious, and so deserves some
2415          * explanation.
2416          * Before entering the loop, bio->bi_next is NULL (as all callers
2417          * ensure that) so we have a list with a single bio.
2418          * We pretend that we have just taken it off a longer list, so
2419          * we assign bio_list to a pointer to the bio_list_on_stack,
2420          * thus initialising the bio_list of new bios to be
2421          * added.  ->make_request() may indeed add some more bios
2422          * through a recursive call to generic_make_request.  If it
2423          * did, we find a non-NULL value in bio_list and re-enter the loop
2424          * from the top.  In this case we really did just take the bio
2425          * of the top of the list (no pretending) and so remove it from
2426          * bio_list, and call into ->make_request() again.
2427          */
2428         BUG_ON(bio->bi_next);
2429         bio_list_init(&bio_list_on_stack[0]);
2430         current->bio_list = bio_list_on_stack;
2431         do {
2432                 bool enter_succeeded = true;
2433
2434                 if (unlikely(q != bio->bi_disk->queue)) {
2435                         if (q)
2436                                 blk_queue_exit(q);
2437                         q = bio->bi_disk->queue;
2438                         flags = 0;
2439                         if (bio->bi_opf & REQ_NOWAIT)
2440                                 flags = BLK_MQ_REQ_NOWAIT;
2441                         if (blk_queue_enter(q, flags) < 0) {
2442                                 enter_succeeded = false;
2443                                 q = NULL;
2444                         }
2445                 }
2446
2447                 if (enter_succeeded) {
2448                         struct bio_list lower, same;
2449
2450                         /* Create a fresh bio_list for all subordinate requests */
2451                         bio_list_on_stack[1] = bio_list_on_stack[0];
2452                         bio_list_init(&bio_list_on_stack[0]);
2453                         ret = q->make_request_fn(q, bio);
2454
2455                         /* sort new bios into those for a lower level
2456                          * and those for the same level
2457                          */
2458                         bio_list_init(&lower);
2459                         bio_list_init(&same);
2460                         while ((bio = bio_list_pop(&bio_list_on_stack[0])) != NULL)
2461                                 if (q == bio->bi_disk->queue)
2462                                         bio_list_add(&same, bio);
2463                                 else
2464                                         bio_list_add(&lower, bio);
2465                         /* now assemble so we handle the lowest level first */
2466                         bio_list_merge(&bio_list_on_stack[0], &lower);
2467                         bio_list_merge(&bio_list_on_stack[0], &same);
2468                         bio_list_merge(&bio_list_on_stack[0], &bio_list_on_stack[1]);
2469                 } else {
2470                         if (unlikely(!blk_queue_dying(q) &&
2471                                         (bio->bi_opf & REQ_NOWAIT)))
2472                                 bio_wouldblock_error(bio);
2473                         else
2474                                 bio_io_error(bio);
2475                 }
2476                 bio = bio_list_pop(&bio_list_on_stack[0]);
2477         } while (bio);
2478         current->bio_list = NULL; /* deactivate */
2479
2480 out:
2481         if (q)
2482                 blk_queue_exit(q);
2483         return ret;
2484 }
2485 EXPORT_SYMBOL(generic_make_request);
2486
2487 /**
2488  * direct_make_request - hand a buffer directly to its device driver for I/O
2489  * @bio:  The bio describing the location in memory and on the device.
2490  *
2491  * This function behaves like generic_make_request(), but does not protect
2492  * against recursion.  Must only be used if the called driver is known
2493  * to not call generic_make_request (or direct_make_request) again from
2494  * its make_request function.  (Calling direct_make_request again from
2495  * a workqueue is perfectly fine as that doesn't recurse).
2496  */
2497 blk_qc_t direct_make_request(struct bio *bio)
2498 {
2499         struct request_queue *q = bio->bi_disk->queue;
2500         bool nowait = bio->bi_opf & REQ_NOWAIT;
2501         blk_qc_t ret;
2502
2503         if (!generic_make_request_checks(bio))
2504                 return BLK_QC_T_NONE;
2505
2506         if (unlikely(blk_queue_enter(q, nowait ? BLK_MQ_REQ_NOWAIT : 0))) {
2507                 if (nowait && !blk_queue_dying(q))
2508                         bio->bi_status = BLK_STS_AGAIN;
2509                 else
2510                         bio->bi_status = BLK_STS_IOERR;
2511                 bio_endio(bio);
2512                 return BLK_QC_T_NONE;
2513         }
2514
2515         ret = q->make_request_fn(q, bio);
2516         blk_queue_exit(q);
2517         return ret;
2518 }
2519 EXPORT_SYMBOL_GPL(direct_make_request);
2520
2521 /**
2522  * submit_bio - submit a bio to the block device layer for I/O
2523  * @bio: The &struct bio which describes the I/O
2524  *
2525  * submit_bio() is very similar in purpose to generic_make_request(), and
2526  * uses that function to do most of the work. Both are fairly rough
2527  * interfaces; @bio must be presetup and ready for I/O.
2528  *
2529  */
2530 blk_qc_t submit_bio(struct bio *bio)
2531 {
2532         /*
2533          * If it's a regular read/write or a barrier with data attached,
2534          * go through the normal accounting stuff before submission.
2535          */
2536         if (bio_has_data(bio)) {
2537                 unsigned int count;
2538
2539                 if (unlikely(bio_op(bio) == REQ_OP_WRITE_SAME))
2540                         count = queue_logical_block_size(bio->bi_disk->queue) >> 9;
2541                 else
2542                         count = bio_sectors(bio);
2543
2544                 if (op_is_write(bio_op(bio))) {
2545                         count_vm_events(PGPGOUT, count);
2546                 } else {
2547                         task_io_account_read(bio->bi_iter.bi_size);
2548                         count_vm_events(PGPGIN, count);
2549                 }
2550
2551                 if (unlikely(block_dump)) {
2552                         char b[BDEVNAME_SIZE];
2553                         printk(KERN_DEBUG "%s(%d): %s block %Lu on %s (%u sectors)\n",
2554                         current->comm, task_pid_nr(current),
2555                                 op_is_write(bio_op(bio)) ? "WRITE" : "READ",
2556                                 (unsigned long long)bio->bi_iter.bi_sector,
2557                                 bio_devname(bio, b), count);
2558                 }
2559         }
2560
2561         return generic_make_request(bio);
2562 }
2563 EXPORT_SYMBOL(submit_bio);
2564
2565 bool blk_poll(struct request_queue *q, blk_qc_t cookie)
2566 {
2567         if (!q->poll_fn || !blk_qc_t_valid(cookie))
2568                 return false;
2569
2570         if (current->plug)
2571                 blk_flush_plug_list(current->plug, false);
2572         return q->poll_fn(q, cookie);
2573 }
2574 EXPORT_SYMBOL_GPL(blk_poll);
2575
2576 /**
2577  * blk_cloned_rq_check_limits - Helper function to check a cloned request
2578  *                              for new the queue limits
2579  * @q:  the queue
2580  * @rq: the request being checked
2581  *
2582  * Description:
2583  *    @rq may have been made based on weaker limitations of upper-level queues
2584  *    in request stacking drivers, and it may violate the limitation of @q.
2585  *    Since the block layer and the underlying device driver trust @rq
2586  *    after it is inserted to @q, it should be checked against @q before
2587  *    the insertion using this generic function.
2588  *
2589  *    Request stacking drivers like request-based dm may change the queue
2590  *    limits when retrying requests on other queues. Those requests need
2591  *    to be checked against the new queue limits again during dispatch.
2592  */
2593 static int blk_cloned_rq_check_limits(struct request_queue *q,
2594                                       struct request *rq)
2595 {
2596         if (blk_rq_sectors(rq) > blk_queue_get_max_sectors(q, req_op(rq))) {
2597                 printk(KERN_ERR "%s: over max size limit.\n", __func__);
2598                 return -EIO;
2599         }
2600
2601         /*
2602          * queue's settings related to segment counting like q->bounce_pfn
2603          * may differ from that of other stacking queues.
2604          * Recalculate it to check the request correctly on this queue's
2605          * limitation.
2606          */
2607         blk_recalc_rq_segments(rq);
2608         if (rq->nr_phys_segments > queue_max_segments(q)) {
2609                 printk(KERN_ERR "%s: over max segments limit.\n", __func__);
2610                 return -EIO;
2611         }
2612
2613         return 0;
2614 }
2615
2616 /**
2617  * blk_insert_cloned_request - Helper for stacking drivers to submit a request
2618  * @q:  the queue to submit the request
2619  * @rq: the request being queued
2620  */
2621 blk_status_t blk_insert_cloned_request(struct request_queue *q, struct request *rq)
2622 {
2623         unsigned long flags;
2624         int where = ELEVATOR_INSERT_BACK;
2625
2626         if (blk_cloned_rq_check_limits(q, rq))
2627                 return BLK_STS_IOERR;
2628
2629         if (rq->rq_disk &&
2630             should_fail_request(&rq->rq_disk->part0, blk_rq_bytes(rq)))
2631                 return BLK_STS_IOERR;
2632
2633         if (q->mq_ops) {
2634                 if (blk_queue_io_stat(q))
2635                         blk_account_io_start(rq, true);
2636                 /*
2637                  * Since we have a scheduler attached on the top device,
2638                  * bypass a potential scheduler on the bottom device for
2639                  * insert.
2640                  */
2641                 return blk_mq_request_issue_directly(rq);
2642         }
2643
2644         spin_lock_irqsave(q->queue_lock, flags);
2645         if (unlikely(blk_queue_dying(q))) {
2646                 spin_unlock_irqrestore(q->queue_lock, flags);
2647                 return BLK_STS_IOERR;
2648         }
2649
2650         /*
2651          * Submitting request must be dequeued before calling this function
2652          * because it will be linked to another request_queue
2653          */
2654         BUG_ON(blk_queued_rq(rq));
2655
2656         if (op_is_flush(rq->cmd_flags))
2657                 where = ELEVATOR_INSERT_FLUSH;
2658
2659         add_acct_request(q, rq, where);
2660         if (where == ELEVATOR_INSERT_FLUSH)
2661                 __blk_run_queue(q);
2662         spin_unlock_irqrestore(q->queue_lock, flags);
2663
2664         return BLK_STS_OK;
2665 }
2666 EXPORT_SYMBOL_GPL(blk_insert_cloned_request);
2667
2668 /**
2669  * blk_rq_err_bytes - determine number of bytes till the next failure boundary
2670  * @rq: request to examine
2671  *
2672  * Description:
2673  *     A request could be merge of IOs which require different failure
2674  *     handling.  This function determines the number of bytes which
2675  *     can be failed from the beginning of the request without
2676  *     crossing into area which need to be retried further.
2677  *
2678  * Return:
2679  *     The number of bytes to fail.
2680  */
2681 unsigned int blk_rq_err_bytes(const struct request *rq)
2682 {
2683         unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK;
2684         unsigned int bytes = 0;
2685         struct bio *bio;
2686
2687         if (!(rq->rq_flags & RQF_MIXED_MERGE))
2688                 return blk_rq_bytes(rq);
2689
2690         /*
2691          * Currently the only 'mixing' which can happen is between
2692          * different fastfail types.  We can safely fail portions
2693          * which have all the failfast bits that the first one has -
2694          * the ones which are at least as eager to fail as the first
2695          * one.
2696          */
2697         for (bio = rq->bio; bio; bio = bio->bi_next) {
2698                 if ((bio->bi_opf & ff) != ff)
2699                         break;
2700                 bytes += bio->bi_iter.bi_size;
2701         }
2702
2703         /* this could lead to infinite loop */
2704         BUG_ON(blk_rq_bytes(rq) && !bytes);
2705         return bytes;
2706 }
2707 EXPORT_SYMBOL_GPL(blk_rq_err_bytes);
2708
2709 void blk_account_io_completion(struct request *req, unsigned int bytes)
2710 {
2711         if (blk_do_io_stat(req)) {
2712                 const int sgrp = op_stat_group(req_op(req));
2713                 struct hd_struct *part;
2714                 int cpu;
2715
2716                 cpu = part_stat_lock();
2717                 part = req->part;
2718                 part_stat_add(cpu, part, sectors[sgrp], bytes >> 9);
2719                 part_stat_unlock();
2720         }
2721 }
2722
2723 void blk_account_io_done(struct request *req, u64 now)
2724 {
2725         /*
2726          * Account IO completion.  flush_rq isn't accounted as a
2727          * normal IO on queueing nor completion.  Accounting the
2728          * containing request is enough.
2729          */
2730         if (blk_do_io_stat(req) && !(req->rq_flags & RQF_FLUSH_SEQ)) {
2731                 const int sgrp = op_stat_group(req_op(req));
2732                 struct hd_struct *part;
2733                 int cpu;
2734
2735                 cpu = part_stat_lock();
2736                 part = req->part;
2737
2738                 part_stat_inc(cpu, part, ios[sgrp]);
2739                 part_stat_add(cpu, part, nsecs[sgrp], now - req->start_time_ns);
2740                 part_round_stats(req->q, cpu, part);
2741                 part_dec_in_flight(req->q, part, rq_data_dir(req));
2742
2743                 hd_struct_put(part);
2744                 part_stat_unlock();
2745         }
2746 }
2747
2748 void blk_account_io_start(struct request *rq, bool new_io)
2749 {
2750         struct hd_struct *part;
2751         int rw = rq_data_dir(rq);
2752         int cpu;
2753
2754         if (!blk_do_io_stat(rq))
2755                 return;
2756
2757         cpu = part_stat_lock();
2758
2759         if (!new_io) {
2760                 part = rq->part;
2761                 part_stat_inc(cpu, part, merges[rw]);
2762         } else {
2763                 part = disk_map_sector_rcu(rq->rq_disk, blk_rq_pos(rq));
2764                 if (!hd_struct_try_get(part)) {
2765                         /*
2766                          * The partition is already being removed,
2767                          * the request will be accounted on the disk only
2768                          *
2769                          * We take a reference on disk->part0 although that
2770                          * partition will never be deleted, so we can treat
2771                          * it as any other partition.
2772                          */
2773                         part = &rq->rq_disk->part0;
2774                         hd_struct_get(part);
2775                 }
2776                 part_round_stats(rq->q, cpu, part);
2777                 part_inc_in_flight(rq->q, part, rw);
2778                 rq->part = part;
2779         }
2780
2781         part_stat_unlock();
2782 }
2783
2784 static struct request *elv_next_request(struct request_queue *q)
2785 {
2786         struct request *rq;
2787         struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL);
2788
2789         WARN_ON_ONCE(q->mq_ops);
2790
2791         while (1) {
2792                 list_for_each_entry(rq, &q->queue_head, queuelist) {
2793 #ifdef CONFIG_PM
2794                         /*
2795                          * If a request gets queued in state RPM_SUSPENDED
2796                          * then that's a kernel bug.
2797                          */
2798                         WARN_ON_ONCE(q->rpm_status == RPM_SUSPENDED);
2799 #endif
2800                         return rq;
2801                 }
2802
2803                 /*
2804                  * Flush request is running and flush request isn't queueable
2805                  * in the drive, we can hold the queue till flush request is
2806                  * finished. Even we don't do this, driver can't dispatch next
2807                  * requests and will requeue them. And this can improve
2808                  * throughput too. For example, we have request flush1, write1,
2809                  * flush 2. flush1 is dispatched, then queue is hold, write1
2810                  * isn't inserted to queue. After flush1 is finished, flush2
2811                  * will be dispatched. Since disk cache is already clean,
2812                  * flush2 will be finished very soon, so looks like flush2 is
2813                  * folded to flush1.
2814                  * Since the queue is hold, a flag is set to indicate the queue
2815                  * should be restarted later. Please see flush_end_io() for
2816                  * details.
2817                  */
2818                 if (fq->flush_pending_idx != fq->flush_running_idx &&
2819                                 !queue_flush_queueable(q)) {
2820                         fq->flush_queue_delayed = 1;
2821                         return NULL;
2822                 }
2823                 if (unlikely(blk_queue_bypass(q)) ||
2824                     !q->elevator->type->ops.sq.elevator_dispatch_fn(q, 0))
2825                         return NULL;
2826         }
2827 }
2828
2829 /**
2830  * blk_peek_request - peek at the top of a request queue
2831  * @q: request queue to peek at
2832  *
2833  * Description:
2834  *     Return the request at the top of @q.  The returned request
2835  *     should be started using blk_start_request() before LLD starts
2836  *     processing it.
2837  *
2838  * Return:
2839  *     Pointer to the request at the top of @q if available.  Null
2840  *     otherwise.
2841  */
2842 struct request *blk_peek_request(struct request_queue *q)
2843 {
2844         struct request *rq;
2845         int ret;
2846
2847         lockdep_assert_held(q->queue_lock);
2848         WARN_ON_ONCE(q->mq_ops);
2849
2850         while ((rq = elv_next_request(q)) != NULL) {
2851                 if (!(rq->rq_flags & RQF_STARTED)) {
2852                         /*
2853                          * This is the first time the device driver
2854                          * sees this request (possibly after
2855                          * requeueing).  Notify IO scheduler.
2856                          */
2857                         if (rq->rq_flags & RQF_SORTED)
2858                                 elv_activate_rq(q, rq);
2859
2860                         /*
2861                          * just mark as started even if we don't start
2862                          * it, a request that has been delayed should
2863                          * not be passed by new incoming requests
2864                          */
2865                         rq->rq_flags |= RQF_STARTED;
2866                         trace_block_rq_issue(q, rq);
2867                 }
2868
2869                 if (!q->boundary_rq || q->boundary_rq == rq) {
2870                         q->end_sector = rq_end_sector(rq);
2871                         q->boundary_rq = NULL;
2872                 }
2873
2874                 if (rq->rq_flags & RQF_DONTPREP)
2875                         break;
2876
2877                 if (q->dma_drain_size && blk_rq_bytes(rq)) {
2878                         /*
2879                          * make sure space for the drain appears we
2880                          * know we can do this because max_hw_segments
2881                          * has been adjusted to be one fewer than the
2882                          * device can handle
2883                          */
2884                         rq->nr_phys_segments++;
2885                 }
2886
2887                 if (!q->prep_rq_fn)
2888                         break;
2889
2890                 ret = q->prep_rq_fn(q, rq);
2891                 if (ret == BLKPREP_OK) {
2892                         break;
2893                 } else if (ret == BLKPREP_DEFER) {
2894                         /*
2895                          * the request may have been (partially) prepped.
2896                          * we need to keep this request in the front to
2897                          * avoid resource deadlock.  RQF_STARTED will
2898                          * prevent other fs requests from passing this one.
2899                          */
2900                         if (q->dma_drain_size && blk_rq_bytes(rq) &&
2901                             !(rq->rq_flags & RQF_DONTPREP)) {
2902                                 /*
2903                                  * remove the space for the drain we added
2904                                  * so that we don't add it again
2905                                  */
2906                                 --rq->nr_phys_segments;
2907                         }
2908
2909                         rq = NULL;
2910                         break;
2911                 } else if (ret == BLKPREP_KILL || ret == BLKPREP_INVALID) {
2912                         rq->rq_flags |= RQF_QUIET;
2913                         /*
2914                          * Mark this request as started so we don't trigger
2915                          * any debug logic in the end I/O path.
2916                          */
2917                         blk_start_request(rq);
2918                         __blk_end_request_all(rq, ret == BLKPREP_INVALID ?
2919                                         BLK_STS_TARGET : BLK_STS_IOERR);
2920                 } else {
2921                         printk(KERN_ERR "%s: bad return=%d\n", __func__, ret);
2922                         break;
2923                 }
2924         }
2925
2926         return rq;
2927 }
2928 EXPORT_SYMBOL(blk_peek_request);
2929
2930 static void blk_dequeue_request(struct request *rq)
2931 {
2932         struct request_queue *q = rq->q;
2933
2934         BUG_ON(list_empty(&rq->queuelist));
2935         BUG_ON(ELV_ON_HASH(rq));
2936
2937         list_del_init(&rq->queuelist);
2938
2939         /*
2940          * the time frame between a request being removed from the lists
2941          * and to it is freed is accounted as io that is in progress at
2942          * the driver side.
2943          */
2944         if (blk_account_rq(rq))
2945                 q->in_flight[rq_is_sync(rq)]++;
2946 }
2947
2948 /**
2949  * blk_start_request - start request processing on the driver
2950  * @req: request to dequeue
2951  *
2952  * Description:
2953  *     Dequeue @req and start timeout timer on it.  This hands off the
2954  *     request to the driver.
2955  */
2956 void blk_start_request(struct request *req)
2957 {
2958         lockdep_assert_held(req->q->queue_lock);
2959         WARN_ON_ONCE(req->q->mq_ops);
2960
2961         blk_dequeue_request(req);
2962
2963         if (test_bit(QUEUE_FLAG_STATS, &req->q->queue_flags)) {
2964                 req->io_start_time_ns = ktime_get_ns();
2965 #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
2966                 req->throtl_size = blk_rq_sectors(req);
2967 #endif
2968                 req->rq_flags |= RQF_STATS;
2969                 rq_qos_issue(req->q, req);
2970         }
2971
2972         BUG_ON(blk_rq_is_complete(req));
2973         blk_add_timer(req);
2974 }
2975 EXPORT_SYMBOL(blk_start_request);
2976
2977 /**
2978  * blk_fetch_request - fetch a request from a request queue
2979  * @q: request queue to fetch a request from
2980  *
2981  * Description:
2982  *     Return the request at the top of @q.  The request is started on
2983  *     return and LLD can start processing it immediately.
2984  *
2985  * Return:
2986  *     Pointer to the request at the top of @q if available.  Null
2987  *     otherwise.
2988  */
2989 struct request *blk_fetch_request(struct request_queue *q)
2990 {
2991         struct request *rq;
2992
2993         lockdep_assert_held(q->queue_lock);
2994         WARN_ON_ONCE(q->mq_ops);
2995
2996         rq = blk_peek_request(q);
2997         if (rq)
2998                 blk_start_request(rq);
2999         return rq;
3000 }
3001 EXPORT_SYMBOL(blk_fetch_request);
3002
3003 /*
3004  * Steal bios from a request and add them to a bio list.
3005  * The request must not have been partially completed before.
3006  */
3007 void blk_steal_bios(struct bio_list *list, struct request *rq)
3008 {
3009         if (rq->bio) {
3010                 if (list->tail)
3011                         list->tail->bi_next = rq->bio;
3012                 else
3013                         list->head = rq->bio;
3014                 list->tail = rq->biotail;
3015
3016                 rq->bio = NULL;
3017                 rq->biotail = NULL;
3018         }
3019
3020         rq->__data_len = 0;
3021 }
3022 EXPORT_SYMBOL_GPL(blk_steal_bios);
3023
3024 /**
3025  * blk_update_request - Special helper function for request stacking drivers
3026  * @req:      the request being processed
3027  * @error:    block status code
3028  * @nr_bytes: number of bytes to complete @req
3029  *
3030  * Description:
3031  *     Ends I/O on a number of bytes attached to @req, but doesn't complete
3032  *     the request structure even if @req doesn't have leftover.
3033  *     If @req has leftover, sets it up for the next range of segments.
3034  *
3035  *     This special helper function is only for request stacking drivers
3036  *     (e.g. request-based dm) so that they can handle partial completion.
3037  *     Actual device drivers should use blk_end_request instead.
3038  *
3039  *     Passing the result of blk_rq_bytes() as @nr_bytes guarantees
3040  *     %false return from this function.
3041  *
3042  * Note:
3043  *      The RQF_SPECIAL_PAYLOAD flag is ignored on purpose in both
3044  *      blk_rq_bytes() and in blk_update_request().
3045  *
3046  * Return:
3047  *     %false - this request doesn't have any more data
3048  *     %true  - this request has more data
3049  **/
3050 bool blk_update_request(struct request *req, blk_status_t error,
3051                 unsigned int nr_bytes)
3052 {
3053         int total_bytes;
3054
3055         trace_block_rq_complete(req, blk_status_to_errno(error), nr_bytes);
3056
3057         if (!req->bio)
3058                 return false;
3059
3060         if (unlikely(error && !blk_rq_is_passthrough(req) &&
3061                      !(req->rq_flags & RQF_QUIET)))
3062                 print_req_error(req, error);
3063
3064         blk_account_io_completion(req, nr_bytes);
3065
3066         total_bytes = 0;
3067         while (req->bio) {
3068                 struct bio *bio = req->bio;
3069                 unsigned bio_bytes = min(bio->bi_iter.bi_size, nr_bytes);
3070
3071                 if (bio_bytes == bio->bi_iter.bi_size)
3072                         req->bio = bio->bi_next;
3073
3074                 /* Completion has already been traced */
3075                 bio_clear_flag(bio, BIO_TRACE_COMPLETION);
3076                 req_bio_endio(req, bio, bio_bytes, error);
3077
3078                 total_bytes += bio_bytes;
3079                 nr_bytes -= bio_bytes;
3080
3081                 if (!nr_bytes)
3082                         break;
3083         }
3084
3085         /*
3086          * completely done
3087          */
3088         if (!req->bio) {
3089                 /*
3090                  * Reset counters so that the request stacking driver
3091                  * can find how many bytes remain in the request
3092                  * later.
3093                  */
3094                 req->__data_len = 0;
3095                 return false;
3096         }
3097
3098         req->__data_len -= total_bytes;
3099
3100         /* update sector only for requests with clear definition of sector */
3101         if (!blk_rq_is_passthrough(req))
3102                 req->__sector += total_bytes >> 9;
3103
3104         /* mixed attributes always follow the first bio */
3105         if (req->rq_flags & RQF_MIXED_MERGE) {
3106                 req->cmd_flags &= ~REQ_FAILFAST_MASK;
3107                 req->cmd_flags |= req->bio->bi_opf & REQ_FAILFAST_MASK;
3108         }
3109
3110         if (!(req->rq_flags & RQF_SPECIAL_PAYLOAD)) {
3111                 /*
3112                  * If total number of sectors is less than the first segment
3113                  * size, something has gone terribly wrong.
3114                  */
3115                 if (blk_rq_bytes(req) < blk_rq_cur_bytes(req)) {
3116                         blk_dump_rq_flags(req, "request botched");
3117                         req->__data_len = blk_rq_cur_bytes(req);
3118                 }
3119
3120                 /* recalculate the number of segments */
3121                 blk_recalc_rq_segments(req);
3122         }
3123
3124         return true;
3125 }
3126 EXPORT_SYMBOL_GPL(blk_update_request);
3127
3128 static bool blk_update_bidi_request(struct request *rq, blk_status_t error,
3129                                     unsigned int nr_bytes,
3130                                     unsigned int bidi_bytes)
3131 {
3132         if (blk_update_request(rq, error, nr_bytes))
3133                 return true;
3134
3135         /* Bidi request must be completed as a whole */
3136         if (unlikely(blk_bidi_rq(rq)) &&
3137             blk_update_request(rq->next_rq, error, bidi_bytes))
3138                 return true;
3139
3140         if (blk_queue_add_random(rq->q))
3141                 add_disk_randomness(rq->rq_disk);
3142
3143         return false;
3144 }
3145
3146 /**
3147  * blk_unprep_request - unprepare a request
3148  * @req:        the request
3149  *
3150  * This function makes a request ready for complete resubmission (or
3151  * completion).  It happens only after all error handling is complete,
3152  * so represents the appropriate moment to deallocate any resources
3153  * that were allocated to the request in the prep_rq_fn.  The queue
3154  * lock is held when calling this.
3155  */
3156 void blk_unprep_request(struct request *req)
3157 {
3158         struct request_queue *q = req->q;
3159
3160         req->rq_flags &= ~RQF_DONTPREP;
3161         if (q->unprep_rq_fn)
3162                 q->unprep_rq_fn(q, req);
3163 }
3164 EXPORT_SYMBOL_GPL(blk_unprep_request);
3165
3166 void blk_finish_request(struct request *req, blk_status_t error)
3167 {
3168         struct request_queue *q = req->q;
3169         u64 now = ktime_get_ns();
3170
3171         lockdep_assert_held(req->q->queue_lock);
3172         WARN_ON_ONCE(q->mq_ops);
3173
3174         if (req->rq_flags & RQF_STATS)
3175                 blk_stat_add(req, now);
3176
3177         if (req->rq_flags & RQF_QUEUED)
3178                 blk_queue_end_tag(q, req);
3179
3180         BUG_ON(blk_queued_rq(req));
3181
3182         if (unlikely(laptop_mode) && !blk_rq_is_passthrough(req))
3183                 laptop_io_completion(req->q->backing_dev_info);
3184
3185         blk_delete_timer(req);
3186
3187         if (req->rq_flags & RQF_DONTPREP)
3188                 blk_unprep_request(req);
3189
3190         blk_account_io_done(req, now);
3191
3192         if (req->end_io) {
3193                 rq_qos_done(q, req);
3194                 req->end_io(req, error);
3195         } else {
3196                 if (blk_bidi_rq(req))
3197                         __blk_put_request(req->next_rq->q, req->next_rq);
3198
3199                 __blk_put_request(q, req);
3200         }
3201 }
3202 EXPORT_SYMBOL(blk_finish_request);
3203
3204 /**
3205  * blk_end_bidi_request - Complete a bidi request
3206  * @rq:         the request to complete
3207  * @error:      block status code
3208  * @nr_bytes:   number of bytes to complete @rq
3209  * @bidi_bytes: number of bytes to complete @rq->next_rq
3210  *
3211  * Description:
3212  *     Ends I/O on a number of bytes attached to @rq and @rq->next_rq.
3213  *     Drivers that supports bidi can safely call this member for any
3214  *     type of request, bidi or uni.  In the later case @bidi_bytes is
3215  *     just ignored.
3216  *
3217  * Return:
3218  *     %false - we are done with this request
3219  *     %true  - still buffers pending for this request
3220  **/
3221 static bool blk_end_bidi_request(struct request *rq, blk_status_t error,
3222                                  unsigned int nr_bytes, unsigned int bidi_bytes)
3223 {
3224         struct request_queue *q = rq->q;
3225         unsigned long flags;
3226
3227         WARN_ON_ONCE(q->mq_ops);
3228
3229         if (blk_update_bidi_request(rq, error, nr_bytes, bidi_bytes))
3230                 return true;
3231
3232         spin_lock_irqsave(q->queue_lock, flags);
3233         blk_finish_request(rq, error);
3234         spin_unlock_irqrestore(q->queue_lock, flags);
3235
3236         return false;
3237 }
3238
3239 /**
3240  * __blk_end_bidi_request - Complete a bidi request with queue lock held
3241  * @rq:         the request to complete
3242  * @error:      block status code
3243  * @nr_bytes:   number of bytes to complete @rq
3244  * @bidi_bytes: number of bytes to complete @rq->next_rq
3245  *
3246  * Description:
3247  *     Identical to blk_end_bidi_request() except that queue lock is
3248  *     assumed to be locked on entry and remains so on return.
3249  *
3250  * Return:
3251  *     %false - we are done with this request
3252  *     %true  - still buffers pending for this request
3253  **/
3254 static bool __blk_end_bidi_request(struct request *rq, blk_status_t error,
3255                                    unsigned int nr_bytes, unsigned int bidi_bytes)
3256 {
3257         lockdep_assert_held(rq->q->queue_lock);
3258         WARN_ON_ONCE(rq->q->mq_ops);
3259
3260         if (blk_update_bidi_request(rq, error, nr_bytes, bidi_bytes))
3261                 return true;
3262
3263         blk_finish_request(rq, error);
3264
3265         return false;
3266 }
3267
3268 /**
3269  * blk_end_request - Helper function for drivers to complete the request.
3270  * @rq:       the request being processed
3271  * @error:    block status code
3272  * @nr_bytes: number of bytes to complete
3273  *
3274  * Description:
3275  *     Ends I/O on a number of bytes attached to @rq.
3276  *     If @rq has leftover, sets it up for the next range of segments.
3277  *
3278  * Return:
3279  *     %false - we are done with this request
3280  *     %true  - still buffers pending for this request
3281  **/
3282 bool blk_end_request(struct request *rq, blk_status_t error,
3283                 unsigned int nr_bytes)
3284 {
3285         WARN_ON_ONCE(rq->q->mq_ops);
3286         return blk_end_bidi_request(rq, error, nr_bytes, 0);
3287 }
3288 EXPORT_SYMBOL(blk_end_request);
3289
3290 /**
3291  * blk_end_request_all - Helper function for drives to finish the request.
3292  * @rq: the request to finish
3293  * @error: block status code
3294  *
3295  * Description:
3296  *     Completely finish @rq.
3297  */
3298 void blk_end_request_all(struct request *rq, blk_status_t error)
3299 {
3300         bool pending;
3301         unsigned int bidi_bytes = 0;
3302
3303         if (unlikely(blk_bidi_rq(rq)))
3304                 bidi_bytes = blk_rq_bytes(rq->next_rq);
3305
3306         pending = blk_end_bidi_request(rq, error, blk_rq_bytes(rq), bidi_bytes);
3307         BUG_ON(pending);
3308 }
3309 EXPORT_SYMBOL(blk_end_request_all);
3310
3311 /**
3312  * __blk_end_request - Helper function for drivers to complete the request.
3313  * @rq:       the request being processed
3314  * @error:    block status code
3315  * @nr_bytes: number of bytes to complete
3316  *
3317  * Description:
3318  *     Must be called with queue lock held unlike blk_end_request().
3319  *
3320  * Return:
3321  *     %false - we are done with this request
3322  *     %true  - still buffers pending for this request
3323  **/
3324 bool __blk_end_request(struct request *rq, blk_status_t error,
3325                 unsigned int nr_bytes)
3326 {
3327         lockdep_assert_held(rq->q->queue_lock);
3328         WARN_ON_ONCE(rq->q->mq_ops);
3329
3330         return __blk_end_bidi_request(rq, error, nr_bytes, 0);
3331 }
3332 EXPORT_SYMBOL(__blk_end_request);
3333
3334 /**
3335  * __blk_end_request_all - Helper function for drives to finish the request.
3336  * @rq: the request to finish
3337  * @error:    block status code
3338  *
3339  * Description:
3340  *     Completely finish @rq.  Must be called with queue lock held.
3341  */
3342 void __blk_end_request_all(struct request *rq, blk_status_t error)
3343 {
3344         bool pending;
3345         unsigned int bidi_bytes = 0;
3346
3347         lockdep_assert_held(rq->q->queue_lock);
3348         WARN_ON_ONCE(rq->q->mq_ops);
3349
3350         if (unlikely(blk_bidi_rq(rq)))
3351                 bidi_bytes = blk_rq_bytes(rq->next_rq);
3352
3353         pending = __blk_end_bidi_request(rq, error, blk_rq_bytes(rq), bidi_bytes);
3354         BUG_ON(pending);
3355 }
3356 EXPORT_SYMBOL(__blk_end_request_all);
3357
3358 /**
3359  * __blk_end_request_cur - Helper function to finish the current request chunk.
3360  * @rq: the request to finish the current chunk for
3361  * @error:    block status code
3362  *
3363  * Description:
3364  *     Complete the current consecutively mapped chunk from @rq.  Must
3365  *     be called with queue lock held.
3366  *
3367  * Return:
3368  *     %false - we are done with this request
3369  *     %true  - still buffers pending for this request
3370  */
3371 bool __blk_end_request_cur(struct request *rq, blk_status_t error)
3372 {
3373         return __blk_end_request(rq, error, blk_rq_cur_bytes(rq));
3374 }
3375 EXPORT_SYMBOL(__blk_end_request_cur);
3376
3377 void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
3378                      struct bio *bio)
3379 {
3380         if (bio_has_data(bio))
3381                 rq->nr_phys_segments = bio_phys_segments(q, bio);
3382         else if (bio_op(bio) == REQ_OP_DISCARD)
3383                 rq->nr_phys_segments = 1;
3384
3385         rq->__data_len = bio->bi_iter.bi_size;
3386         rq->bio = rq->biotail = bio;
3387
3388         if (bio->bi_disk)
3389                 rq->rq_disk = bio->bi_disk;
3390 }
3391
3392 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
3393 /**
3394  * rq_flush_dcache_pages - Helper function to flush all pages in a request
3395  * @rq: the request to be flushed
3396  *
3397  * Description:
3398  *     Flush all pages in @rq.
3399  */
3400 void rq_flush_dcache_pages(struct request *rq)
3401 {
3402         struct req_iterator iter;
3403         struct bio_vec bvec;
3404
3405         rq_for_each_segment(bvec, rq, iter)
3406                 flush_dcache_page(bvec.bv_page);
3407 }
3408 EXPORT_SYMBOL_GPL(rq_flush_dcache_pages);
3409 #endif
3410
3411 /**
3412  * blk_lld_busy - Check if underlying low-level drivers of a device are busy
3413  * @q : the queue of the device being checked
3414  *
3415  * Description:
3416  *    Check if underlying low-level drivers of a device are busy.
3417  *    If the drivers want to export their busy state, they must set own
3418  *    exporting function using blk_queue_lld_busy() first.
3419  *
3420  *    Basically, this function is used only by request stacking drivers
3421  *    to stop dispatching requests to underlying devices when underlying
3422  *    devices are busy.  This behavior helps more I/O merging on the queue
3423  *    of the request stacking driver and prevents I/O throughput regression
3424  *    on burst I/O load.
3425  *
3426  * Return:
3427  *    0 - Not busy (The request stacking driver should dispatch request)
3428  *    1 - Busy (The request stacking driver should stop dispatching request)
3429  */
3430 int blk_lld_busy(struct request_queue *q)
3431 {
3432         if (q->lld_busy_fn)
3433                 return q->lld_busy_fn(q);
3434
3435         return 0;
3436 }
3437 EXPORT_SYMBOL_GPL(blk_lld_busy);
3438
3439 /**
3440  * blk_rq_unprep_clone - Helper function to free all bios in a cloned request
3441  * @rq: the clone request to be cleaned up
3442  *
3443  * Description:
3444  *     Free all bios in @rq for a cloned request.
3445  */
3446 void blk_rq_unprep_clone(struct request *rq)
3447 {
3448         struct bio *bio;
3449
3450         while ((bio = rq->bio) != NULL) {
3451                 rq->bio = bio->bi_next;
3452
3453                 bio_put(bio);
3454         }
3455 }
3456 EXPORT_SYMBOL_GPL(blk_rq_unprep_clone);
3457
3458 /*
3459  * Copy attributes of the original request to the clone request.
3460  * The actual data parts (e.g. ->cmd, ->sense) are not copied.
3461  */
3462 static void __blk_rq_prep_clone(struct request *dst, struct request *src)
3463 {
3464         dst->cpu = src->cpu;
3465         dst->__sector = blk_rq_pos(src);
3466         dst->__data_len = blk_rq_bytes(src);
3467         if (src->rq_flags & RQF_SPECIAL_PAYLOAD) {
3468                 dst->rq_flags |= RQF_SPECIAL_PAYLOAD;
3469                 dst->special_vec = src->special_vec;
3470         }
3471         dst->nr_phys_segments = src->nr_phys_segments;
3472         dst->ioprio = src->ioprio;
3473         dst->extra_len = src->extra_len;
3474 }
3475
3476 /**
3477  * blk_rq_prep_clone - Helper function to setup clone request
3478  * @rq: the request to be setup
3479  * @rq_src: original request to be cloned
3480  * @bs: bio_set that bios for clone are allocated from
3481  * @gfp_mask: memory allocation mask for bio
3482  * @bio_ctr: setup function to be called for each clone bio.
3483  *           Returns %0 for success, non %0 for failure.
3484  * @data: private data to be passed to @bio_ctr
3485  *
3486  * Description:
3487  *     Clones bios in @rq_src to @rq, and copies attributes of @rq_src to @rq.
3488  *     The actual data parts of @rq_src (e.g. ->cmd, ->sense)
3489  *     are not copied, and copying such parts is the caller's responsibility.
3490  *     Also, pages which the original bios are pointing to are not copied
3491  *     and the cloned bios just point same pages.
3492  *     So cloned bios must be completed before original bios, which means
3493  *     the caller must complete @rq before @rq_src.
3494  */
3495 int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
3496                       struct bio_set *bs, gfp_t gfp_mask,
3497                       int (*bio_ctr)(struct bio *, struct bio *, void *),
3498                       void *data)
3499 {
3500         struct bio *bio, *bio_src;
3501
3502         if (!bs)
3503                 bs = &fs_bio_set;
3504
3505         __rq_for_each_bio(bio_src, rq_src) {
3506                 bio = bio_clone_fast(bio_src, gfp_mask, bs);
3507                 if (!bio)
3508                         goto free_and_out;
3509
3510                 if (bio_ctr && bio_ctr(bio, bio_src, data))
3511                         goto free_and_out;
3512
3513                 if (rq->bio) {
3514                         rq->biotail->bi_next = bio;
3515                         rq->biotail = bio;
3516                 } else
3517                         rq->bio = rq->biotail = bio;
3518         }
3519
3520         __blk_rq_prep_clone(rq, rq_src);
3521
3522         return 0;
3523
3524 free_and_out:
3525         if (bio)
3526                 bio_put(bio);
3527         blk_rq_unprep_clone(rq);
3528
3529         return -ENOMEM;
3530 }
3531 EXPORT_SYMBOL_GPL(blk_rq_prep_clone);
3532
3533 int kblockd_schedule_work(struct work_struct *work)
3534 {
3535         return queue_work(kblockd_workqueue, work);
3536 }
3537 EXPORT_SYMBOL(kblockd_schedule_work);
3538
3539 int kblockd_schedule_work_on(int cpu, struct work_struct *work)
3540 {
3541         return queue_work_on(cpu, kblockd_workqueue, work);
3542 }
3543 EXPORT_SYMBOL(kblockd_schedule_work_on);
3544
3545 int kblockd_mod_delayed_work_on(int cpu, struct delayed_work *dwork,
3546                                 unsigned long delay)
3547 {
3548         return mod_delayed_work_on(cpu, kblockd_workqueue, dwork, delay);
3549 }
3550 EXPORT_SYMBOL(kblockd_mod_delayed_work_on);
3551
3552 /**
3553  * blk_start_plug - initialize blk_plug and track it inside the task_struct
3554  * @plug:       The &struct blk_plug that needs to be initialized
3555  *
3556  * Description:
3557  *   Tracking blk_plug inside the task_struct will help with auto-flushing the
3558  *   pending I/O should the task end up blocking between blk_start_plug() and
3559  *   blk_finish_plug(). This is important from a performance perspective, but
3560  *   also ensures that we don't deadlock. For instance, if the task is blocking
3561  *   for a memory allocation, memory reclaim could end up wanting to free a
3562  *   page belonging to that request that is currently residing in our private
3563  *   plug. By flushing the pending I/O when the process goes to sleep, we avoid
3564  *   this kind of deadlock.
3565  */
3566 void blk_start_plug(struct blk_plug *plug)
3567 {
3568         struct task_struct *tsk = current;
3569
3570         /*
3571          * If this is a nested plug, don't actually assign it.
3572          */
3573         if (tsk->plug)
3574                 return;
3575
3576         INIT_LIST_HEAD(&plug->list);
3577         INIT_LIST_HEAD(&plug->mq_list);
3578         INIT_LIST_HEAD(&plug->cb_list);
3579         /*
3580          * Store ordering should not be needed here, since a potential
3581          * preempt will imply a full memory barrier
3582          */
3583         tsk->plug = plug;
3584 }
3585 EXPORT_SYMBOL(blk_start_plug);
3586
3587 static int plug_rq_cmp(void *priv, struct list_head *a, struct list_head *b)
3588 {
3589         struct request *rqa = container_of(a, struct request, queuelist);
3590         struct request *rqb = container_of(b, struct request, queuelist);
3591
3592         return !(rqa->q < rqb->q ||
3593                 (rqa->q == rqb->q && blk_rq_pos(rqa) < blk_rq_pos(rqb)));
3594 }
3595
3596 /*
3597  * If 'from_schedule' is true, then postpone the dispatch of requests
3598  * until a safe kblockd context. We due this to avoid accidental big
3599  * additional stack usage in driver dispatch, in places where the originally
3600  * plugger did not intend it.
3601  */
3602 static void queue_unplugged(struct request_queue *q, unsigned int depth,
3603                             bool from_schedule)
3604         __releases(q->queue_lock)
3605 {
3606         lockdep_assert_held(q->queue_lock);
3607
3608         trace_block_unplug(q, depth, !from_schedule);
3609
3610         if (from_schedule)
3611                 blk_run_queue_async(q);
3612         else
3613                 __blk_run_queue(q);
3614         spin_unlock_irq(q->queue_lock);
3615 }
3616
3617 static void flush_plug_callbacks(struct blk_plug *plug, bool from_schedule)
3618 {
3619         LIST_HEAD(callbacks);
3620
3621         while (!list_empty(&plug->cb_list)) {
3622                 list_splice_init(&plug->cb_list, &callbacks);
3623
3624                 while (!list_empty(&callbacks)) {
3625                         struct blk_plug_cb *cb = list_first_entry(&callbacks,
3626                                                           struct blk_plug_cb,
3627                                                           list);
3628                         list_del(&cb->list);
3629                         cb->callback(cb, from_schedule);
3630                 }
3631         }
3632 }
3633
3634 struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug, void *data,
3635                                       int size)
3636 {
3637         struct blk_plug *plug = current->plug;
3638         struct blk_plug_cb *cb;
3639
3640         if (!plug)
3641                 return NULL;
3642
3643         list_for_each_entry(cb, &plug->cb_list, list)
3644                 if (cb->callback == unplug && cb->data == data)
3645                         return cb;
3646
3647         /* Not currently on the callback list */
3648         BUG_ON(size < sizeof(*cb));
3649         cb = kzalloc(size, GFP_ATOMIC);
3650         if (cb) {
3651                 cb->data = data;
3652                 cb->callback = unplug;
3653                 list_add(&cb->list, &plug->cb_list);
3654         }
3655         return cb;
3656 }
3657 EXPORT_SYMBOL(blk_check_plugged);
3658
3659 void blk_flush_plug_list(struct blk_plug *plug, bool from_schedule)
3660 {
3661         struct request_queue *q;
3662         struct request *rq;
3663         LIST_HEAD(list);
3664         unsigned int depth;
3665
3666         flush_plug_callbacks(plug, from_schedule);
3667
3668         if (!list_empty(&plug->mq_list))
3669                 blk_mq_flush_plug_list(plug, from_schedule);
3670
3671         if (list_empty(&plug->list))
3672                 return;
3673
3674         list_splice_init(&plug->list, &list);
3675
3676         list_sort(NULL, &list, plug_rq_cmp);
3677
3678         q = NULL;
3679         depth = 0;
3680
3681         while (!list_empty(&list)) {
3682                 rq = list_entry_rq(list.next);
3683                 list_del_init(&rq->queuelist);
3684                 BUG_ON(!rq->q);
3685                 if (rq->q != q) {
3686                         /*
3687                          * This drops the queue lock
3688                          */
3689                         if (q)
3690                                 queue_unplugged(q, depth, from_schedule);
3691                         q = rq->q;
3692                         depth = 0;
3693                         spin_lock_irq(q->queue_lock);
3694                 }
3695
3696                 /*
3697                  * Short-circuit if @q is dead
3698                  */
3699                 if (unlikely(blk_queue_dying(q))) {
3700                         __blk_end_request_all(rq, BLK_STS_IOERR);
3701                         continue;
3702                 }
3703
3704                 /*
3705                  * rq is already accounted, so use raw insert
3706                  */
3707                 if (op_is_flush(rq->cmd_flags))
3708                         __elv_add_request(q, rq, ELEVATOR_INSERT_FLUSH);
3709                 else
3710                         __elv_add_request(q, rq, ELEVATOR_INSERT_SORT_MERGE);
3711
3712                 depth++;
3713         }
3714
3715         /*
3716          * This drops the queue lock
3717          */
3718         if (q)
3719                 queue_unplugged(q, depth, from_schedule);
3720 }
3721
3722 void blk_finish_plug(struct blk_plug *plug)
3723 {
3724         if (plug != current->plug)
3725                 return;
3726         blk_flush_plug_list(plug, false);
3727
3728         current->plug = NULL;
3729 }
3730 EXPORT_SYMBOL(blk_finish_plug);
3731
3732 int __init blk_dev_init(void)
3733 {
3734         BUILD_BUG_ON(REQ_OP_LAST >= (1 << REQ_OP_BITS));
3735         BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 *
3736                         FIELD_SIZEOF(struct request, cmd_flags));
3737         BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 *
3738                         FIELD_SIZEOF(struct bio, bi_opf));
3739
3740         /* used for unplugging and affects IO latency/throughput - HIGHPRI */
3741         kblockd_workqueue = alloc_workqueue("kblockd",
3742                                             WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
3743         if (!kblockd_workqueue)
3744                 panic("Failed to create kblockd\n");
3745
3746         request_cachep = kmem_cache_create("blkdev_requests",
3747                         sizeof(struct request), 0, SLAB_PANIC, NULL);
3748
3749         blk_requestq_cachep = kmem_cache_create("request_queue",
3750                         sizeof(struct request_queue), 0, SLAB_PANIC, NULL);
3751
3752 #ifdef CONFIG_DEBUG_FS
3753         blk_debugfs_root = debugfs_create_dir("block", NULL);
3754 #endif
3755
3756         return 0;
3757 }