blkdev.h 51.9 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0 */
L
Linus Torvalds 已提交
2 3 4
#ifndef _LINUX_BLKDEV_H
#define _LINUX_BLKDEV_H

5
#include <linux/sched.h>
6
#include <linux/sched/clock.h>
7

J
Jens Axboe 已提交
8 9
#ifdef CONFIG_BLOCK

L
Linus Torvalds 已提交
10 11 12
#include <linux/major.h>
#include <linux/genhd.h>
#include <linux/list.h>
13
#include <linux/llist.h>
L
Linus Torvalds 已提交
14 15 16
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <linux/pagemap.h>
17
#include <linux/backing-dev-defs.h>
L
Linus Torvalds 已提交
18 19
#include <linux/wait.h>
#include <linux/mempool.h>
D
Dan Williams 已提交
20
#include <linux/pfn.h>
L
Linus Torvalds 已提交
21 22
#include <linux/bio.h>
#include <linux/stringify.h>
23
#include <linux/gfp.h>
24
#include <linux/bsg.h>
25
#include <linux/smp.h>
T
Tejun Heo 已提交
26
#include <linux/rcupdate.h>
27
#include <linux/percpu-refcount.h>
C
Christoph Hellwig 已提交
28
#include <linux/scatterlist.h>
29
#include <linux/blkzoned.h>
L
Linus Torvalds 已提交
30

31
struct module;
32 33
struct scsi_ioctl_command;

L
Linus Torvalds 已提交
34 35
struct request_queue;
struct elevator_queue;
36
struct blk_trace;
37 38
struct request;
struct sg_io_hdr;
M
Mike Christie 已提交
39
struct bsg_job;
T
Tejun Heo 已提交
40
struct blkcg_gq;
41
struct blk_flush_queue;
42
struct pr_ops;
43
struct rq_qos;
44 45
struct blk_queue_stats;
struct blk_stat_callback;
L
Linus Torvalds 已提交
46 47 48 49

#define BLKDEV_MIN_RQ	4
#define BLKDEV_MAX_RQ	128	/* Default maximum */

50
/* Must be consistent with blk_mq_poll_stats_bkt() */
51 52
#define BLK_MQ_POLL_STATS_BKTS 16

53 54 55
/* Doing classic polling */
#define BLK_MQ_POLL_CLASSIC -1

T
Tejun Heo 已提交
56 57 58 59
/*
 * Maximum number of blkcg policies allowed to be registered concurrently.
 * Defined here to simplify include dependency.
 */
60
#define BLKCG_MAX_POLS		5
T
Tejun Heo 已提交
61

62
typedef void (rq_end_io_fn)(struct request *, blk_status_t);
L
Linus Torvalds 已提交
63

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
/*
 * request flags */
typedef __u32 __bitwise req_flags_t;

/* elevator knows about this request */
#define RQF_SORTED		((__force req_flags_t)(1 << 0))
/* drive already may have started this one */
#define RQF_STARTED		((__force req_flags_t)(1 << 1))
/* may not be passed by ioscheduler */
#define RQF_SOFTBARRIER		((__force req_flags_t)(1 << 3))
/* request for flush sequence */
#define RQF_FLUSH_SEQ		((__force req_flags_t)(1 << 4))
/* merge of different types, fail separately */
#define RQF_MIXED_MERGE		((__force req_flags_t)(1 << 5))
/* track inflight for MQ */
#define RQF_MQ_INFLIGHT		((__force req_flags_t)(1 << 6))
/* don't call prep for this one */
#define RQF_DONTPREP		((__force req_flags_t)(1 << 7))
/* set for "ide_preempt" requests and also for requests for which the SCSI
   "quiesce" state must be ignored. */
#define RQF_PREEMPT		((__force req_flags_t)(1 << 8))
/* contains copies of user pages */
#define RQF_COPY_USER		((__force req_flags_t)(1 << 9))
/* vaguely specified driver internal error.  Ignored by the block layer */
#define RQF_FAILED		((__force req_flags_t)(1 << 10))
/* don't warn about errors */
#define RQF_QUIET		((__force req_flags_t)(1 << 11))
/* elevator private data attached */
#define RQF_ELVPRIV		((__force req_flags_t)(1 << 12))
93
/* account into disk and partition IO statistics */
94 95 96 97 98 99 100
#define RQF_IO_STAT		((__force req_flags_t)(1 << 13))
/* request came from our alloc pool */
#define RQF_ALLOCED		((__force req_flags_t)(1 << 14))
/* runtime pm request */
#define RQF_PM			((__force req_flags_t)(1 << 15))
/* on IO scheduler merge hash */
#define RQF_HASHED		((__force req_flags_t)(1 << 16))
101
/* track IO completion time */
102
#define RQF_STATS		((__force req_flags_t)(1 << 17))
103 104 105
/* Look at ->special_vec for the actual data payload instead of the
   bio chain. */
#define RQF_SPECIAL_PAYLOAD	((__force req_flags_t)(1 << 18))
106 107
/* The per-zone write lock is held for this request */
#define RQF_ZONE_WRITE_LOCKED	((__force req_flags_t)(1 << 19))
J
Jens Axboe 已提交
108
/* already slept for hybrid poll */
K
Keith Busch 已提交
109
#define RQF_MQ_POLL_SLEPT	((__force req_flags_t)(1 << 20))
110 111
/* ->timeout has been called, don't expire again */
#define RQF_TIMED_OUT		((__force req_flags_t)(1 << 21))
112 113 114

/* flags that prevent us from merging requests: */
#define RQF_NOMERGE_FLAGS \
115
	(RQF_STARTED | RQF_SOFTBARRIER | RQF_FLUSH_SEQ | RQF_SPECIAL_PAYLOAD)
116

K
Keith Busch 已提交
117 118 119 120 121 122 123 124 125
/*
 * Request state for blk-mq.
 */
enum mq_rq_state {
	MQ_RQ_IDLE		= 0,
	MQ_RQ_IN_FLIGHT		= 1,
	MQ_RQ_COMPLETE		= 2,
};

L
Linus Torvalds 已提交
126
/*
127 128 129 130
 * Try to put the fields that are referenced together in the same cacheline.
 *
 * If you modify this structure, make sure to update blk_rq_init() and
 * especially blk_mq_rq_ctx_init() to take care of the added fields.
L
Linus Torvalds 已提交
131 132
 */
struct request {
133
	struct request_queue *q;
134
	struct blk_mq_ctx *mq_ctx;
135
	struct blk_mq_hw_ctx *mq_hctx;
136

137
	unsigned int cmd_flags;		/* op and common flags */
138
	req_flags_t rq_flags;
139

140
	int tag;
141 142
	int internal_tag;

143 144
	/* the following two fields are internal, NEVER access directly */
	unsigned int __data_len;	/* total data len */
145
	sector_t __sector;		/* sector cursor */
L
Linus Torvalds 已提交
146 147 148 149

	struct bio *bio;
	struct bio *biotail;

150 151
	struct list_head queuelist;

152 153 154 155 156 157 158 159 160 161 162 163
	/*
	 * The hash is used inside the scheduler, and killed once the
	 * request reaches the dispatch list. The ipi_list is only used
	 * to queue the request for softirq completion, which is long
	 * after the request has been unhashed (and even removed from
	 * the dispatch list).
	 */
	union {
		struct hlist_node hash;	/* merge hash */
		struct list_head ipi_list;
	};

164 165 166
	/*
	 * The rb_node is only used inside the io scheduler, requests
	 * are pruned when moved to the dispatch queue. So let the
167
	 * completion_data share space with the rb_node.
168 169 170
	 */
	union {
		struct rb_node rb_node;	/* sort/lookup */
171
		struct bio_vec special_vec;
172
		void *completion_data;
173
		int error_count; /* for legacy drivers, don't use */
174
	};
175

176
	/*
177
	 * Three pointers are available for the IO schedulers, if they need
178 179
	 * more they have to dynamically allocate it.  Flush requests are
	 * never put on the IO scheduler. So let the flush fields share
180
	 * space with the elevator data.
181
	 */
182
	union {
183 184 185 186 187
		struct {
			struct io_cq		*icq;
			void			*priv[2];
		} elv;

188 189 190
		struct {
			unsigned int		seq;
			struct list_head	list;
191
			rq_end_io_fn		*saved_end_io;
192 193
		} flush;
	};
194

195
	struct gendisk *rq_disk;
196
	struct hd_struct *part;
197 198 199 200 201
#ifdef CONFIG_BLK_RQ_ALLOC_TIME
	/* Time that the first bio started allocating this request. */
	u64 alloc_time_ns;
#endif
	/* Time that this request was allocated for this IO. */
202
	u64 start_time_ns;
203 204 205 206 207 208
	/* Time that I/O was submitted to the device. */
	u64 io_start_time_ns;

#ifdef CONFIG_BLK_WBT
	unsigned short wbt_flags;
#endif
209 210 211 212 213 214
	/*
	 * rq sectors used for blk stats. It has the same value
	 * with blk_rq_sectors(rq), except that it never be zeroed
	 * by completion.
	 */
	unsigned short stats_sectors;
215 216 217

