#ifndef _LINUX_BLKDEV_H#define _LINUX_BLKDEV_H #include <linux/config.h>#include <linux/major.h>#include <linux/genhd.h>#include <linux/list.h>#include <linux/timer.h>#include <linux/workqueue.h>#include <linux/pagemap.h>#include <linux/backing-dev.h>#include <linux/wait.h>#include <linux/mempool.h>#include <linux/bio.h>#include <linux/module.h>#include <linux/stringify.h> #include <asm/scatterlist.h> struct request_queue;typedef struct request_queue request_queue_t;struct elevator_queue;typedef struct elevator_queue elevator_t;struct request_pm_state; #define BLKDEV_MIN_RQ	4#define BLKDEV_MAX_RQ	128	/* Default maximum */ /* * This is the per-process anticipatory I/O scheduler state. */struct as_io_context {	spinlock_t lock; 	void (*dtor)(struct as_io_context *aic); /* destructor */	void (*exit)(struct as_io_context *aic); /* called on task exit */ 	unsigned long state;	atomic_t nr_queued; /* queued reads & sync writes */	atomic_t nr_dispatched; /* number of requests gone to the drivers */ 	/* IO History tracking */	/* Thinktime */	unsigned long last_end_request;	unsigned long ttime_total;	unsigned long ttime_samples;	unsigned long ttime_mean;	/* Layout pattern */	unsigned int seek_samples;	sector_t last_request_pos;	u64 seek_total;	sector_t seek_mean;}; struct cfq_queue;struct cfq_io_context {	/*	 * circular list of cfq_io_contexts belonging to a process io context	 */	struct list_head list;	struct cfq_queue *cfqq;	void *key; 	struct io_context *ioc; 	unsigned long last_end_request;	unsigned long last_queue;	unsigned long ttime_total;	unsigned long ttime_samples;	unsigned long ttime_mean; 	void (*dtor)(struct cfq_io_context *);	void (*exit)(struct cfq_io_context *);}; /* * This is the per-process I/O subsystem state.  It is refcounted and * kmalloc'ed. Currently all fields are modified in process io context * (apart from the atomic refcount), so require no locking. */struct io_context {	atomic_t refcount;	struct task_struct *task; 	int (*set_ioprio)(struct io_context *, unsigned int); 	/*	 * For request batching	 */	unsigned long last_waited; /* Time last woken after wait for request */	int nr_batch_requests;     /* Number of requests left in the batch */ 	struct as_io_context *aic;	struct cfq_io_context *cic;}; void put_io_context(struct io_context *ioc);void exit_io_context(void);struct io_context *current_io_context(int gfp_flags);struct io_context *get_io_context(int gfp_flags);void copy_io_context(struct io_context **pdst, struct io_context **psrc);void swap_io_context(struct io_context **ioc1, struct io_context **ioc2); struct request;typedef void (rq_end_io_fn)(struct request *); struct request_list {	int count[2];	int starved[2];	mempool_t *rq_pool;	wait_queue_head_t wait[2];	wait_queue_head_t drain;}; #define BLK_MAX_CDB	16 /* * try to put the fields that are referenced together in the same cacheline */struct request {	struct list_head queuelist; /* looking for ->queue? you must _not_				     * access it directly, use				     * blkdev_dequeue_request! */	unsigned long flags;		/* see REQ_ bits below */ 	/* Maintain bio traversal state for part by part I/O submission.	 * hard_* are block layer internals, no driver should touch them!	 */ 	sector_t sector;		/* next sector to submit */	unsigned long nr_sectors;	/* no. of sectors left to submit */	/* no. of sectors left to submit in the current segment */	unsigned int current_nr_sectors; 	sector_t hard_sector;		/* next sector to complete */	unsigned long hard_nr_sectors;	/* no. of sectors left to complete */	/* no. of sectors left to complete in the current segment */	unsigned int hard_cur_sectors; 	struct bio *bio;	struct bio *biotail; 	void *elevator_private; 	unsigned short ioprio; 	int rq_status;	/* should split this into a few status bits */	struct gendisk *rq_disk;	int errors;	unsigned long start_time; 	/* Number of scatter-gather DMA addr+len pairs after	 * physical address coalescing is performed.	 */	unsigned short nr_phys_segments; 	/* Number of scatter-gather addr+len pairs after	 * physical and DMA remapping hardware coalescing is performed.	 * This is the number of scatter-gather entries the driver	 * will actually have to deal with after DMA mapping is done.	 */	unsigned short nr_hw_segments; 	int tag;	char *buffer; 	int ref_count;	request_queue_t *q;	struct request_list *rl; 	struct completion *waiting;	void *special; 	/*	 * when request is used as a packet command carrier	 */	unsigned int cmd_len;	unsigned char cmd[BLK_MAX_CDB]; 	unsigned int data_len;	void *data; 	unsigned int sense_len;	void *sense; 	unsigned int timeout; 	/*	 * For Power Management requests	 */	struct request_pm_state *pm; 	/*	 * completion callback. end_io_data should be folded in with waiting	 */	rq_end_io_fn *end_io;	void *end_io_data;}; /* * first three bits match BIO_RW* bits, important */enum rq_flag_bits {	__REQ_RW,		/* not set, read. set, write */	__REQ_FAILFAST,		/* no low level driver retries */	__REQ_SOFTBARRIER,	/* may not be passed by ioscheduler */	__REQ_HARDBARRIER,	/* may not be passed by drive either */	__REQ_CMD,		/* is a regular fs rw request */	__REQ_NOMERGE,		/* don't touch this for merging */	__REQ_STARTED,		/* drive already may have started this one */	__REQ_DONTPREP,		/* don't call prep for this one */	__REQ_QUEUED,		/* uses queueing */	/*	 * for ATA/ATAPI devices	 */	__REQ_PC,		/* packet command (special) */	__REQ_BLOCK_PC,		/* queued down pc from block layer */	__REQ_SENSE,		/* sense retrival */ 	__REQ_FAILED,		/* set if the request failed */	__REQ_QUIET,		/* don't worry about errors */	__REQ_SPECIAL,		/* driver suplied command */	__REQ_DRIVE_CMD,	__REQ_DRIVE_TASK,	__REQ_DRIVE_TASKFILE,	__REQ_PREEMPT,		/* set for "ide_preempt" requests */	__REQ_PM_SUSPEND,	/* suspend request */	__REQ_PM_RESUME,	/* resume request */	__REQ_PM_SHUTDOWN,	/* shutdown request */	__REQ_BAR_PREFLUSH,	/* barrier pre-flush done */	__REQ_BAR_POSTFLUSH,	/* barrier post-flush */	__REQ_BAR_FLUSH,	/* rq is the flush request */	__REQ_NR_BITS,		/* stops here */}; #define REQ_RW		(1 << __REQ_RW)#define REQ_FAILFAST	(1 << __REQ_FAILFAST)#define REQ_SOFTBARRIER	(1 << __REQ_SOFTBARRIER)#define REQ_HARDBARRIER	(1 << __REQ_HARDBARRIER)#define REQ_CMD		(1 << __REQ_CMD)#define REQ_NOMERGE	(1 << __REQ_NOMERGE)#define REQ_STARTED	(1 << __REQ_STARTED)#define REQ_DONTPREP	(1 << __REQ_DONTPREP)#define REQ_QUEUED	(1 << __REQ_QUEUED)#define REQ_PC		(1 << __REQ_PC)#define REQ_BLOCK_PC	(1 << __REQ_BLOCK_PC)#define REQ_SENSE	(1 << __REQ_SENSE)#define REQ_FAILED	(1 << __REQ_FAILED)#define REQ_QUIET	(1 << __REQ_QUIET)#define REQ_SPECIAL	(1 << __REQ_SPECIAL)#define REQ_DRIVE_CMD	(1 << __REQ_DRIVE_CMD)#define REQ_DRIVE_TASK	(1 << __REQ_DRIVE_TASK)#define REQ_DRIVE_TASKFILE	(1 << __REQ_DRIVE_TASKFILE)#define REQ_PREEMPT	(1 << __REQ_PREEMPT)#define REQ_PM_SUSPEND	(1 << __REQ_PM_SUSPEND)#define REQ_PM_RESUME	(1 << __REQ_PM_RESUME)#define REQ_PM_SHUTDOWN	(1 << __REQ_PM_SHUTDOWN)#define REQ_BAR_PREFLUSH	(1 << __REQ_BAR_PREFLUSH)#define REQ_BAR_POSTFLUSH	(1 << __REQ_BAR_POSTFLUSH)#define REQ_BAR_FLUSH	(1 << __REQ_BAR_FLUSH) /* * State information carried for REQ_PM_SUSPEND and REQ_PM_RESUME * requests. Some step values could eventually be made generic. */struct request_pm_state{	/* PM state machine step value, currently driver specific */	int	pm_step;	/* requested PM state value (S1, S2, S3, S4, ...) */	u32	pm_state;	void*	data;		/* for driver use */}; #include <linux/elevator.h> typedef int (merge_request_fn) (request_queue_t *, struct request *,				struct bio *);typedef int (merge_requests_fn) (request_queue_t *, struct request *,				 struct request *);typedef void (request_fn_proc) (request_queue_t *q);typedef int (make_request_fn) (request_queue_t *q, struct bio *bio);typedef int (prep_rq_fn) (request_queue_t *, struct request *);typedef void (unplug_fn) (request_queue_t *); struct bio_vec;typedef int (merge_bvec_fn) (request_queue_t *, struct bio *, struct bio_vec *);typedef void (activity_fn) (void *data, int rw);typedef int (issue_flush_fn) (request_queue_t *, struct gendisk *, sector_t *);typedef int (prepare_flush_fn) (request_queue_t *, struct request *);typedef void (end_flush_fn) (request_queue_t *, struct request *); enum blk_queue_state {	Queue_down,	Queue_up,}; struct blk_queue_tag {	struct request **tag_index;	/* map of busy tags */	unsigned long *tag_map;		/* bit map of free/busy tags */	struct list_head busy_list;	/* fifo list of busy tags */	int busy;			/* current depth */	int max_depth;			/* what we will send to device */	int real_max_depth;		/* what the array can hold */	atomic_t refcnt;		/* map can be shared */}; struct request_queue{	/*	 * Together with queue_head for cacheline sharing	 */	struct list_head	queue_head;	struct request		*last_merge;	elevator_t		*elevator; 	/*	 * the queue request freelist, one for reads and one for writes	 */	struct request_list	rq; 	request_fn_proc		*request_fn;	merge_request_fn	*back_merge_fn;	merge_request_fn	*front_merge_fn;	merge_requests_fn	*merge_requests_fn;	make_request_fn		*make_request_fn;	prep_rq_fn		*prep_rq_fn;	unplug_fn		*unplug_fn;	merge_bvec_fn		*merge_bvec_fn;	activity_fn		*activity_fn;	issue_flush_fn		*issue_flush_fn;	prepare_flush_fn	*prepare_flush_fn;	end_flush_fn		*end_flush_fn; 	/*	 * Auto-unplugging state	 */	struct timer_list	unplug_timer;	int			unplug_thresh;	/* After this many requests */	unsigned long		unplug_delay;	/* After this many jiffies */	struct work_struct	unplug_work; 	struct backing_dev_info	backing_dev_info; 	/*	 * The queue owner gets to use this for whatever they like.	 * ll_rw_blk doesn't touch it.	 */	void			*queuedata; 	void			*activity_data; 	/*	 * queue needs bounce pages for pages above this limit	 */	unsigned long		bounce_pfn;	unsigned int		bounce_gfp; 	/*	 * various queue flags, see QUEUE_* below	 */	unsigned long		queue_flags; 	/*	 * protects queue structures from reentrancy. ->__queue_lock should	 * _never_ be used directly, it is queue private. always use	 * ->queue_lock.	 */	spinlock_t		__queue_lock;	spinlock_t		*queue_lock; 	/*	 * queue kobject	 */	struct kobject kobj; 	/*	 * queue settings	 */	unsigned long		nr_requests;	/* Max # of requests */	unsigned int		nr_congestion_on;	unsigned int		nr_congestion_off;	unsigned int		nr_batching; 	unsigned short		max_sectors;	unsigned short		max_hw_sectors;	unsigned short		max_phys_segments;	unsigned short		max_hw_segments;	unsigned short		hardsect_size;	unsigned int		max_segment_size; 	unsigned long		seg_boundary_mask;	unsigned int		dma_alignment; 	struct blk_queue_tag	*queue_tags; 	atomic_t		refcnt; 	unsigned int		in_flight; 	/*	 * sg stuff	 */	unsigned int		sg_timeout;	unsigned int		sg_reserved_size;	int			node; 	struct list_head	drain_list; 	/*	 * reserved for flush operations	 */	struct request		*flush_rq;	unsigned char		ordered;}; enum {	QUEUE_ORDERED_NONE,	QUEUE_ORDERED_TAG,	QUEUE_ORDERED_FLUSH,}; #define RQ_INACTIVE		(-1)#define RQ_ACTIVE		1#define RQ_SCSI_BUSY		0xffff#define RQ_SCSI_DONE		0xfffe#define RQ_SCSI_DISCONNECTING	0xffe0 #define QUEUE_FLAG_CLUSTER	0	/* cluster several segments into 1 */#define QUEUE_FLAG_QUEUED	1	/* uses generic tag queueing */#define QUEUE_FLAG_STOPPED	2	/* queue is stopped */#define	QUEUE_FLAG_READFULL	3	/* write queue has been filled */#define QUEUE_FLAG_WRITEFULL	4	/* read queue has been filled */#define QUEUE_FLAG_DEAD		5	/* queue being torn down */#define QUEUE_FLAG_REENTER	6	/* Re-entrancy avoidance */#define QUEUE_FLAG_PLUGGED	7	/* queue is plugged */#define QUEUE_FLAG_DRAIN	8	/* draining queue for sched switch */#define QUEUE_FLAG_FLUSH	9	/* doing barrier flush sequence */ #define blk_queue_plugged(q)	test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)#define blk_queue_tagged(q)	test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)#define blk_queue_stopped(q)	test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)#define blk_queue_flushing(q)	test_bit(QUEUE_FLAG_FLUSH, &(q)->queue_flags) #define blk_fs_request(rq)	((rq)->flags & REQ_CMD)#define blk_pc_request(rq)	((rq)->flags & REQ_BLOCK_PC)#define blk_noretry_request(rq)	((rq)->flags & REQ_FAILFAST)#define blk_rq_started(rq)	((rq)->flags & REQ_STARTED) #define blk_account_rq(rq)	(blk_rq_started(rq) && blk_fs_request(rq)) #define blk_pm_suspend_request(rq)	((rq)->flags & REQ_PM_SUSPEND)#define blk_pm_resume_request(rq)	((rq)->flags & REQ_PM_RESUME)#define blk_pm_request(rq)	\	((rq)->flags & (REQ_PM_SUSPEND | REQ_PM_RESUME)) #define blk_barrier_rq(rq)	((rq)->flags & REQ_HARDBARRIER)#define blk_barrier_preflush(rq)	((rq)->flags & REQ_BAR_PREFLUSH)#define blk_barrier_postflush(rq)	((rq)->flags & REQ_BAR_POSTFLUSH) #define list_entry_rq(ptr)	list_entry((ptr), struct request, queuelist) #define rq_data_dir(rq)		((rq)->flags & 1) static inline int blk_queue_full(struct request_queue *q, int rw){	if (rw == READ)		return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);	return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);} static inline void blk_set_queue_full(struct request_queue *q, int rw){	if (rw == READ)		set_bit(QUEUE_FLAG_READFULL, &q->queue_flags);	else		set_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);} static inline void blk_clear_queue_full(struct request_queue *q, int rw){	if (rw == READ)		clear_bit(QUEUE_FLAG_READFULL, &q->queue_flags);	else		clear_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);}  /* * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may * it already be started by driver. */#define RQ_NOMERGE_FLAGS	\	(REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)#define rq_mergeable(rq)	\	(!((rq)->flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq))) /* * noop, requests are automagically marked as active/inactive by I/O * scheduler -- see elv_next_request

Lines 1–500 of 769. Load more