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