	/*
	 * Number of scatter-gather DMA addr+len pairs after
L
Linus Torvalds 已提交
218 219 220
	 * physical address coalescing is performed.
	 */
	unsigned short nr_phys_segments;
221

222 223 224
#if defined(CONFIG_BLK_DEV_INTEGRITY)
	unsigned short nr_integrity_segments;
#endif
L
Linus Torvalds 已提交
225

226
	unsigned short write_hint;
227 228
	unsigned short ioprio;

229
	unsigned int extra_len;	/* length of alignment and padding */
L
Linus Torvalds 已提交
230

K
Keith Busch 已提交
231 232
	enum mq_rq_state state;
	refcount_t ref;
233

234
	unsigned int timeout;
235
	unsigned long deadline;
236

237
	union {
238
		struct __call_single_data csd;
239 240 241
		u64 fifo_time;
	};

L
Linus Torvalds 已提交
242
	/*
243
	 * completion callback.
L
Linus Torvalds 已提交
244 245 246 247 248
	 */
	rq_end_io_fn *end_io;
	void *end_io_data;
};

249 250 251 252 253 254 255 256 257 258
static inline bool blk_op_is_scsi(unsigned int op)
{
	return op == REQ_OP_SCSI_IN || op == REQ_OP_SCSI_OUT;
}

static inline bool blk_op_is_private(unsigned int op)
{
	return op == REQ_OP_DRV_IN || op == REQ_OP_DRV_OUT;
}

259 260
static inline bool blk_rq_is_scsi(struct request *rq)
{
261
	return blk_op_is_scsi(req_op(rq));
262 263 264 265
}

static inline bool blk_rq_is_private(struct request *rq)
{
266
	return blk_op_is_private(req_op(rq));
267 268
}

269 270
static inline bool blk_rq_is_passthrough(struct request *rq)
{
271
	return blk_rq_is_scsi(rq) || blk_rq_is_private(rq);
272 273
}

274 275 276 277 278 279 280
static inline bool bio_is_passthrough(struct bio *bio)
{
	unsigned op = bio_op(bio);

	return blk_op_is_scsi(op) || blk_op_is_private(op);
}

281 282 283 284 285
static inline unsigned short req_get_ioprio(struct request *req)
{
	return req->ioprio;
}

L
Linus Torvalds 已提交
286 287
#include <linux/elevator.h>

288 289
struct blk_queue_ctx;

290
typedef blk_qc_t (make_request_fn) (struct request_queue *q, struct bio *bio);
L
Linus Torvalds 已提交
291 292

struct bio_vec;
293
typedef int (dma_drain_needed_fn)(struct request *);
L
Linus Torvalds 已提交
294

J
Jens Axboe 已提交
295
enum blk_eh_timer_return {
296 297
	BLK_EH_DONE,		/* drivers has completed the command */
	BLK_EH_RESET_TIMER,	/* reset timer and try again */
J
Jens Axboe 已提交
298 299
};

L
Linus Torvalds 已提交
300 301 302 303 304
enum blk_queue_state {
	Queue_down,
	Queue_up,
};

305 306
#define BLK_TAG_ALLOC_FIFO 0 /* allocate starting from 0 */
#define BLK_TAG_ALLOC_RR 1 /* allocate starting from last allocated tag */
L
Linus Torvalds 已提交
307

308 309 310
#define BLK_SCSI_MAX_CMDS	(256)
#define BLK_SCSI_CMD_PER_LONG	(BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))

D
Damien Le Moal 已提交
311 312 313 314 315 316 317 318 319
/*
 * Zoned block device models (zoned limit).
 */
enum blk_zoned_model {
	BLK_ZONED_NONE,	/* Regular block device */
	BLK_ZONED_HA,	/* Host-aware zoned block device */
	BLK_ZONED_HM,	/* Host-managed zoned block device */
};

320 321 322
struct queue_limits {
	unsigned long		bounce_pfn;
	unsigned long		seg_boundary_mask;
323
	unsigned long		virt_boundary_mask;
324 325

	unsigned int		max_hw_sectors;
326
	unsigned int		max_dev_sectors;
327
	unsigned int		chunk_sectors;
328 329
	unsigned int		max_sectors;
	unsigned int		max_segment_size;
330 331 332 333
	unsigned int		physical_block_size;
	unsigned int		alignment_offset;
	unsigned int		io_min;
	unsigned int		io_opt;
334
	unsigned int		max_discard_sectors;
335
	unsigned int		max_hw_discard_sectors;
336
	unsigned int		max_write_same_sectors;
337
	unsigned int		max_write_zeroes_sectors;
338 339
	unsigned int		discard_granularity;
	unsigned int		discard_alignment;
340 341

	unsigned short		logical_block_size;
342
	unsigned short		max_segments;
343
	unsigned short		max_integrity_segments;
344
	unsigned short		max_discard_segments;
345

346
	unsigned char		misaligned;
347
	unsigned char		discard_misaligned;
348
	unsigned char		raid_partial_stripes_expensive;
D
Damien Le Moal 已提交
349
	enum blk_zoned_model	zoned;
350 351
};

C
Christoph Hellwig 已提交
352 353 354
typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx,
			       void *data);

355 356
#ifdef CONFIG_BLK_DEV_ZONED

C
Christoph Hellwig 已提交
357 358 359
#define BLK_ALL_ZONES  ((unsigned int)-1)
int blkdev_report_zones(struct block_device *bdev, sector_t sector,
			unsigned int nr_zones, report_zones_cb cb, void *data);
360

361
extern unsigned int blkdev_nr_zones(struct block_device *bdev);
362 363 364
extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
			    sector_t sectors, sector_t nr_sectors,
			    gfp_t gfp_mask);
365
extern int blk_revalidate_disk_zones(struct gendisk *disk);
366

S
Shaun Tancheff 已提交
367 368
extern int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
				     unsigned int cmd, unsigned long arg);
369 370
extern int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode,
				  unsigned int cmd, unsigned long arg);
S
Shaun Tancheff 已提交
371 372 373

#else /* CONFIG_BLK_DEV_ZONED */

374 375 376 377
static inline unsigned int blkdev_nr_zones(struct block_device *bdev)
{
	return 0;
}
378 379 380 381 382 383

static inline int blk_revalidate_disk_zones(struct gendisk *disk)
{
	return 0;
}

S
Shaun Tancheff 已提交
384 385 386 387 388 389 390
static inline int blkdev_report_zones_ioctl(struct block_device *bdev,
					    fmode_t mode, unsigned int cmd,
					    unsigned long arg)
{
	return -ENOTTY;
}

391 392 393
static inline int blkdev_zone_mgmt_ioctl(struct block_device *bdev,
					 fmode_t mode, unsigned int cmd,
					 unsigned long arg)
S
Shaun Tancheff 已提交
394 395 396 397
{
	return -ENOTTY;
}

398 399
#endif /* CONFIG_BLK_DEV_ZONED */

400
struct request_queue {
L
Linus Torvalds 已提交
401
	struct request		*last_merge;
J
Jens Axboe 已提交
402
	struct elevator_queue	*elevator;
L
Linus Torvalds 已提交
403

404
	struct blk_queue_stats	*stats;
405
	struct rq_qos		*rq_qos;
J
Jens Axboe 已提交
406

L
Linus Torvalds 已提交
407
	make_request_fn		*make_request_fn;
408
	dma_drain_needed_fn	*dma_drain_needed;
L
Linus Torvalds 已提交
409

J
Jens Axboe 已提交
410
	const struct blk_mq_ops	*mq_ops;
411 412

	/* sw queues */
413
	struct blk_mq_ctx __percpu	*queue_ctx;
414

415 416
	unsigned int		queue_depth;

417 418 419 420
	/* hw dispatch queues */
	struct blk_mq_hw_ctx	**queue_hw_ctx;
	unsigned int		nr_hw_queues;

421
	struct backing_dev_info	*backing_dev_info;
L
Linus Torvalds 已提交
422 423 424 425 426 427 428 429

	/*
	 * The queue owner gets to use this for whatever they like.
	 * ll_rw_blk doesn't touch it.
	 */
	void			*queuedata;

	/*
430
	 * various queue flags, see QUEUE_* below
L
Linus Torvalds 已提交
431
	 */
432
	unsigned long		queue_flags;
433 434 435 436 437 438
	/*
	 * Number of contexts that have called blk_set_pm_only(). If this
	 * counter is above zero then only RQF_PM and RQF_PREEMPT requests are
	 * processed.
	 */
	atomic_t		pm_only;
L
Linus Torvalds 已提交
439

440 441 442 443 444 445
	/*
	 * ida allocated id for this queue.  Used to index queues from
	 * ioctx.
	 */
	int			id;

L
Linus Torvalds 已提交
446
	/*
447
	 * queue needs bounce pages for pages above this limit
L
Linus Torvalds 已提交
448
	 */
449
	gfp_t			bounce_gfp;
L
Linus Torvalds 已提交
450

451
	spinlock_t		queue_lock;
L
Linus Torvalds 已提交
452 453 454 455 456 457

	/*
	 * queue kobject
	 */
	struct kobject kobj;

458 459 460
	/*
	 * mq queue kobject
	 */
461
	struct kobject *mq_kobj;
462

463 464 465 466
#ifdef  CONFIG_BLK_DEV_INTEGRITY
	struct blk_integrity integrity;
#endif	/* CONFIG_BLK_DEV_INTEGRITY */

467
#ifdef CONFIG_PM
L
Lin Ming 已提交
468 469 470 471 472
	struct device		*dev;
	int			rpm_status;
	unsigned int		nr_pending;
#endif

L
Linus Torvalds 已提交
473 474 475 476 477
	/*
	 * queue settings
	 */
	unsigned long		nr_requests;	/* Max # of requests */

J
James Bottomley 已提交
478
	unsigned int		dma_drain_size;
479
	void			*dma_drain_buffer;
480
	unsigned int		dma_pad_mask;
L
Linus Torvalds 已提交
481 482
	unsigned int		dma_alignment;

J
Jens Axboe 已提交
483
	unsigned int		rq_timeout;
484
	int			poll_nsec;
485 486

	struct blk_stat_callback	*poll_cb;
487
	struct blk_rq_stat	poll_stat[BLK_MQ_POLL_STATS_BKTS];
488

J
Jens Axboe 已提交
489
	struct timer_list	timeout;
490
	struct work_struct	timeout_work;
J
Jens Axboe 已提交
491

492
	struct list_head	icq_list;
493
#ifdef CONFIG_BLK_CGROUP
494
	DECLARE_BITMAP		(blkcg_pols, BLKCG_MAX_POLS);
T
Tejun Heo 已提交
495
	struct blkcg_gq		*root_blkg;
496
	struct list_head	blkg_list;
497
#endif
498

499 500
	struct queue_limits	limits;

501 502
	unsigned int		required_elevator_features;

503
#ifdef CONFIG_BLK_DEV_ZONED
504 505 506 507 508 509 510 511 512 513 514
	/*
	 * Zoned block device information for request dispatch control.
	 * nr_zones is the total number of zones of the device. This is always
	 * 0 for regular block devices. seq_zones_bitmap is a bitmap of nr_zones
	 * bits which indicates if a zone is conventional (bit clear) or
	 * sequential (bit set). seq_zones_wlock is a bitmap of nr_zones
	 * bits which indicates if a zone is write locked, that is, if a write
	 * request targeting the zone was dispatched. All three fields are
	 * initialized by the low level device driver (e.g. scsi/sd.c).
	 * Stacking drivers (device mappers) may or may not initialize
	 * these fields.
515 516 517 518 519
	 *
	 * Reads of this information must be protected with blk_queue_enter() /
	 * blk_queue_exit(). Modifying this information is only allowed while
	 * no requests are being processed. See also blk_mq_freeze_queue() and
	 * blk_mq_unfreeze_queue().
520 521 522 523
	 */
	unsigned int		nr_zones;
	unsigned long		*seq_zones_bitmap;
	unsigned long		*seq_zones_wlock;
524
#endif /* CONFIG_BLK_DEV_ZONED */
525

L
Linus Torvalds 已提交
526 527 528 529 530
	/*
	 * sg stuff
	 */
	unsigned int		sg_timeout;
	unsigned int		sg_reserved_size;
531
	int			node;
532
#ifdef CONFIG_BLK_DEV_IO_TRACE
533
	struct blk_trace	*blk_trace;
534
	struct mutex		blk_trace_mutex;
535
#endif
L
Linus Torvalds 已提交
536
	/*
537
	 * for flush operations
L
Linus Torvalds 已提交
538
	 */
539
	struct blk_flush_queue	*fq;
540

541 542
	struct list_head	requeue_list;
	spinlock_t		requeue_lock;
543
	struct delayed_work	requeue_work;
544

545
	struct mutex		sysfs_lock;
546
	struct mutex		sysfs_dir_lock;
547

548 549 550 551 552 553 554
	/*
	 * for reusing dead hctx instance in case of updating
	 * nr_hw_queues
	 */
	struct list_head	unused_hctx_list;
	spinlock_t		unused_hctx_lock;

555
	int			mq_freeze_depth;
556

557 558 559
#if defined(CONFIG_BLK_DEV_BSG)
	struct bsg_class_device bsg_dev;
#endif
560 561 562 563 564

#ifdef CONFIG_BLK_DEV_THROTTLING
	/* Throttle data */
	struct throtl_data *td;
#endif
T
Tejun Heo 已提交
565
	struct rcu_head		rcu_head;
566
	wait_queue_head_t	mq_freeze_wq;
567 568 569 570 571
	/*
	 * Protect concurrent access to q_usage_counter by
	 * percpu_ref_kill() and percpu_ref_reinit().
	 */
	struct mutex		mq_freeze_lock;
572
	struct percpu_ref	q_usage_counter;
573 574 575

	struct blk_mq_tag_set	*tag_set;
	struct list_head	tag_set_list;
576
	struct bio_set		bio_split;
577

578
#ifdef CONFIG_BLK_DEBUG_FS
579
	struct dentry		*debugfs_dir;
580
	struct dentry		*sched_debugfs_dir;
M
Ming Lei 已提交
581
	struct dentry		*rqos_debugfs_dir;
582 583
#endif

584
	bool			mq_sysfs_init_done;
585 586

	size_t			cmd_size;
587 588

	struct work_struct	release_work;
589 590 591

#define BLK_MAX_WRITE_HINTS	5
	u64			write_hints[BLK_MAX_WRITE_HINTS];
L
Linus Torvalds 已提交
592 593
};

J
Jens Axboe 已提交
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
#define QUEUE_FLAG_STOPPED	0	/* queue is stopped */
#define QUEUE_FLAG_DYING	1	/* queue being torn down */
#define QUEUE_FLAG_NOMERGES     3	/* disable merge attempts */
#define QUEUE_FLAG_SAME_COMP	4	/* complete on same CPU-group */
#define QUEUE_FLAG_FAIL_IO	5	/* fake timeout */
#define QUEUE_FLAG_NONROT	6	/* non-rotational device (SSD) */
#define QUEUE_FLAG_VIRT		QUEUE_FLAG_NONROT /* paravirt device */
#define QUEUE_FLAG_IO_STAT	7	/* do disk/partitions IO accounting */
#define QUEUE_FLAG_DISCARD	8	/* supports DISCARD */
#define QUEUE_FLAG_NOXMERGES	9	/* No extended merges */
#define QUEUE_FLAG_ADD_RANDOM	10	/* Contributes to random pool */
#define QUEUE_FLAG_SECERASE	11	/* supports secure erase */
#define QUEUE_FLAG_SAME_FORCE	12	/* force complete on same CPU */
#define QUEUE_FLAG_DEAD		13	/* queue tear-down finished */
#define QUEUE_FLAG_INIT_DONE	14	/* queue is initialized */
#define QUEUE_FLAG_POLL		16	/* IO polling enabled if set */
#define QUEUE_FLAG_WC		17	/* Write back caching */
#define QUEUE_FLAG_FUA		18	/* device supports FUA writes */
#define QUEUE_FLAG_DAX		19	/* device supports DAX */
#define QUEUE_FLAG_STATS	20	/* track IO start and completion times */
#define QUEUE_FLAG_POLL_STATS	21	/* collecting stats for hybrid polling */
#define QUEUE_FLAG_REGISTERED	22	/* queue has been registered to a disk */
#define QUEUE_FLAG_SCSI_PASSTHROUGH 23	/* queue supports SCSI commands */
#define QUEUE_FLAG_QUIESCED	24	/* queue has been quiesced */
#define QUEUE_FLAG_PCI_P2PDMA	25	/* device supports PCI p2p requests */
619
#define QUEUE_FLAG_ZONE_RESETALL 26	/* supports Zone Reset All */
620
#define QUEUE_FLAG_RQ_ALLOC_TIME 27	/* record rq->alloc_time_ns */
621

622
#define QUEUE_FLAG_MQ_DEFAULT	((1 << QUEUE_FLAG_IO_STAT) |		\
623
				 (1 << QUEUE_FLAG_SAME_COMP))
624

625 626 627 628
void blk_queue_flag_set(unsigned int flag, struct request_queue *q);
void blk_queue_flag_clear(unsigned int flag, struct request_queue *q);
bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q);

L
Linus Torvalds 已提交
629
#define blk_queue_stopped(q)	test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
B
Bart Van Assche 已提交
630
#define blk_queue_dying(q)	test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags)
631
#define blk_queue_dead(q)	test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags)
632
#define blk_queue_init_done(q)	test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags)
633
#define blk_queue_nomerges(q)	test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
634 635
#define blk_queue_noxmerges(q)	\
	test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
636
#define blk_queue_nonrot(q)	test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
637
#define blk_queue_io_stat(q)	test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
638
#define blk_queue_add_random(q)	test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
639
#define blk_queue_discard(q)	test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
640 641
#define blk_queue_zone_resetall(q)	\
	test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags)
642 643
#define blk_queue_secure_erase(q) \
	(test_bit(QUEUE_FLAG_SECERASE, &(q)->queue_flags))
644
#define blk_queue_dax(q)	test_bit(QUEUE_FLAG_DAX, &(q)->queue_flags)
645 646
#define blk_queue_scsi_passthrough(q)	\
	test_bit(QUEUE_FLAG_SCSI_PASSTHROUGH, &(q)->queue_flags)
647 648
#define blk_queue_pci_p2pdma(q)	\
	test_bit(QUEUE_FLAG_PCI_P2PDMA, &(q)->queue_flags)
649 650 651 652 653 654
#ifdef CONFIG_BLK_RQ_ALLOC_TIME
#define blk_queue_rq_alloc_time(q)	\
	test_bit(QUEUE_FLAG_RQ_ALLOC_TIME, &(q)->queue_flags)
#else
#define blk_queue_rq_alloc_time(q)	false
#endif
L
Linus Torvalds 已提交
655

656 657 658
#define blk_noretry_request(rq) \
	((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
			     REQ_FAILFAST_DRIVER))
659
#define blk_queue_quiesced(q)	test_bit(QUEUE_FLAG_QUIESCED, &(q)->queue_flags)
660
#define blk_queue_pm_only(q)	atomic_read(&(q)->pm_only)
661
#define blk_queue_fua(q)	test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags)
662
#define blk_queue_registered(q)	test_bit(QUEUE_FLAG_REGISTERED, &(q)->queue_flags)
663

664 665
extern void blk_set_pm_only(struct request_queue *q);
extern void blk_clear_pm_only(struct request_queue *q);
666

667 668 669 670
static inline bool blk_account_rq(struct request *rq)
{
	return (rq->rq_flags & RQF_STARTED) && !blk_rq_is_passthrough(rq);
}
671

L
Linus Torvalds 已提交
672 673
#define list_entry_rq(ptr)	list_entry((ptr), struct request, queuelist)

674
#define rq_data_dir(rq)		(op_is_write(req_op(rq)) ? WRITE : READ)
L
Linus Torvalds 已提交
675

676 677 678
#define rq_dma_dir(rq) \
	(op_is_write(req_op(rq)) ? DMA_TO_DEVICE : DMA_FROM_DEVICE)

679 680 681 682
#define dma_map_bvec(dev, bv, dir, attrs) \
	dma_map_page_attrs(dev, (bv)->bv_page, (bv)->bv_offset, (bv)->bv_len, \
	(dir), (attrs))

J
Jens Axboe 已提交
683
static inline bool queue_is_mq(struct request_queue *q)
684
{
J
Jens Axboe 已提交
685
	return q->mq_ops;
686 687
}

D
Damien Le Moal 已提交
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
static inline enum blk_zoned_model
blk_queue_zoned_model(struct request_queue *q)
{
	return q->limits.zoned;
}

static inline bool blk_queue_is_zoned(struct request_queue *q)
{
	switch (blk_queue_zoned_model(q)) {
	case BLK_ZONED_HA:
	case BLK_ZONED_HM:
		return true;
	default:
		return false;
	}
}

705
static inline sector_t blk_queue_zone_sectors(struct request_queue *q)
706 707 708 709
{
	return blk_queue_is_zoned(q) ? q->limits.chunk_sectors : 0;
}

710
#ifdef CONFIG_BLK_DEV_ZONED
711 712 713 714 715
static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
{
	return blk_queue_is_zoned(q) ? q->nr_zones : 0;
}

716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
static inline unsigned int blk_queue_zone_no(struct request_queue *q,
					     sector_t sector)
{
	if (!blk_queue_is_zoned(q))
		return 0;
	return sector >> ilog2(q->limits.chunk_sectors);
}

static inline bool blk_queue_zone_is_seq(struct request_queue *q,
					 sector_t sector)
{
	if (!blk_queue_is_zoned(q) || !q->seq_zones_bitmap)
		return false;
	return test_bit(blk_queue_zone_no(q, sector), q->seq_zones_bitmap);
}
731 732 733 734 735
#else /* CONFIG_BLK_DEV_ZONED */
static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
{
	return 0;
}
736
#endif /* CONFIG_BLK_DEV_ZONED */
737

738 739
static inline bool rq_is_sync(struct request *rq)
{
740
	return op_is_sync(rq->cmd_flags);
741 742
}

743 744
static inline bool rq_mergeable(struct request *rq)
{
745
	if (blk_rq_is_passthrough(rq))
746
		return false;
L
Linus Torvalds 已提交
747

748 749 750
	if (req_op(rq) == REQ_OP_FLUSH)
		return false;

751 752 753
	if (req_op(rq) == REQ_OP_WRITE_ZEROES)
		return false;

754
	if (rq->cmd_flags & REQ_NOMERGE_FLAGS)
755 756
		return false;
	if (rq->rq_flags & RQF_NOMERGE_FLAGS)
757 758 759 760
		return false;

	return true;
}
L
Linus Torvalds 已提交
761

762 763
static inline bool blk_write_same_mergeable(struct bio *a, struct bio *b)
{
764 765
	if (bio_page(a) == bio_page(b) &&
	    bio_offset(a) == bio_offset(b))
766 767 768 769 770
		return true;

	return false;
}

771 772 773 774 775 776 777 778
static inline unsigned int blk_queue_depth(struct request_queue *q)
{
	if (q->queue_depth)
		return q->queue_depth;

	return q->nr_requests;
}

L
Linus Torvalds 已提交
779 780 781 782 783 784 785 786 787
extern unsigned long blk_max_low_pfn, blk_max_pfn;

/*
 * standard bounce addresses:
 *
 * BLK_BOUNCE_HIGH	: bounce all highmem pages
 * BLK_BOUNCE_ANY	: don't bounce anything
 * BLK_BOUNCE_ISA	: bounce pages above ISA DMA boundary
 */
788 789

#if BITS_PER_LONG == 32
L
Linus Torvalds 已提交
790
#define BLK_BOUNCE_HIGH		((u64)blk_max_low_pfn << PAGE_SHIFT)
791 792 793 794
#else
#define BLK_BOUNCE_HIGH		-1ULL
#endif
#define BLK_BOUNCE_ANY		(-1ULL)
795
#define BLK_BOUNCE_ISA		(DMA_BIT_MASK(24))
L
Linus Torvalds 已提交
796

797 798 799 800
/*
 * default timeout for SG_IO if none specified
 */
#define BLK_DEFAULT_SG_TIMEOUT	(60 * HZ)
L
Linus Torvalds 已提交
801
#define BLK_MIN_SG_TIMEOUT	(7 * HZ)
802

803 804 805 806
struct rq_map_data {
	struct page **pages;
	int page_order;
	int nr_entries;
807
	unsigned long offset;
808
	int null_mapped;
809
	int from_user;
810 811
};

812
struct req_iterator {
813
	struct bvec_iter iter;
814 815 816 817
	struct bio *bio;
};

/* This should not be used directly - use rq_for_each_segment */
818 819
#define for_each_bio(_bio)		\
	for (; _bio; _bio = _bio->bi_next)
820
#define __rq_for_each_bio(_bio, rq)	\
L
Linus Torvalds 已提交
821 822 823
	if ((rq->bio))			\
		for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)

824 825
#define rq_for_each_segment(bvl, _rq, _iter)			\
	__rq_for_each_bio(_iter.bio, _rq)			\
826
		bio_for_each_segment(bvl, _iter.bio, _iter.iter)
827

828 829 830 831
#define rq_for_each_bvec(bvl, _rq, _iter)			\
	__rq_for_each_bio(_iter.bio, _rq)			\
		bio_for_each_bvec(bvl, _iter.bio, _iter.iter)

K
Kent Overstreet 已提交
832
#define rq_iter_last(bvec, _iter)				\
833
		(_iter.bio->bi_next == NULL &&			\
K
Kent Overstreet 已提交
834
		 bio_iter_last(bvec, _iter.iter))
835

836 837 838 839 840 841 842 843 844 845 846
#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
# error	"You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
#endif
#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
extern void rq_flush_dcache_pages(struct request *rq);
#else
static inline void rq_flush_dcache_pages(struct request *rq)
{
}
#endif

L
Linus Torvalds 已提交
847 848
extern int blk_register_queue(struct gendisk *disk);
extern void blk_unregister_queue(struct gendisk *disk);
849
extern blk_qc_t generic_make_request(struct bio *bio);
850
extern blk_qc_t direct_make_request(struct bio *bio);
851
extern void blk_rq_init(struct request_queue *q, struct request *rq);
L
Linus Torvalds 已提交
852
extern void blk_put_request(struct request *);
853
extern struct request *blk_get_request(struct request_queue *, unsigned int op,
854
				       blk_mq_req_flags_t flags);
855
extern int blk_lld_busy(struct request_queue *q);
856 857 858 859 860
extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
			     struct bio_set *bs, gfp_t gfp_mask,
			     int (*bio_ctr)(struct bio *, struct bio *, void *),
			     void *data);
extern void blk_rq_unprep_clone(struct request *rq);
861
extern blk_status_t blk_insert_cloned_request(struct request_queue *q,
862
				     struct request *rq);
J
Jens Axboe 已提交
863
extern int blk_rq_append_bio(struct request *rq, struct bio **bio);
864
extern void blk_queue_split(struct request_queue *, struct bio **);
865
extern int scsi_verify_blk_ioctl(struct block_device *, unsigned int);
866 867
extern int scsi_cmd_blk_ioctl(struct block_device *, fmode_t,
			      unsigned int, void __user *);
868 869
extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
			  unsigned int, void __user *);
870 871
extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
			 struct scsi_ioctl_command __user *);
872 873
extern int get_sg_io_hdr(struct sg_io_hdr *hdr, const void __user *argp);
extern int put_sg_io_hdr(const struct sg_io_hdr *hdr, void __user *argp);
874

875
extern int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags);
876
extern void blk_queue_exit(struct request_queue *q);
L
Linus Torvalds 已提交
877
extern void blk_sync_queue(struct request_queue *q);
878
extern int blk_rq_map_user(struct request_queue *, struct request *,
879 880
			   struct rq_map_data *, void __user *, unsigned long,
			   gfp_t);
J
Jens Axboe 已提交
881
extern int blk_rq_unmap_user(struct bio *);
882 883
extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
884 885
			       struct rq_map_data *, const struct iov_iter *,
			       gfp_t);
886
extern void blk_execute_rq(struct request_queue *, struct gendisk *,
887
			  struct request *, int);
888
extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
889
				  struct request *, int, rq_end_io_fn *);
890

891 892 893
/* Helper to convert REQ_OP_XXX to its string format XXX */
extern const char *blk_op_str(unsigned int op);

894 895 896
int blk_status_to_errno(blk_status_t status);
blk_status_t errno_to_blk_status(int errno);

897
int blk_poll(struct request_queue *q, blk_qc_t cookie, bool spin);
J
Jens Axboe 已提交
898

899
static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
L
Linus Torvalds 已提交
900
{
901
	return bdev->bd_disk->queue;	/* this is never NULL */
L
Linus Torvalds 已提交
902 903
}

904 905 906 907 908 909 910 911 912 913 914 915 916
/*
 * The basic unit of block I/O is a sector. It is used in a number of contexts
 * in Linux (blk, bio, genhd). The size of one sector is 512 = 2**9
 * bytes. Variables of type sector_t represent an offset or size that is a
 * multiple of 512 bytes. Hence these two constants.
 */
#ifndef SECTOR_SHIFT
#define SECTOR_SHIFT 9
#endif
#ifndef SECTOR_SIZE
#define SECTOR_SIZE (1 << SECTOR_SHIFT)
#endif

917
/*
918 919 920 921 922 923
 * blk_rq_pos()			: the current sector
 * blk_rq_bytes()		: bytes left in the entire request
 * blk_rq_cur_bytes()		: bytes left in the current segment
 * blk_rq_err_bytes()		: bytes left till the next error boundary
 * blk_rq_sectors()		: sectors left in the entire request
 * blk_rq_cur_sectors()		: sectors left in the current segment
924
 * blk_rq_stats_sectors()	: sectors of the entire request used for stats
925
 */
926 927
static inline sector_t blk_rq_pos(const struct request *rq)
{
928
	return rq->__sector;
929 930 931 932
}

static inline unsigned int blk_rq_bytes(const struct request *rq)
{
933
	return rq->__data_len;
934 935
}

936 937 938 939
static inline int blk_rq_cur_bytes(const struct request *rq)
{
	return rq->bio ? bio_cur_bytes(rq->bio) : 0;
}
940

941 942
extern unsigned int blk_rq_err_bytes(const struct request *rq);

943 944
static inline unsigned int blk_rq_sectors(const struct request *rq)
{
945
	return blk_rq_bytes(rq) >> SECTOR_SHIFT;
946 947 948 949
}

static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
{
950
	return blk_rq_cur_bytes(rq) >> SECTOR_SHIFT;
951 952
}

953 954 955 956 957
static inline unsigned int blk_rq_stats_sectors(const struct request *rq)
{
	return rq->stats_sectors;
}

958
#ifdef CONFIG_BLK_DEV_ZONED
959 960 961 962 963 964 965 966 967
static inline unsigned int blk_rq_zone_no(struct request *rq)
{
	return blk_queue_zone_no(rq->q, blk_rq_pos(rq));
}

static inline unsigned int blk_rq_zone_is_seq(struct request *rq)
{
	return blk_queue_zone_is_seq(rq->q, blk_rq_pos(rq));
}
968
#endif /* CONFIG_BLK_DEV_ZONED */
969

970 971 972 973 974 975 976 977 978 979 980 981 982
/*
 * Some commands like WRITE SAME have a payload or data transfer size which
 * is different from the size of the request.  Any driver that supports such
 * commands using the RQF_SPECIAL_PAYLOAD flag needs to use this helper to
 * calculate the data transfer size.
 */
static inline unsigned int blk_rq_payload_bytes(struct request *rq)
{
	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
		return rq->special_vec.bv_len;
	return blk_rq_bytes(rq);
}

C
Christoph Hellwig 已提交
983 984 985 986 987 988 989 990 991 992 993
/*
 * Return the first full biovec in the request.  The caller needs to check that
 * there are any bvecs before calling this helper.
 */
static inline struct bio_vec req_bvec(struct request *rq)
{
	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
		return rq->special_vec;
	return mp_bvec_iter_bvec(rq->bio->bi_io_vec, rq->bio->bi_iter);
}

994
static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
995
						     int op)
996
{
A
Adrian Hunter 已提交
997
	if (unlikely(op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE))
998 999
		return min(q->limits.max_discard_sectors,
			   UINT_MAX >> SECTOR_SHIFT);
1000

1001
	if (unlikely(op == REQ_OP_WRITE_SAME))
1002 1003
		return q->limits.max_write_same_sectors;

1004 1005 1006
	if (unlikely(op == REQ_OP_WRITE_ZEROES))
		return q->limits.max_write_zeroes_sectors;

1007 1008 1009
	return q->limits.max_sectors;
}

1010 1011 1012 1013 1014 1015 1016 1017
/*
 * Return maximum size of a request at given offset. Only valid for
 * file system requests.
 */
static inline unsigned int blk_max_size_offset(struct request_queue *q,
					       sector_t offset)
{
	if (!q->limits.chunk_sectors)
1018
		return q->limits.max_sectors;
1019

1020 1021
	return min(q->limits.max_sectors, (unsigned int)(q->limits.chunk_sectors -
			(offset & (q->limits.chunk_sectors - 1))));
1022 1023
}

D
Damien Le Moal 已提交
1024 1025
static inline unsigned int blk_rq_get_max_sectors(struct request *rq,
						  sector_t offset)
1026 1027 1028
{
	struct request_queue *q = rq->q;

1029
	if (blk_rq_is_passthrough(rq))
1030 1031
		return q->limits.max_hw_sectors;

A
Adrian Hunter 已提交
1032 1033 1034
	if (!q->limits.chunk_sectors ||
	    req_op(rq) == REQ_OP_DISCARD ||
	    req_op(rq) == REQ_OP_SECURE_ERASE)
1035
		return blk_queue_get_max_sectors(q, req_op(rq));
1036

D
Damien Le Moal 已提交
1037
	return min(blk_max_size_offset(q, offset),
1038
			blk_queue_get_max_sectors(q, req_op(rq)));
1039 1040
}

1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
static inline unsigned int blk_rq_count_bios(struct request *rq)
{
	unsigned int nr_bios = 0;
	struct bio *bio;

	__rq_for_each_bio(bio, rq)
		nr_bios++;

	return nr_bios;
}

1052 1053
void blk_steal_bios(struct bio_list *list, struct request *rq);

L
Linus Torvalds 已提交
1054
/*
1055 1056 1057 1058
 * Request completion related functions.
 *
 * blk_update_request() completes given number of bytes and updates
 * the request without completing it.
L
Linus Torvalds 已提交
1059
 */
1060
extern bool blk_update_request(struct request *rq, blk_status_t error,
1061 1062
			       unsigned int nr_bytes);

J
Jens Axboe 已提交
1063 1064
extern void __blk_complete_request(struct request *);
extern void blk_abort_request(struct request *);
1065

L
Linus Torvalds 已提交
1066 1067 1068
/*
 * Access functions for manipulating queue properties
 */
1069 1070 1071
extern void blk_cleanup_queue(struct request_queue *);
extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
extern void blk_queue_bounce_limit(struct request_queue *, u64);
1072
extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
1073
extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
1074
extern void blk_queue_max_segments(struct request_queue *, unsigned short);
1075 1076
extern void blk_queue_max_discard_segments(struct request_queue *,
		unsigned short);
1077
extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
1078 1079
extern void blk_queue_max_discard_sectors(struct request_queue *q,
		unsigned int max_discard_sectors);
1080 1081
extern void blk_queue_max_write_same_sectors(struct request_queue *q,
		unsigned int max_write_same_sectors);
1082 1083
extern void blk_queue_max_write_zeroes_sectors(struct request_queue *q,
		unsigned int max_write_same_sectors);
1084
extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
1085
extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
1086 1087
extern void blk_queue_alignment_offset(struct request_queue *q,
				       unsigned int alignment);
1088
extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
1089
extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
1090
extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
1091
extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
1092
extern void blk_set_queue_depth(struct request_queue *q, unsigned int depth);
1093
extern void blk_set_default_limits(struct queue_limits *lim);
1094
extern void blk_set_stacking_limits(struct queue_limits *lim);
1095 1096
extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
			    sector_t offset);
1097 1098
extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
			    sector_t offset);
1099 1100
extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
			      sector_t offset);
1101
extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
1102
extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
1103 1104 1105
extern int blk_queue_dma_drain(struct request_queue *q,
			       dma_drain_needed_fn *dma_drain_needed,
			       void *buf, unsigned int size);
1106
extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
1107
extern void blk_queue_virt_boundary(struct request_queue *, unsigned long);
1108
extern void blk_queue_dma_alignment(struct request_queue *, int);
1109
extern void blk_queue_update_dma_alignment(struct request_queue *, int);
J
Jens Axboe 已提交
1110
extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
1111
extern void blk_queue_write_cache(struct request_queue *q, bool enabled, bool fua);
1112 1113
extern void blk_queue_required_elevator_features(struct request_queue *q,
						 unsigned int features);
1114 1115
extern bool blk_queue_can_use_dma_map_merging(struct request_queue *q,
					      struct device *dev);
L
Linus Torvalds 已提交
1116

1117 1118 1119 1120 1121 1122 1123 1124 1125
/*
 * Number of physical segments as sent to the device.
 *
 * Normally this is the number of discontiguous data segments sent by the
 * submitter.  But for data-less command like discard we might have no
 * actual data segments submitted, but the driver might have to add it's
 * own special payload.  In that case we still return 1 here so that this
 * special payload will be mapped.
 */
1126 1127 1128 1129 1130 1131 1132
static inline unsigned short blk_rq_nr_phys_segments(struct request *rq)
{
	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
		return 1;
	return rq->nr_phys_segments;
}

1133 1134 1135 1136 1137 1138 1139 1140 1141
/*
 * Number of discard segments (or ranges) the driver needs to fill in.
 * Each discard bio merged into a request is counted as one segment.
 */
static inline unsigned short blk_rq_nr_discard_segments(struct request *rq)
{
	return max_t(unsigned short, rq->nr_phys_segments, 1);
}

1142
extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
L
Linus Torvalds 已提交
1143 1144 1145
extern void blk_dump_rq_flags(struct request *, char *);
extern long nr_blockdev_pages(void);

T
Tejun Heo 已提交
1146
bool __must_check blk_get_queue(struct request_queue *);
1147
struct request_queue *blk_alloc_queue(gfp_t);
1148
struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id);
1149
extern void blk_put_queue(struct request_queue *);
1150
extern void blk_set_queue_dying(struct request_queue *);
L
Linus Torvalds 已提交
1151

1152
/*
S
Suresh Jayaraman 已提交
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
 * blk_plug permits building a queue of related requests by holding the I/O
 * fragments for a short period. This allows merging of sequential requests
 * into single larger request. As the requests are moved from a per-task list to
 * the device's request_queue in a batch, this results in improved scalability
 * as the lock contention for request_queue lock is reduced.
 *
 * It is ok not to disable preemption when adding the request to the plug list
 * or when attempting a merge, because blk_schedule_flush_list() will only flush
 * the plug list when the task sleeps by itself. For details, please see
 * schedule() where blk_schedule_flush_plug() is called.
1163
 */
1164
struct blk_plug {
1165
	struct list_head mq_list; /* blk-mq requests */
S
Suresh Jayaraman 已提交
1166
	struct list_head cb_list; /* md requires an unplug callback */
1167
	unsigned short rq_count;
1168
	bool multiple_queues;
1169
};
1170
#define BLK_MAX_REQUEST_COUNT 16
1171
#define BLK_PLUG_FLUSH_SIZE (128 * 1024)
1172

1173
struct blk_plug_cb;
1174
typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool);
1175 1176
struct blk_plug_cb {
	struct list_head list;
1177 1178
	blk_plug_cb_fn callback;
	void *data;
1179
};
1180 1181
extern struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug,
					     void *data, int size);
1182 1183
extern void blk_start_plug(struct blk_plug *);
extern void blk_finish_plug(struct blk_plug *);
1184
extern void blk_flush_plug_list(struct blk_plug *, bool);
1185 1186 1187 1188 1189

static inline void blk_flush_plug(struct task_struct *tsk)
{
	struct blk_plug *plug = tsk->plug;

1190 1191 1192 1193 1194 1195 1196 1197
	if (plug)
		blk_flush_plug_list(plug, false);
}

static inline void blk_schedule_flush_plug(struct task_struct *tsk)
{
	struct blk_plug *plug = tsk->plug;

1198
	if (plug)
1199
		blk_flush_plug_list(plug, true);
1200 1201 1202 1203 1204 1205
}

static inline bool blk_needs_flush_plug(struct task_struct *tsk)
{
	struct blk_plug *plug = tsk->plug;

1206
	return plug &&
J
Jens Axboe 已提交
1207
		 (!list_empty(&plug->mq_list) ||
1208
		 !list_empty(&plug->cb_list));
1209 1210
}

1211 1212 1213
extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
		sector_t nr_sects, gfp_t gfp_mask, struct page *page);
1214 1215

#define BLKDEV_DISCARD_SECURE	(1 << 0)	/* issue a secure erase */
1216

1217 1218
extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
		sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
1219
extern int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,
1220
		sector_t nr_sects, gfp_t gfp_mask, int flags,
1221
		struct bio **biop);
1222 1223

#define BLKDEV_ZERO_NOUNMAP	(1 << 0)  /* do not free blocks */
1224
#define BLKDEV_ZERO_NOFALLBACK	(1 << 1)  /* don't write explicit zeroes */
1225

1226 1227
extern int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
		sector_t nr_sects, gfp_t gfp_mask, struct bio **biop,
1228
		unsigned flags);
1229
extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
1230 1231
		sector_t nr_sects, gfp_t gfp_mask, unsigned flags);

1232 1233
static inline int sb_issue_discard(struct super_block *sb, sector_t block,
		sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
D
David Woodhouse 已提交
1234
{
1235 1236 1237 1238 1239
	return blkdev_issue_discard(sb->s_bdev,
				    block << (sb->s_blocksize_bits -
					      SECTOR_SHIFT),
				    nr_blocks << (sb->s_blocksize_bits -
						  SECTOR_SHIFT),
1240
				    gfp_mask, flags);
D
David Woodhouse 已提交
1241
}
1242
static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
1243
		sector_t nr_blocks, gfp_t gfp_mask)
1244 1245
{
	return blkdev_issue_zeroout(sb->s_bdev,
1246 1247 1248 1249
				    block << (sb->s_blocksize_bits -
					      SECTOR_SHIFT),
				    nr_blocks << (sb->s_blocksize_bits -
						  SECTOR_SHIFT),
1250
				    gfp_mask, 0);
1251
}
L
Linus Torvalds 已提交
1252

1253
extern int blk_verify_command(unsigned char *cmd, fmode_t mode);
1254

1255 1256 1257
enum blk_default_limits {
	BLK_MAX_SEGMENTS	= 128,
	BLK_SAFE_MAX_SECTORS	= 255,
1258
	BLK_DEF_MAX_SECTORS	= 2560,
1259 1260 1261
	BLK_MAX_SEGMENT_SIZE	= 65536,
	BLK_SEG_BOUNDARY_MASK	= 0xFFFFFFFFUL,
};
1262

1263
static inline unsigned long queue_segment_boundary(const struct request_queue *q)
1264
{
1265
	return q->limits.seg_boundary_mask;
1266 1267
}

1268
static inline unsigned long queue_virt_boundary(const struct request_queue *q)
1269 1270 1271 1272
{
	return q->limits.virt_boundary_mask;
}

1273
static inline unsigned int queue_max_sectors(const struct request_queue *q)
1274
{
1275
	return q->limits.max_sectors;
1276 1277
}

1278
static inline unsigned int queue_max_hw_sectors(const struct request_queue *q)
1279
{
1280
	return q->limits.max_hw_sectors;
1281 1282
}

1283
static inline unsigned short queue_max_segments(const struct request_queue *q)
1284
{
1285
	return q->limits.max_segments;
1286 1287
}

1288
static inline unsigned short queue_max_discard_segments(const struct request_queue *q)
1289 1290 1291 1292
{
	return q->limits.max_discard_segments;
}

1293
static inline unsigned int queue_max_segment_size(const struct request_queue *q)
1294
{
1295
	return q->limits.max_segment_size;
1296 1297
}

1298
static inline unsigned short queue_logical_block_size(const struct request_queue *q)
L
Linus Torvalds 已提交
1299 1300 1301
{
	int retval = 512;

1302 1303
	if (q && q->limits.logical_block_size)
		retval = q->limits.logical_block_size;
L
Linus Torvalds 已提交
1304 1305 1306 1307

	return retval;
}

1308
static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
L
Linus Torvalds 已提交
1309
{
1310
	return queue_logical_block_size(bdev_get_queue(bdev));
L
Linus Torvalds 已提交
1311 1312
}

1313
static inline unsigned int queue_physical_block_size(const struct request_queue *q)
1314 1315 1316 1317
{
	return q->limits.physical_block_size;
}

1318
static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
M
Martin K. Petersen 已提交
1319 1320 1321 1322
{
	return queue_physical_block_size(bdev_get_queue(bdev));
}

1323
static inline unsigned int queue_io_min(const struct request_queue *q)
1324 1325 1326 1327
{
	return q->limits.io_min;
}

M
Martin K. Petersen 已提交
1328 1329 1330 1331 1332
static inline int bdev_io_min(struct block_device *bdev)
{
	return queue_io_min(bdev_get_queue(bdev));
}

1333
static inline unsigned int queue_io_opt(const struct request_queue *q)
1334 1335 1336 1337
{
	return q->limits.io_opt;
}

M
Martin K. Petersen 已提交
1338 1339 1340 1341 1342
static inline int bdev_io_opt(struct block_device *bdev)
{
	return queue_io_opt(bdev_get_queue(bdev));
}

1343
static inline int queue_alignment_offset(const struct request_queue *q)
1344
{
M
Martin K. Petersen 已提交
1345
	if (q->limits.misaligned)
1346 1347
		return -1;

M
Martin K. Petersen 已提交
1348
	return q->limits.alignment_offset;
1349 1350
}

1351
static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
1352 1353
{
	unsigned int granularity = max(lim->physical_block_size, lim->io_min);
1354 1355
	unsigned int alignment = sector_div(sector, granularity >> SECTOR_SHIFT)
		<< SECTOR_SHIFT;
1356

1357
	return (granularity + lim->alignment_offset - alignment) % granularity;
1358 1359
}

M
Martin K. Petersen 已提交
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
static inline int bdev_alignment_offset(struct block_device *bdev)
{
	struct request_queue *q = bdev_get_queue(bdev);

	if (q->limits.misaligned)
		return -1;

	if (bdev != bdev->bd_contains)
		return bdev->bd_part->alignment_offset;

	return q->limits.alignment_offset;
}

1373
static inline int queue_discard_alignment(const struct request_queue *q)
1374 1375 1376 1377 1378 1379 1380
{
	if (q->limits.discard_misaligned)
		return -1;

	return q->limits.discard_alignment;
}

1381
static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
1382
{
1383
	unsigned int alignment, granularity, offset;
1384

1385 1386 1387
	if (!lim->max_discard_sectors)
		return 0;

1388
	/* Why are these in bytes, not sectors? */
1389 1390
	alignment = lim->discard_alignment >> SECTOR_SHIFT;
	granularity = lim->discard_granularity >> SECTOR_SHIFT;
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
	if (!granularity)
		return 0;

	/* Offset of the partition start in 'granularity' sectors */
	offset = sector_div(sector, granularity);

	/* And why do we do this modulus *again* in blkdev_issue_discard()? */
	offset = (granularity + alignment - offset) % granularity;

	/* Turn it back into bytes, gaah */
1401
	return offset << SECTOR_SHIFT;
1402 1403
}

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
static inline int bdev_discard_alignment(struct block_device *bdev)
{
	struct request_queue *q = bdev_get_queue(bdev);

	if (bdev != bdev->bd_contains)
		return bdev->bd_part->discard_alignment;

	return q->limits.discard_alignment;
}

1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
static inline unsigned int bdev_write_same(struct block_device *bdev)
{
	struct request_queue *q = bdev_get_queue(bdev);

	if (q)
		return q->limits.max_write_same_sectors;

	return 0;
}

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
static inline unsigned int bdev_write_zeroes_sectors(struct block_device *bdev)
{
	struct request_queue *q = bdev_get_queue(bdev);

	if (q)
		return q->limits.max_write_zeroes_sectors;

	return 0;
}

D
Damien Le Moal 已提交
1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
static inline enum blk_zoned_model bdev_zoned_model(struct block_device *bdev)
{
	struct request_queue *q = bdev_get_queue(bdev);

	if (q)
		return blk_queue_zoned_model(q);

	return BLK_ZONED_NONE;
}

static inline bool bdev_is_zoned(struct block_device *bdev)
{
	struct request_queue *q = bdev_get_queue(bdev);

	if (q)
		return blk_queue_is_zoned(q);

	return false;
}

1454
static inline sector_t bdev_zone_sectors(struct block_device *bdev)
1455 1456 1457 1458
{
	struct request_queue *q = bdev_get_queue(bdev);

	if (q)
1459
		return blk_queue_zone_sectors(q);
1460 1461
	return 0;
}
1462

1463
static inline int queue_dma_alignment(const struct request_queue *q)
L
Linus Torvalds 已提交
1464
{
1465
	return q ? q->dma_alignment : 511;
L
Linus Torvalds 已提交
1466 1467
}

1468
static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
1469 1470 1471
				 unsigned int len)
{
	unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1472
	return !(addr & alignment) && !(len & alignment);
1473 1474
}

L
Linus Torvalds 已提交
1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
/* assumes size > 256 */
static inline unsigned int blksize_bits(unsigned int size)
{
	unsigned int bits = 8;
	do {
		bits++;
		size >>= 1;
	} while (size > 256);
	return bits;
}

1486
static inline unsigned int block_size(struct block_device *bdev)
L
Linus Torvalds 已提交
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
{
	return bdev->bd_block_size;
}

typedef struct {struct page *v;} Sector;

unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);

static inline void put_dev_sector(Sector p)
{
1497
	put_page(p.v);
L
Linus Torvalds 已提交
1498 1499
}

1500
int kblockd_schedule_work(struct work_struct *work);
1501
int kblockd_schedule_work_on(int cpu, struct work_struct *work);
1502
int kblockd_mod_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
L
Linus Torvalds 已提交
1503 1504 1505 1506 1507 1508

#define MODULE_ALIAS_BLOCKDEV(major,minor) \
	MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
#define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
	MODULE_ALIAS("block-major-" __stringify(major) "-*")

1509 1510
#if defined(CONFIG_BLK_DEV_INTEGRITY)

1511 1512 1513
enum blk_integrity_flags {
	BLK_INTEGRITY_VERIFY		= 1 << 0,
	BLK_INTEGRITY_GENERATE		= 1 << 1,
1514
	BLK_INTEGRITY_DEVICE_CAPABLE	= 1 << 2,
1515
	BLK_INTEGRITY_IP_CHECKSUM	= 1 << 3,
1516
};
1517

1518
struct blk_integrity_iter {
1519 1520
	void			*prot_buf;
	void			*data_buf;
1521
	sector_t		seed;
1522
	unsigned int		data_size;
1523
	unsigned short		interval;
1524 1525 1526
	const char		*disk_name;
};

1527
typedef blk_status_t (integrity_processing_fn) (struct blk_integrity_iter *);
1528 1529
typedef void (integrity_prepare_fn) (struct request *);
typedef void (integrity_complete_fn) (struct request *, unsigned int);
1530

1531 1532 1533
struct blk_integrity_profile {
	integrity_processing_fn		*generate_fn;
	integrity_processing_fn		*verify_fn;
1534 1535
	integrity_prepare_fn		*prepare_fn;
	integrity_complete_fn		*complete_fn;
1536 1537
	const char			*name;
};
1538

1539
extern void blk_integrity_register(struct gendisk *, struct blk_integrity *);
1540
extern void blk_integrity_unregister(struct gendisk *);
1541
extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
1542 1543 1544
extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
				   struct scatterlist *);
extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
1545 1546 1547 1548
extern bool blk_integrity_merge_rq(struct request_queue *, struct request *,
				   struct request *);
extern bool blk_integrity_merge_bio(struct request_queue *, struct request *,
				    struct bio *);
1549

1550
static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
1551
{
1552
	struct blk_integrity *bi = &disk->queue->integrity;
1553 1554 1555 1556 1557

	if (!bi->profile)
		return NULL;

	return bi;
1558 1559
}

1560 1561
static inline
struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
1562
{
1563
	return blk_get_integrity(bdev->bd_disk);
1564 1565
}

1566
static inline bool blk_integrity_rq(struct request *rq)
1567
{
1568
	return rq->cmd_flags & REQ_INTEGRITY;
1569 1570
}

1571 1572 1573 1574 1575 1576 1577
static inline void blk_queue_max_integrity_segments(struct request_queue *q,
						    unsigned int segs)
{
	q->limits.max_integrity_segments = segs;
}

static inline unsigned short
1578
queue_max_integrity_segments(const struct request_queue *q)
1579 1580 1581 1582
{
	return q->limits.max_integrity_segments;
}

1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
/**
 * bio_integrity_intervals - Return number of integrity intervals for a bio
 * @bi:		blk_integrity profile for device
 * @sectors:	Size of the bio in 512-byte sectors
 *
 * Description: The block layer calculates everything in 512 byte
 * sectors but integrity metadata is done in terms of the data integrity
 * interval size of the storage device.  Convert the block layer sectors
 * to the appropriate number of integrity intervals.
 */
static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
						   unsigned int sectors)
{
	return sectors >> (bi->interval_exp - 9);
}

static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
					       unsigned int sectors)
{
	return bio_integrity_intervals(bi, sectors) * bi->tuple_size;
}

1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
/*
 * Return the first bvec that contains integrity data.  Only drivers that are
 * limited to a single integrity segment should use this helper.
 */
static inline struct bio_vec *rq_integrity_vec(struct request *rq)
{
	if (WARN_ON_ONCE(queue_max_integrity_segments(rq->q) > 1))
		return NULL;
	return rq->bio->bi_integrity->bip_vec;
}

1616 1617
#else /* CONFIG_BLK_DEV_INTEGRITY */

1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
struct bio;
struct block_device;
struct gendisk;
struct blk_integrity;

static inline int blk_integrity_rq(struct request *rq)
{
	return 0;
}
static inline int blk_rq_count_integrity_sg(struct request_queue *q,
					    struct bio *b)
{
	return 0;
}
static inline int blk_rq_map_integrity_sg(struct request_queue *q,
					  struct bio *b,
					  struct scatterlist *s)
{
	return 0;
}
static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
{
1640
	return NULL;
1641 1642 1643 1644 1645 1646 1647 1648 1649
}
static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
{
	return NULL;
}
static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
{
	return 0;
}
1650
static inline void blk_integrity_register(struct gendisk *d,
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
					 struct blk_integrity *b)
{
}
static inline void blk_integrity_unregister(struct gendisk *d)
{
}
static inline void blk_queue_max_integrity_segments(struct request_queue *q,
						    unsigned int segs)
{
}
1661
static inline unsigned short queue_max_integrity_segments(const struct request_queue *q)
1662 1663 1664
{
	return 0;
}
1665 1666 1667
static inline bool blk_integrity_merge_rq(struct request_queue *rq,
					  struct request *r1,
					  struct request *r2)
1668
{
1669
	return true;
1670
}
1671 1672 1673
static inline bool blk_integrity_merge_bio(struct request_queue *rq,
					   struct request *r,
					   struct bio *b)
1674
{
1675
	return true;
1676
}
1677

1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689
static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
						   unsigned int sectors)
{
	return 0;
}

static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
					       unsigned int sectors)
{
	return 0;
}

1690 1691 1692 1693 1694
static inline struct bio_vec *rq_integrity_vec(struct request *rq)
{
	return NULL;
}

1695 1696
#endif /* CONFIG_BLK_DEV_INTEGRITY */

1697
struct block_device_operations {
A
Al Viro 已提交
1698
	int (*open) (struct block_device *, fmode_t);
1699
	void (*release) (struct gendisk *, fmode_t);
1700
	int (*rw_page)(struct block_device *, sector_t, struct page *, unsigned int);
A
Al Viro 已提交
1701 1702
	int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
	int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1703 1704 1705
	unsigned int (*check_events) (struct gendisk *disk,
				      unsigned int clearing);
	/* ->media_changed() is DEPRECATED, use ->check_events() instead */
1706
	int (*media_changed) (struct gendisk *);
1707
	void (*unlock_native_capacity) (struct gendisk *);
1708 1709
	int (*revalidate_disk) (struct gendisk *);
	int (*getgeo)(struct block_device *, struct hd_geometry *);
1710 1711
	/* this callback is with swap_lock and sometimes page table lock held */
	void (*swap_slot_free_notify) (struct block_device *, unsigned long);
1712
	int (*report_zones)(struct gendisk *, sector_t sector,
C
Christoph Hellwig 已提交
1713
			unsigned int nr_zones, report_zones_cb cb, void *data);
1714
	struct module *owner;
1715
	const struct pr_ops *pr_ops;
1716 1717
};

1718 1719
extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
				 unsigned long);
1720 1721 1722
extern int bdev_read_page(struct block_device *, sector_t, struct page *);
extern int bdev_write_page(struct block_device *, sector_t, struct page *,
						struct writeback_control *);
1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776

#ifdef CONFIG_BLK_DEV_ZONED
bool blk_req_needs_zone_write_lock(struct request *rq);
void __blk_req_zone_write_lock(struct request *rq);
void __blk_req_zone_write_unlock(struct request *rq);

static inline void blk_req_zone_write_lock(struct request *rq)
{
	if (blk_req_needs_zone_write_lock(rq))
		__blk_req_zone_write_lock(rq);
}

static inline void blk_req_zone_write_unlock(struct request *rq)
{
	if (rq->rq_flags & RQF_ZONE_WRITE_LOCKED)
		__blk_req_zone_write_unlock(rq);
}

static inline bool blk_req_zone_is_write_locked(struct request *rq)
{
	return rq->q->seq_zones_wlock &&
		test_bit(blk_rq_zone_no(rq), rq->q->seq_zones_wlock);
}

static inline bool blk_req_can_dispatch_to_zone(struct request *rq)
{
	if (!blk_req_needs_zone_write_lock(rq))
		return true;
	return !blk_req_zone_is_write_locked(rq);
}
#else
static inline bool blk_req_needs_zone_write_lock(struct request *rq)
{
	return false;
}

static inline void blk_req_zone_write_lock(struct request *rq)
{
}

static inline void blk_req_zone_write_unlock(struct request *rq)
{
}
static inline bool blk_req_zone_is_write_locked(struct request *rq)
{
	return false;
}

static inline bool blk_req_can_dispatch_to_zone(struct request *rq)
{
	return true;
}
#endif /* CONFIG_BLK_DEV_ZONED */

1777
#else /* CONFIG_BLOCK */
1778 1779 1780

struct block_device;

1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
/*
 * stubs for when the block layer is configured out
 */
#define buffer_heads_over_limit 0

static inline long nr_blockdev_pages(void)
{
	return 0;
}

1791 1792 1793 1794
struct blk_plug {
};

static inline void blk_start_plug(struct blk_plug *plug)
1795 1796 1797
{
}

1798
static inline void blk_finish_plug(struct blk_plug *plug)
1799 1800 1801
{
}

1802
static inline void blk_flush_plug(struct task_struct *task)
1803 1804 1805
{
}

1806 1807 1808 1809 1810
static inline void blk_schedule_flush_plug(struct task_struct *task)
{
}


1811 1812 1813 1814 1815
static inline bool blk_needs_flush_plug(struct task_struct *tsk)
{
	return false;
}

1816 1817 1818 1819 1820 1821
static inline int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
				     sector_t *error_sector)
{
	return 0;
}

1822 1823
#endif /* CONFIG_BLOCK */

J
Jens Axboe 已提交
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
static inline void blk_wake_io_task(struct task_struct *waiter)
{
	/*
	 * If we're polling, the task itself is doing the completions. For
	 * that case, we don't need to signal a wakeup, it's enough to just
	 * mark us as RUNNING.
	 */
	if (waiter == current)
		__set_current_state(TASK_RUNNING);
	else
		wake_up_process(waiter);
}

L
Linus Torvalds 已提交
1837
#endif