2005-04-16 22:20:36 +00:00
|
|
|
#ifndef _LINUX_BLKDEV_H
|
|
|
|
#define _LINUX_BLKDEV_H
|
|
|
|
|
2007-09-21 07:19:54 +00:00
|
|
|
#ifdef CONFIG_BLOCK
|
|
|
|
|
2006-08-31 10:56:06 +00:00
|
|
|
#include <linux/sched.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#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>
|
2008-09-11 08:57:55 +00:00
|
|
|
#include <linux/gfp.h>
|
2007-07-09 10:40:35 +00:00
|
|
|
#include <linux/bsg.h>
|
2008-09-13 18:26:01 +00:00
|
|
|
#include <linux/smp.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/scatterlist.h>
|
|
|
|
|
2006-03-22 16:52:04 +00:00
|
|
|
struct scsi_ioctl_command;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct request_queue;
|
|
|
|
struct elevator_queue;
|
|
|
|
struct request_pm_state;
|
2006-03-23 19:00:26 +00:00
|
|
|
struct blk_trace;
|
2007-07-09 10:38:05 +00:00
|
|
|
struct request;
|
|
|
|
struct sg_io_hdr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define BLKDEV_MIN_RQ 4
|
|
|
|
#define BLKDEV_MAX_RQ 128 /* Default maximum */
|
|
|
|
|
|
|
|
struct request;
|
2006-01-06 08:49:03 +00:00
|
|
|
typedef void (rq_end_io_fn)(struct request *, int);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct request_list {
|
|
|
|
int count[2];
|
|
|
|
int starved[2];
|
2005-10-28 06:29:39 +00:00
|
|
|
int elvpriv;
|
2005-04-16 22:20:36 +00:00
|
|
|
mempool_t *rq_pool;
|
|
|
|
wait_queue_head_t wait[2];
|
|
|
|
};
|
|
|
|
|
2006-08-10 06:44:47 +00:00
|
|
|
/*
|
|
|
|
* request command types
|
|
|
|
*/
|
|
|
|
enum rq_cmd_type_bits {
|
|
|
|
REQ_TYPE_FS = 1, /* fs request */
|
|
|
|
REQ_TYPE_BLOCK_PC, /* scsi command */
|
|
|
|
REQ_TYPE_SENSE, /* sense request */
|
|
|
|
REQ_TYPE_PM_SUSPEND, /* suspend request */
|
|
|
|
REQ_TYPE_PM_RESUME, /* resume request */
|
|
|
|
REQ_TYPE_PM_SHUTDOWN, /* shutdown request */
|
|
|
|
REQ_TYPE_SPECIAL, /* driver defined type */
|
|
|
|
REQ_TYPE_LINUX_BLOCK, /* generic block layer message */
|
|
|
|
/*
|
|
|
|
* for ATA/ATAPI devices. this really doesn't belong here, ide should
|
|
|
|
* use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
|
|
|
|
* private REQ_LB opcodes to differentiate what type of request this is
|
|
|
|
*/
|
|
|
|
REQ_TYPE_ATA_TASKFILE,
|
2006-10-12 13:08:45 +00:00
|
|
|
REQ_TYPE_ATA_PC,
|
2006-08-10 06:44:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
|
|
|
|
* sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
|
|
|
|
* SCSI cdb.
|
|
|
|
*
|
|
|
|
* 0x00 -> 0x3f are driver private, to be used for whatever purpose they need,
|
|
|
|
* typically to differentiate REQ_TYPE_SPECIAL requests.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
REQ_LB_OP_EJECT = 0x40, /* eject request */
|
2008-08-13 11:35:09 +00:00
|
|
|
REQ_LB_OP_FLUSH = 0x41, /* flush request */
|
2008-08-05 17:08:25 +00:00
|
|
|
REQ_LB_OP_DISCARD = 0x42, /* discard sectors */
|
2006-08-10 06:44:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2008-08-09 15:22:17 +00:00
|
|
|
* request type modified bits. first two bits match BIO_RW* bits, important
|
2006-08-10 06:44:47 +00:00
|
|
|
*/
|
|
|
|
enum rq_flag_bits {
|
|
|
|
__REQ_RW, /* not set, read. set, write */
|
2008-08-19 23:45:30 +00:00
|
|
|
__REQ_FAILFAST_DEV, /* no driver retries of device errors */
|
|
|
|
__REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */
|
|
|
|
__REQ_FAILFAST_DRIVER, /* no driver retries of driver errors */
|
2008-08-05 17:01:53 +00:00
|
|
|
__REQ_DISCARD, /* request to discard sectors */
|
2006-08-10 06:44:47 +00:00
|
|
|
__REQ_SORTED, /* elevator knows about this request */
|
|
|
|
__REQ_SOFTBARRIER, /* may not be passed by ioscheduler */
|
|
|
|
__REQ_HARDBARRIER, /* may not be passed by drive either */
|
|
|
|
__REQ_FUA, /* forced unit access */
|
|
|
|
__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 */
|
|
|
|
__REQ_ELVPRIV, /* elevator private data attached */
|
|
|
|
__REQ_FAILED, /* set if the request failed */
|
|
|
|
__REQ_QUIET, /* don't worry about errors */
|
|
|
|
__REQ_PREEMPT, /* set for "ide_preempt" requests */
|
|
|
|
__REQ_ORDERED_COLOR, /* is before or after barrier */
|
|
|
|
__REQ_RW_SYNC, /* request is sync (O_DIRECT) */
|
2006-08-10 06:59:11 +00:00
|
|
|
__REQ_ALLOCED, /* request came from our alloc pool */
|
2006-08-10 07:01:02 +00:00
|
|
|
__REQ_RW_META, /* metadata io request */
|
2008-04-11 10:56:52 +00:00
|
|
|
__REQ_COPY_USER, /* contains copies of user pages */
|
2008-06-30 18:04:41 +00:00
|
|
|
__REQ_INTEGRITY, /* integrity metadata has been remapped */
|
2006-08-10 06:44:47 +00:00
|
|
|
__REQ_NR_BITS, /* stops here */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define REQ_RW (1 << __REQ_RW)
|
2008-08-19 23:45:30 +00:00
|
|
|
#define REQ_FAILFAST_DEV (1 << __REQ_FAILFAST_DEV)
|
|
|
|
#define REQ_FAILFAST_TRANSPORT (1 << __REQ_FAILFAST_TRANSPORT)
|
|
|
|
#define REQ_FAILFAST_DRIVER (1 << __REQ_FAILFAST_DRIVER)
|
2008-08-05 17:01:53 +00:00
|
|
|
#define REQ_DISCARD (1 << __REQ_DISCARD)
|
2006-08-10 06:44:47 +00:00
|
|
|
#define REQ_SORTED (1 << __REQ_SORTED)
|
|
|
|
#define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER)
|
|
|
|
#define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER)
|
|
|
|
#define REQ_FUA (1 << __REQ_FUA)
|
|
|
|
#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_ELVPRIV (1 << __REQ_ELVPRIV)
|
|
|
|
#define REQ_FAILED (1 << __REQ_FAILED)
|
|
|
|
#define REQ_QUIET (1 << __REQ_QUIET)
|
|
|
|
#define REQ_PREEMPT (1 << __REQ_PREEMPT)
|
|
|
|
#define REQ_ORDERED_COLOR (1 << __REQ_ORDERED_COLOR)
|
|
|
|
#define REQ_RW_SYNC (1 << __REQ_RW_SYNC)
|
2006-08-10 06:59:11 +00:00
|
|
|
#define REQ_ALLOCED (1 << __REQ_ALLOCED)
|
2006-08-10 07:01:02 +00:00
|
|
|
#define REQ_RW_META (1 << __REQ_RW_META)
|
2008-04-11 10:56:52 +00:00
|
|
|
#define REQ_COPY_USER (1 << __REQ_COPY_USER)
|
2008-06-30 18:04:41 +00:00
|
|
|
#define REQ_INTEGRITY (1 << __REQ_INTEGRITY)
|
2006-08-10 06:44:47 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define BLK_MAX_CDB 16
|
|
|
|
|
|
|
|
/*
|
2008-02-08 11:41:03 +00:00
|
|
|
* try to put the fields that are referenced together in the same cacheline.
|
|
|
|
* if you modify this structure, be sure to check block/blk-core.c:rq_init()
|
|
|
|
* as well!
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
struct request {
|
2006-01-09 15:02:34 +00:00
|
|
|
struct list_head queuelist;
|
2008-09-13 18:26:01 +00:00
|
|
|
struct call_single_data csd;
|
|
|
|
int cpu;
|
2006-01-09 15:02:34 +00:00
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
struct request_queue *q;
|
2006-08-10 07:00:21 +00:00
|
|
|
|
2006-08-10 06:44:47 +00:00
|
|
|
unsigned int cmd_flags;
|
|
|
|
enum rq_cmd_type_bits cmd_type;
|
2008-09-14 12:55:09 +00:00
|
|
|
unsigned long atomic_flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* 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 */
|
2006-08-10 07:00:21 +00:00
|
|
|
sector_t hard_sector; /* next sector to complete */
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long nr_sectors; /* no. of sectors left to submit */
|
2006-08-10 07:00:21 +00:00
|
|
|
unsigned long hard_nr_sectors; /* no. of sectors left to complete */
|
2005-04-16 22:20:36 +00:00
|
|
|
/* no. of sectors left to submit in the current segment */
|
|
|
|
unsigned int current_nr_sectors;
|
|
|
|
|
|
|
|
/* no. of sectors left to complete in the current segment */
|
|
|
|
unsigned int hard_cur_sectors;
|
|
|
|
|
|
|
|
struct bio *bio;
|
|
|
|
struct bio *biotail;
|
|
|
|
|
2006-07-28 07:23:08 +00:00
|
|
|
struct hlist_node hash; /* merge hash */
|
2006-08-10 07:00:21 +00:00
|
|
|
/*
|
|
|
|
* The rb_node is only used inside the io scheduler, requests
|
|
|
|
* are pruned when moved to the dispatch queue. So let the
|
|
|
|
* completion_data share space with the rb_node.
|
|
|
|
*/
|
|
|
|
union {
|
|
|
|
struct rb_node rb_node; /* sort/lookup */
|
|
|
|
void *completion_data;
|
|
|
|
};
|
2006-07-28 07:23:08 +00:00
|
|
|
|
2006-07-12 12:04:37 +00:00
|
|
|
/*
|
|
|
|
* two pointers are available for the IO schedulers, if they need
|
|
|
|
* more they have to dynamically allocate it.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
void *elevator_private;
|
2006-07-12 12:04:37 +00:00
|
|
|
void *elevator_private2;
|
|
|
|
|
2006-06-13 07:02:34 +00:00
|
|
|
struct gendisk *rq_disk;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long start_time;
|
|
|
|
|
|
|
|
/* Number of scatter-gather DMA addr+len pairs after
|
|
|
|
* physical address coalescing is performed.
|
|
|
|
*/
|
|
|
|
unsigned short nr_phys_segments;
|
|
|
|
|
2006-06-13 07:02:34 +00:00
|
|
|
unsigned short ioprio;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void *special;
|
2006-06-13 07:02:34 +00:00
|
|
|
char *buffer;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-07-28 07:32:07 +00:00
|
|
|
int tag;
|
|
|
|
int errors;
|
|
|
|
|
|
|
|
int ref_count;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* when request is used as a packet command carrier
|
|
|
|
*/
|
2008-04-29 07:54:39 +00:00
|
|
|
unsigned short cmd_len;
|
|
|
|
unsigned char __cmd[BLK_MAX_CDB];
|
|
|
|
unsigned char *cmd;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
unsigned int data_len;
|
2008-03-04 10:17:11 +00:00
|
|
|
unsigned int extra_len; /* length of alignment and padding */
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int sense_len;
|
2006-06-13 07:02:34 +00:00
|
|
|
void *data;
|
2005-04-16 22:20:36 +00:00
|
|
|
void *sense;
|
|
|
|
|
2008-09-14 12:55:09 +00:00
|
|
|
unsigned long deadline;
|
|
|
|
struct list_head timeout_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int timeout;
|
2005-11-11 11:31:37 +00:00
|
|
|
int retries;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2006-09-30 18:29:12 +00:00
|
|
|
* completion callback.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
rq_end_io_fn *end_io;
|
|
|
|
void *end_io_data;
|
2007-07-16 06:52:14 +00:00
|
|
|
|
|
|
|
/* for bidi */
|
|
|
|
struct request *next_rq;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2008-08-14 07:59:13 +00:00
|
|
|
static inline unsigned short req_get_ioprio(struct request *req)
|
|
|
|
{
|
|
|
|
return req->ioprio;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-08-10 06:44:47 +00:00
|
|
|
* State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME
|
2005-04-16 22:20:36 +00:00
|
|
|
* 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>
|
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
typedef void (request_fn_proc) (struct request_queue *q);
|
|
|
|
typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
|
|
|
|
typedef int (prep_rq_fn) (struct request_queue *, struct request *);
|
|
|
|
typedef void (unplug_fn) (struct request_queue *);
|
2008-08-05 17:01:53 +00:00
|
|
|
typedef int (prepare_discard_fn) (struct request_queue *, struct request *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct bio_vec;
|
2008-07-03 07:53:43 +00:00
|
|
|
struct bvec_merge_data {
|
|
|
|
struct block_device *bi_bdev;
|
|
|
|
sector_t bi_sector;
|
|
|
|
unsigned bi_size;
|
|
|
|
unsigned long bi_rw;
|
|
|
|
};
|
|
|
|
typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
|
|
|
|
struct bio_vec *);
|
2007-07-24 07:28:11 +00:00
|
|
|
typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
|
2006-01-09 15:02:34 +00:00
|
|
|
typedef void (softirq_done_fn)(struct request *);
|
2008-02-19 10:36:53 +00:00
|
|
|
typedef int (dma_drain_needed_fn)(struct request *);
|
2008-10-01 14:12:15 +00:00
|
|
|
typedef int (lld_busy_fn) (struct request_queue *q);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-09-14 12:55:09 +00:00
|
|
|
enum blk_eh_timer_return {
|
|
|
|
BLK_EH_NOT_HANDLED,
|
|
|
|
BLK_EH_HANDLED,
|
|
|
|
BLK_EH_RESET_TIMER,
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
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 */
|
|
|
|
int busy; /* current depth */
|
|
|
|
int max_depth; /* what we will send to device */
|
2005-08-05 20:28:11 +00:00
|
|
|
int real_max_depth; /* what the array can hold */
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_t refcnt; /* map can be shared */
|
|
|
|
};
|
|
|
|
|
2008-08-16 05:10:05 +00:00
|
|
|
#define BLK_SCSI_MAX_CMDS (256)
|
|
|
|
#define BLK_SCSI_CMD_PER_LONG (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
|
|
|
|
|
2008-07-26 09:03:25 +00:00
|
|
|
struct blk_cmd_filter {
|
2008-08-16 05:10:05 +00:00
|
|
|
unsigned long read_ok[BLK_SCSI_CMD_PER_LONG];
|
|
|
|
unsigned long write_ok[BLK_SCSI_CMD_PER_LONG];
|
|
|
|
struct kobject kobj;
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct request_queue
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Together with queue_head for cacheline sharing
|
|
|
|
*/
|
|
|
|
struct list_head queue_head;
|
|
|
|
struct request *last_merge;
|
2008-10-31 09:05:07 +00:00
|
|
|
struct elevator_queue *elevator;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* the queue request freelist, one for reads and one for writes
|
|
|
|
*/
|
|
|
|
struct request_list rq;
|
|
|
|
|
|
|
|
request_fn_proc *request_fn;
|
|
|
|
make_request_fn *make_request_fn;
|
|
|
|
prep_rq_fn *prep_rq_fn;
|
|
|
|
unplug_fn *unplug_fn;
|
2008-08-05 17:01:53 +00:00
|
|
|
prepare_discard_fn *prepare_discard_fn;
|
2005-04-16 22:20:36 +00:00
|
|
|
merge_bvec_fn *merge_bvec_fn;
|
|
|
|
prepare_flush_fn *prepare_flush_fn;
|
2006-01-09 15:02:34 +00:00
|
|
|
softirq_done_fn *softirq_done_fn;
|
2008-09-14 12:55:09 +00:00
|
|
|
rq_timed_out_fn *rq_timed_out_fn;
|
2008-02-19 10:36:53 +00:00
|
|
|
dma_drain_needed_fn *dma_drain_needed;
|
2008-10-01 14:12:15 +00:00
|
|
|
lld_busy_fn *lld_busy_fn;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-20 14:23:44 +00:00
|
|
|
/*
|
|
|
|
* Dispatch queue sorting
|
|
|
|
*/
|
2005-10-20 14:37:00 +00:00
|
|
|
sector_t end_sector;
|
2005-10-20 14:23:44 +00:00
|
|
|
struct request *boundary_rq;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* queue needs bounce pages for pages above this limit
|
|
|
|
*/
|
|
|
|
unsigned long bounce_pfn;
|
2005-10-21 07:20:53 +00:00
|
|
|
gfp_t bounce_gfp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* various queue flags, see QUEUE_* below
|
|
|
|
*/
|
|
|
|
unsigned long queue_flags;
|
|
|
|
|
|
|
|
/*
|
2005-04-12 21:22:06 +00:00
|
|
|
* protects queue structures from reentrancy. ->__queue_lock should
|
|
|
|
* _never_ be used directly, it is queue private. always use
|
|
|
|
* ->queue_lock.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-04-12 21:22:06 +00:00
|
|
|
spinlock_t __queue_lock;
|
2005-04-16 22:20:36 +00:00
|
|
|
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;
|
|
|
|
|
2006-01-17 08:04:32 +00:00
|
|
|
unsigned int max_sectors;
|
|
|
|
unsigned int max_hw_sectors;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned short max_phys_segments;
|
|
|
|
unsigned short max_hw_segments;
|
|
|
|
unsigned short hardsect_size;
|
|
|
|
unsigned int max_segment_size;
|
|
|
|
|
|
|
|
unsigned long seg_boundary_mask;
|
2008-01-10 17:30:36 +00:00
|
|
|
void *dma_drain_buffer;
|
|
|
|
unsigned int dma_drain_size;
|
2008-03-04 10:18:17 +00:00
|
|
|
unsigned int dma_pad_mask;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int dma_alignment;
|
|
|
|
|
|
|
|
struct blk_queue_tag *queue_tags;
|
2007-10-25 08:14:47 +00:00
|
|
|
struct list_head tag_busy_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-10 07:52:05 +00:00
|
|
|
unsigned int nr_sorted;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int in_flight;
|
|
|
|
|
2008-09-14 12:55:09 +00:00
|
|
|
unsigned int rq_timeout;
|
|
|
|
struct timer_list timeout;
|
|
|
|
struct list_head timeout_list;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* sg stuff
|
|
|
|
*/
|
|
|
|
unsigned int sg_timeout;
|
|
|
|
unsigned int sg_reserved_size;
|
2005-06-23 07:08:19 +00:00
|
|
|
int node;
|
2006-09-29 08:59:40 +00:00
|
|
|
#ifdef CONFIG_BLK_DEV_IO_TRACE
|
2006-03-23 19:00:26 +00:00
|
|
|
struct blk_trace *blk_trace;
|
2006-09-29 08:59:40 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* reserved for flush operations
|
|
|
|
*/
|
2006-01-06 08:51:03 +00:00
|
|
|
unsigned int ordered, next_ordered, ordseq;
|
|
|
|
int orderr, ordcolor;
|
|
|
|
struct request pre_flush_rq, bar_rq, post_flush_rq;
|
|
|
|
struct request *orig_bar_rq;
|
2006-03-18 23:34:37 +00:00
|
|
|
|
|
|
|
struct mutex sysfs_lock;
|
2007-07-09 10:40:35 +00:00
|
|
|
|
|
|
|
#if defined(CONFIG_BLK_DEV_BSG)
|
|
|
|
struct bsg_class_device bsg_dev;
|
|
|
|
#endif
|
2008-07-26 09:03:25 +00:00
|
|
|
struct blk_cmd_filter cmd_filter;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#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 */
|
2007-07-25 06:45:51 +00:00
|
|
|
#define QUEUE_FLAG_READFULL 3 /* read queue has been filled */
|
|
|
|
#define QUEUE_FLAG_WRITEFULL 4 /* write queue has been filled */
|
2005-04-16 22:20:36 +00:00
|
|
|
#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 */
|
2005-10-28 06:30:39 +00:00
|
|
|
#define QUEUE_FLAG_ELVSWITCH 8 /* don't use elevator, just do FIFO */
|
2007-07-16 06:52:14 +00:00
|
|
|
#define QUEUE_FLAG_BIDI 9 /* queue supports bidi requests */
|
2008-04-29 12:44:19 +00:00
|
|
|
#define QUEUE_FLAG_NOMERGES 10 /* disable merge attempts */
|
2008-09-13 18:26:01 +00:00
|
|
|
#define QUEUE_FLAG_SAME_COMP 11 /* force complete on same CPU */
|
2008-09-14 12:56:33 +00:00
|
|
|
#define QUEUE_FLAG_FAIL_IO 12 /* fake timeout */
|
block: add a queue flag for request stacking support
This patch adds a queue flag to indicate the block device can be
used for request stacking.
Request stacking drivers need to stack their devices on top of
only devices of which q->request_fn is functional.
Since bio stacking drivers (e.g. md, loop) basically initialize
their queue using blk_alloc_queue() and don't set q->request_fn,
the check of (q->request_fn == NULL) looks enough for that purpose.
However, dm will become both types of stacking driver (bio-based and
request-based). And dm will always set q->request_fn even if the dm
device is bio-based of which q->request_fn is not functional actually.
So we need something else to distinguish the type of the device.
Adding a queue flag is a solution for that.
The reason why dm always sets q->request_fn is to keep
the compatibility of dm user-space tools.
Currently, all dm user-space tools are using bio-based dm without
specifying the type of the dm device they use.
To use request-based dm without changing such tools, the kernel
must decide the type of the dm device automatically.
The automatic type decision can't be done at the device creation time
and needs to be deferred until such tools load a mapping table,
since the actual type is decided by dm target type included in
the mapping table.
So a dm device has to be initialized using blk_init_queue()
so that we can load either type of table.
Then, all queue stuffs are set (e.g. q->request_fn) and we have
no element to distinguish that it is bio-based or request-based,
even after a table is loaded and the type of the device is decided.
By the way, some stuffs of the queue (e.g. request_list, elevator)
are needless when the dm device is used as bio-based.
But the memory size is not so large (about 20[KB] per queue on ia64),
so I hope the memory loss can be acceptable for bio-based dm users.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2008-09-18 14:46:13 +00:00
|
|
|
#define QUEUE_FLAG_STACKABLE 13 /* supports request stacking */
|
2008-09-24 11:03:33 +00:00
|
|
|
#define QUEUE_FLAG_NONROT 14 /* non-rotational device (SSD) */
|
2008-10-27 09:44:46 +00:00
|
|
|
#define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */
|
2006-01-06 08:51:03 +00:00
|
|
|
|
2008-04-29 17:16:38 +00:00
|
|
|
static inline int queue_is_locked(struct request_queue *q)
|
|
|
|
{
|
2008-04-29 19:31:27 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2008-04-29 17:16:38 +00:00
|
|
|
spinlock_t *lock = q->queue_lock;
|
|
|
|
return lock && spin_is_locked(lock);
|
2008-04-29 19:31:27 +00:00
|
|
|
#else
|
|
|
|
return 1;
|
|
|
|
#endif
|
2008-04-29 17:16:38 +00:00
|
|
|
}
|
|
|
|
|
2008-04-29 12:48:33 +00:00
|
|
|
static inline void queue_flag_set_unlocked(unsigned int flag,
|
|
|
|
struct request_queue *q)
|
|
|
|
{
|
|
|
|
__set_bit(flag, &q->queue_flags);
|
|
|
|
}
|
|
|
|
|
2008-07-03 11:18:54 +00:00
|
|
|
static inline int queue_flag_test_and_clear(unsigned int flag,
|
|
|
|
struct request_queue *q)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(!queue_is_locked(q));
|
|
|
|
|
|
|
|
if (test_bit(flag, &q->queue_flags)) {
|
|
|
|
__clear_bit(flag, &q->queue_flags);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int queue_flag_test_and_set(unsigned int flag,
|
|
|
|
struct request_queue *q)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(!queue_is_locked(q));
|
|
|
|
|
|
|
|
if (!test_bit(flag, &q->queue_flags)) {
|
|
|
|
__set_bit(flag, &q->queue_flags);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:48:33 +00:00
|
|
|
static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
|
|
|
|
{
|
2008-04-29 17:16:38 +00:00
|
|
|
WARN_ON_ONCE(!queue_is_locked(q));
|
2008-04-29 12:48:33 +00:00
|
|
|
__set_bit(flag, &q->queue_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void queue_flag_clear_unlocked(unsigned int flag,
|
|
|
|
struct request_queue *q)
|
|
|
|
{
|
|
|
|
__clear_bit(flag, &q->queue_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
|
|
|
|
{
|
2008-04-29 17:16:38 +00:00
|
|
|
WARN_ON_ONCE(!queue_is_locked(q));
|
2008-04-29 12:48:33 +00:00
|
|
|
__clear_bit(flag, &q->queue_flags);
|
|
|
|
}
|
|
|
|
|
2006-01-06 08:51:03 +00:00
|
|
|
enum {
|
|
|
|
/*
|
|
|
|
* Hardbarrier is supported with one of the following methods.
|
|
|
|
*
|
|
|
|
* NONE : hardbarrier unsupported
|
|
|
|
* DRAIN : ordering by draining is enough
|
|
|
|
* DRAIN_FLUSH : ordering by draining w/ pre and post flushes
|
|
|
|
* DRAIN_FUA : ordering by draining w/ pre flush and FUA write
|
|
|
|
* TAG : ordering by tag is enough
|
|
|
|
* TAG_FLUSH : ordering by tag w/ pre and post flushes
|
|
|
|
* TAG_FUA : ordering by tag w/ pre flush and FUA write
|
|
|
|
*/
|
2008-11-28 04:32:02 +00:00
|
|
|
QUEUE_ORDERED_BY_DRAIN = 0x01,
|
|
|
|
QUEUE_ORDERED_BY_TAG = 0x02,
|
|
|
|
QUEUE_ORDERED_DO_PREFLUSH = 0x10,
|
2008-11-28 04:32:04 +00:00
|
|
|
QUEUE_ORDERED_DO_BAR = 0x20,
|
2008-11-28 04:32:02 +00:00
|
|
|
QUEUE_ORDERED_DO_POSTFLUSH = 0x40,
|
|
|
|
QUEUE_ORDERED_DO_FUA = 0x80,
|
|
|
|
|
|
|
|
QUEUE_ORDERED_NONE = 0x00,
|
|
|
|
|
2008-11-28 04:32:04 +00:00
|
|
|
QUEUE_ORDERED_DRAIN = QUEUE_ORDERED_BY_DRAIN |
|
|
|
|
QUEUE_ORDERED_DO_BAR,
|
2008-11-28 04:32:02 +00:00
|
|
|
QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN |
|
|
|
|
QUEUE_ORDERED_DO_PREFLUSH |
|
|
|
|
QUEUE_ORDERED_DO_POSTFLUSH,
|
|
|
|
QUEUE_ORDERED_DRAIN_FUA = QUEUE_ORDERED_DRAIN |
|
|
|
|
QUEUE_ORDERED_DO_PREFLUSH |
|
|
|
|
QUEUE_ORDERED_DO_FUA,
|
|
|
|
|
2008-11-28 04:32:04 +00:00
|
|
|
QUEUE_ORDERED_TAG = QUEUE_ORDERED_BY_TAG |
|
|
|
|
QUEUE_ORDERED_DO_BAR,
|
2008-11-28 04:32:02 +00:00
|
|
|
QUEUE_ORDERED_TAG_FLUSH = QUEUE_ORDERED_TAG |
|
|
|
|
QUEUE_ORDERED_DO_PREFLUSH |
|
|
|
|
QUEUE_ORDERED_DO_POSTFLUSH,
|
|
|
|
QUEUE_ORDERED_TAG_FUA = QUEUE_ORDERED_TAG |
|
|
|
|
QUEUE_ORDERED_DO_PREFLUSH |
|
|
|
|
QUEUE_ORDERED_DO_FUA,
|
2006-01-06 08:51:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Ordered operation sequence
|
|
|
|
*/
|
|
|
|
QUEUE_ORDSEQ_STARTED = 0x01, /* flushing in progress */
|
|
|
|
QUEUE_ORDSEQ_DRAIN = 0x02, /* waiting for the queue to be drained */
|
|
|
|
QUEUE_ORDSEQ_PREFLUSH = 0x04, /* pre-flushing in progress */
|
|
|
|
QUEUE_ORDSEQ_BAR = 0x08, /* original barrier req in progress */
|
|
|
|
QUEUE_ORDSEQ_POSTFLUSH = 0x10, /* post-flushing in progress */
|
|
|
|
QUEUE_ORDSEQ_DONE = 0x20,
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#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)
|
2008-04-29 12:44:19 +00:00
|
|
|
#define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
|
2008-09-24 11:03:33 +00:00
|
|
|
#define blk_queue_nonrot(q) test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
|
2006-01-06 08:51:03 +00:00
|
|
|
#define blk_queue_flushing(q) ((q)->ordseq)
|
block: add a queue flag for request stacking support
This patch adds a queue flag to indicate the block device can be
used for request stacking.
Request stacking drivers need to stack their devices on top of
only devices of which q->request_fn is functional.
Since bio stacking drivers (e.g. md, loop) basically initialize
their queue using blk_alloc_queue() and don't set q->request_fn,
the check of (q->request_fn == NULL) looks enough for that purpose.
However, dm will become both types of stacking driver (bio-based and
request-based). And dm will always set q->request_fn even if the dm
device is bio-based of which q->request_fn is not functional actually.
So we need something else to distinguish the type of the device.
Adding a queue flag is a solution for that.
The reason why dm always sets q->request_fn is to keep
the compatibility of dm user-space tools.
Currently, all dm user-space tools are using bio-based dm without
specifying the type of the dm device they use.
To use request-based dm without changing such tools, the kernel
must decide the type of the dm device automatically.
The automatic type decision can't be done at the device creation time
and needs to be deferred until such tools load a mapping table,
since the actual type is decided by dm target type included in
the mapping table.
So a dm device has to be initialized using blk_init_queue()
so that we can load either type of table.
Then, all queue stuffs are set (e.g. q->request_fn) and we have
no element to distinguish that it is bio-based or request-based,
even after a table is loaded and the type of the device is decided.
By the way, some stuffs of the queue (e.g. request_list, elevator)
are needless when the dm device is used as bio-based.
But the memory size is not so large (about 20[KB] per queue on ia64),
so I hope the memory loss can be acceptable for bio-based dm users.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2008-09-18 14:46:13 +00:00
|
|
|
#define blk_queue_stackable(q) \
|
|
|
|
test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-10 06:44:47 +00:00
|
|
|
#define blk_fs_request(rq) ((rq)->cmd_type == REQ_TYPE_FS)
|
|
|
|
#define blk_pc_request(rq) ((rq)->cmd_type == REQ_TYPE_BLOCK_PC)
|
|
|
|
#define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL)
|
|
|
|
#define blk_sense_request(rq) ((rq)->cmd_type == REQ_TYPE_SENSE)
|
|
|
|
|
2008-08-19 23:45:30 +00:00
|
|
|
#define blk_failfast_dev(rq) ((rq)->cmd_flags & REQ_FAILFAST_DEV)
|
|
|
|
#define blk_failfast_transport(rq) ((rq)->cmd_flags & REQ_FAILFAST_TRANSPORT)
|
|
|
|
#define blk_failfast_driver(rq) ((rq)->cmd_flags & REQ_FAILFAST_DRIVER)
|
|
|
|
#define blk_noretry_request(rq) (blk_failfast_dev(rq) || \
|
|
|
|
blk_failfast_transport(rq) || \
|
|
|
|
blk_failfast_driver(rq))
|
2006-08-10 06:44:47 +00:00
|
|
|
#define blk_rq_started(rq) ((rq)->cmd_flags & REQ_STARTED)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-09 15:42:20 +00:00
|
|
|
#define blk_account_rq(rq) (blk_rq_started(rq) && (blk_fs_request(rq) || blk_discard_rq(rq)))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-10 06:44:47 +00:00
|
|
|
#define blk_pm_suspend_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND)
|
|
|
|
#define blk_pm_resume_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_RESUME)
|
2005-04-16 22:20:36 +00:00
|
|
|
#define blk_pm_request(rq) \
|
2006-08-10 06:44:47 +00:00
|
|
|
(blk_pm_suspend_request(rq) || blk_pm_resume_request(rq))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-26 08:25:02 +00:00
|
|
|
#define blk_rq_cpu_valid(rq) ((rq)->cpu != -1)
|
2006-08-10 06:44:47 +00:00
|
|
|
#define blk_sorted_rq(rq) ((rq)->cmd_flags & REQ_SORTED)
|
|
|
|
#define blk_barrier_rq(rq) ((rq)->cmd_flags & REQ_HARDBARRIER)
|
|
|
|
#define blk_fua_rq(rq) ((rq)->cmd_flags & REQ_FUA)
|
2008-08-05 17:01:53 +00:00
|
|
|
#define blk_discard_rq(rq) ((rq)->cmd_flags & REQ_DISCARD)
|
2007-07-16 06:52:14 +00:00
|
|
|
#define blk_bidi_rq(rq) ((rq)->next_rq != NULL)
|
2007-12-11 22:40:30 +00:00
|
|
|
/* rq->queuelist of dequeued request must be list_empty() */
|
|
|
|
#define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist)
|
|
|
|
|
2006-08-10 06:44:47 +00:00
|
|
|
#define rq_data_dir(rq) ((rq)->cmd_flags & 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-07-28 07:26:13 +00:00
|
|
|
/*
|
|
|
|
* We regard a request as sync, if it's a READ or a SYNC write.
|
|
|
|
*/
|
|
|
|
#define rq_is_sync(rq) (rq_data_dir((rq)) == READ || (rq)->cmd_flags & REQ_RW_SYNC)
|
2006-08-10 07:01:02 +00:00
|
|
|
#define rq_is_meta(rq) ((rq)->cmd_flags & REQ_RW_META)
|
2006-07-28 07:26:13 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
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)
|
2008-04-29 12:48:33 +00:00
|
|
|
queue_flag_set(QUEUE_FLAG_READFULL, q);
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2008-04-29 12:48:33 +00:00
|
|
|
queue_flag_set(QUEUE_FLAG_WRITEFULL, q);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void blk_clear_queue_full(struct request_queue *q, int rw)
|
|
|
|
{
|
|
|
|
if (rw == READ)
|
2008-04-29 12:48:33 +00:00
|
|
|
queue_flag_clear(QUEUE_FLAG_READFULL, q);
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2008-04-29 12:48:33 +00:00
|
|
|
queue_flag_clear(QUEUE_FLAG_WRITEFULL, q);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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) \
|
2008-08-09 15:42:20 +00:00
|
|
|
(!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && \
|
|
|
|
(blk_discard_rq(rq) || blk_fs_request((rq))))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* q->prep_rq_fn return values
|
|
|
|
*/
|
|
|
|
#define BLKPREP_OK 0 /* serve it */
|
|
|
|
#define BLKPREP_KILL 1 /* fatal error, kill */
|
|
|
|
#define BLKPREP_DEFER 2 /* leave on queue */
|
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2008-04-21 07:51:05 +00:00
|
|
|
|
|
|
|
#if BITS_PER_LONG == 32
|
2005-04-16 22:20:36 +00:00
|
|
|
#define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT)
|
2008-04-21 07:51:05 +00:00
|
|
|
#else
|
|
|
|
#define BLK_BOUNCE_HIGH -1ULL
|
|
|
|
#endif
|
|
|
|
#define BLK_BOUNCE_ANY (-1ULL)
|
2005-04-16 22:20:36 +00:00
|
|
|
#define BLK_BOUNCE_ISA (ISA_DMA_THRESHOLD)
|
|
|
|
|
2007-07-09 10:38:05 +00:00
|
|
|
/*
|
|
|
|
* default timeout for SG_IO if none specified
|
|
|
|
*/
|
|
|
|
#define BLK_DEFAULT_SG_TIMEOUT (60 * HZ)
|
2008-12-05 22:49:18 +00:00
|
|
|
#define BLK_MIN_SG_TIMEOUT (7 * HZ)
|
2007-07-09 10:38:05 +00:00
|
|
|
|
2007-07-17 11:03:37 +00:00
|
|
|
#ifdef CONFIG_BOUNCE
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int init_emergency_isa_pool(void);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
|
|
|
static inline int init_emergency_isa_pool(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2007-07-24 07:28:11 +00:00
|
|
|
static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_MMU */
|
|
|
|
|
2008-08-28 07:17:06 +00:00
|
|
|
struct rq_map_data {
|
|
|
|
struct page **pages;
|
|
|
|
int page_order;
|
|
|
|
int nr_entries;
|
2008-12-18 05:49:37 +00:00
|
|
|
unsigned long offset;
|
2008-12-18 05:49:38 +00:00
|
|
|
int null_mapped;
|
2008-08-28 07:17:06 +00:00
|
|
|
};
|
|
|
|
|
2007-09-25 10:35:59 +00:00
|
|
|
struct req_iterator {
|
|
|
|
int i;
|
|
|
|
struct bio *bio;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* This should not be used directly - use rq_for_each_segment */
|
|
|
|
#define __rq_for_each_bio(_bio, rq) \
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((rq->bio)) \
|
|
|
|
for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
|
|
|
|
|
2007-09-25 10:35:59 +00:00
|
|
|
#define rq_for_each_segment(bvl, _rq, _iter) \
|
|
|
|
__rq_for_each_bio(_iter.bio, _rq) \
|
|
|
|
bio_for_each_segment(bvl, _iter.bio, _iter.i)
|
|
|
|
|
|
|
|
#define rq_iter_last(rq, _iter) \
|
|
|
|
(_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int blk_register_queue(struct gendisk *disk);
|
|
|
|
extern void blk_unregister_queue(struct gendisk *disk);
|
|
|
|
extern void register_disk(struct gendisk *dev);
|
|
|
|
extern void generic_make_request(struct bio *bio);
|
2008-04-29 07:54:36 +00:00
|
|
|
extern void blk_rq_init(struct request_queue *q, struct request *rq);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void blk_put_request(struct request *);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void __blk_put_request(struct request_queue *, struct request *);
|
|
|
|
extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
|
|
|
|
extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
|
|
|
|
extern void blk_requeue_request(struct request_queue *, struct request *);
|
2008-09-18 14:45:38 +00:00
|
|
|
extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
|
2008-10-01 14:12:15 +00:00
|
|
|
extern int blk_lld_busy(struct request_queue *q);
|
2008-09-18 14:45:38 +00:00
|
|
|
extern int blk_insert_cloned_request(struct request_queue *q,
|
|
|
|
struct request *rq);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void blk_plug_device(struct request_queue *);
|
2008-08-01 18:31:32 +00:00
|
|
|
extern void blk_plug_device_unlocked(struct request_queue *);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern int blk_remove_plug(struct request_queue *);
|
|
|
|
extern void blk_recount_segments(struct request_queue *, struct bio *);
|
2007-08-27 19:38:10 +00:00
|
|
|
extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
|
|
|
|
unsigned int, void __user *);
|
2008-09-02 21:16:41 +00:00
|
|
|
extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
|
|
|
|
struct scsi_ioctl_command __user *);
|
2006-10-20 06:28:16 +00:00
|
|
|
|
2006-12-19 07:33:11 +00:00
|
|
|
/*
|
|
|
|
* Temporary export, until SCSI gets fixed up.
|
|
|
|
*/
|
2007-08-16 11:31:27 +00:00
|
|
|
extern int blk_rq_append_bio(struct request_queue *q, struct request *rq,
|
|
|
|
struct bio *bio);
|
2006-12-19 07:33:11 +00:00
|
|
|
|
2006-10-20 06:28:16 +00:00
|
|
|
/*
|
|
|
|
* A queue has just exitted congestion. Note this in the global counter of
|
|
|
|
* congested queues, and wake up anyone who was waiting for requests to be
|
|
|
|
* put back.
|
|
|
|
*/
|
2007-07-24 07:28:11 +00:00
|
|
|
static inline void blk_clear_queue_congested(struct request_queue *q, int rw)
|
2006-10-20 06:28:16 +00:00
|
|
|
{
|
|
|
|
clear_bdi_congested(&q->backing_dev_info, rw);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A queue has just entered congestion. Flag that in the queue's VM-visible
|
|
|
|
* state flags and increment the global gounter of congested queues.
|
|
|
|
*/
|
2007-07-24 07:28:11 +00:00
|
|
|
static inline void blk_set_queue_congested(struct request_queue *q, int rw)
|
2006-10-20 06:28:16 +00:00
|
|
|
{
|
|
|
|
set_bdi_congested(&q->backing_dev_info, rw);
|
|
|
|
}
|
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void blk_start_queue(struct request_queue *q);
|
|
|
|
extern void blk_stop_queue(struct request_queue *q);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void blk_sync_queue(struct request_queue *q);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void __blk_stop_queue(struct request_queue *q);
|
2008-04-29 12:48:33 +00:00
|
|
|
extern void __blk_run_queue(struct request_queue *);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void blk_run_queue(struct request_queue *);
|
|
|
|
extern void blk_start_queueing(struct request_queue *);
|
2008-08-28 07:17:05 +00:00
|
|
|
extern int blk_rq_map_user(struct request_queue *, struct request *,
|
2008-08-28 07:17:06 +00:00
|
|
|
struct rq_map_data *, void __user *, unsigned long,
|
|
|
|
gfp_t);
|
2006-12-19 10:12:46 +00:00
|
|
|
extern int blk_rq_unmap_user(struct bio *);
|
2007-07-24 07:28:11 +00:00
|
|
|
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 *,
|
2008-08-28 07:17:06 +00:00
|
|
|
struct rq_map_data *, struct sg_iovec *, int,
|
|
|
|
unsigned int, gfp_t);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern int blk_execute_rq(struct request_queue *, struct gendisk *,
|
2005-06-20 12:11:09 +00:00
|
|
|
struct request *, int);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
|
2006-01-06 09:00:50 +00:00
|
|
|
struct request *, int, rq_end_io_fn *);
|
2007-11-07 19:26:56 +00:00
|
|
|
extern void blk_unplug(struct request_queue *q);
|
2005-11-11 11:30:24 +00:00
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return bdev->bd_disk->queue;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
|
|
|
|
struct page *page)
|
|
|
|
{
|
|
|
|
if (bdi && bdi->unplug_io_fn)
|
|
|
|
bdi->unplug_io_fn(bdi, page);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void blk_run_address_space(struct address_space *mapping)
|
|
|
|
{
|
|
|
|
if (mapping)
|
|
|
|
blk_run_backing_dev(mapping->backing_dev_info, NULL);
|
|
|
|
}
|
|
|
|
|
2008-12-03 11:41:26 +00:00
|
|
|
extern void blkdev_dequeue_request(struct request *req);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2007-12-11 22:52:28 +00:00
|
|
|
* blk_end_request() and friends.
|
|
|
|
* __blk_end_request() and end_request() must be called with
|
|
|
|
* the request queue spinlock acquired.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Several drivers define their own end_request and call
|
2007-12-11 22:52:28 +00:00
|
|
|
* blk_end_request() for parts of the original function.
|
|
|
|
* This prevents code duplication in drivers.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-31 11:36:19 +00:00
|
|
|
extern int blk_end_request(struct request *rq, int error,
|
|
|
|
unsigned int nr_bytes);
|
|
|
|
extern int __blk_end_request(struct request *rq, int error,
|
|
|
|
unsigned int nr_bytes);
|
|
|
|
extern int blk_end_bidi_request(struct request *rq, int error,
|
|
|
|
unsigned int nr_bytes, unsigned int bidi_bytes);
|
2007-09-21 08:41:07 +00:00
|
|
|
extern void end_request(struct request *, int);
|
2008-01-31 11:36:19 +00:00
|
|
|
extern int blk_end_request_callback(struct request *rq, int error,
|
|
|
|
unsigned int nr_bytes,
|
|
|
|
int (drv_callback)(struct request *));
|
2006-01-09 15:02:34 +00:00
|
|
|
extern void blk_complete_request(struct request *);
|
2008-09-14 12:55:09 +00:00
|
|
|
extern void __blk_complete_request(struct request *);
|
|
|
|
extern void blk_abort_request(struct request *);
|
2008-09-13 18:31:27 +00:00
|
|
|
extern void blk_abort_queue(struct request_queue *);
|
block: add request update interface
This patch adds blk_update_request(), which updates struct request
with completing its data part, but doesn't complete the struct
request itself.
Though it looks like end_that_request_first() of older kernels,
blk_update_request() should be used only by request stacking drivers.
Request-based dm will use it in bio->bi_end_io callback to update
the original request when a data part of a cloned request completes.
Followings are additional background information of why request-based
dm needs this interface.
- Request stacking drivers can't use blk_end_request() directly from
the lower driver's completion context (bio->bi_end_io or rq->end_io),
because some device drivers (e.g. ide) may try to complete
their request with queue lock held, and it may cause deadlock.
See below for detailed description of possible deadlock:
<http://marc.info/?l=linux-kernel&m=120311479108569&w=2>
- To solve that, request-based dm offloads the completion of
cloned struct request to softirq context (i.e. using
blk_complete_request() from rq->end_io).
- Though it is possible to use the same solution from bio->bi_end_io,
it will delay the notification of bio completion to the original
submitter. Also, it will cause inefficient partial completion,
because the lower driver can't perform the cloned request anymore
and request-based dm needs to requeue and redispatch it to
the lower driver again later. That's not good.
- So request-based dm needs blk_update_request() to perform the bio
completion in the lower driver's completion context, which is more
efficient.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2008-09-18 14:45:09 +00:00
|
|
|
extern void blk_update_request(struct request *rq, int error,
|
|
|
|
unsigned int nr_bytes);
|
2006-01-09 15:02:34 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2007-12-11 22:41:17 +00:00
|
|
|
* blk_end_request() takes bytes instead of sectors as a complete size.
|
|
|
|
* blk_rq_bytes() returns bytes left to complete in the entire request.
|
|
|
|
* blk_rq_cur_bytes() returns bytes left to complete in the current segment.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2007-12-11 22:41:17 +00:00
|
|
|
extern unsigned int blk_rq_bytes(struct request *rq);
|
|
|
|
extern unsigned int blk_rq_cur_bytes(struct request *rq);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Access functions for manipulating queue properties
|
|
|
|
*/
|
2007-07-24 07:28:11 +00:00
|
|
|
extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
|
2005-06-23 07:08:19 +00:00
|
|
|
spinlock_t *lock, int node_id);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
|
|
|
|
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);
|
|
|
|
extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
|
|
|
|
extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
|
|
|
|
extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
|
|
|
|
extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
|
|
|
|
extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
|
|
|
|
extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
|
2008-03-04 10:18:17 +00:00
|
|
|
extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
|
2008-07-04 07:30:03 +00:00
|
|
|
extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
|
2008-02-19 10:36:53 +00:00
|
|
|
extern int blk_queue_dma_drain(struct request_queue *q,
|
|
|
|
dma_drain_needed_fn *dma_drain_needed,
|
|
|
|
void *buf, unsigned int size);
|
2008-10-01 14:12:15 +00:00
|
|
|
extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
|
|
|
|
extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
|
|
|
|
extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
|
|
|
|
extern void blk_queue_dma_alignment(struct request_queue *, int);
|
2007-12-31 22:37:00 +00:00
|
|
|
extern void blk_queue_update_dma_alignment(struct request_queue *, int);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
|
2008-08-05 17:01:53 +00:00
|
|
|
extern void blk_queue_set_discard(struct request_queue *, prepare_discard_fn *);
|
2008-09-14 12:55:09 +00:00
|
|
|
extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
|
|
|
|
extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
|
2008-11-28 04:32:05 +00:00
|
|
|
extern bool blk_do_ordered(struct request_queue *, struct request **);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern unsigned blk_ordered_cur_seq(struct request_queue *);
|
2006-01-06 08:51:03 +00:00
|
|
|
extern unsigned blk_ordered_req_seq(struct request *);
|
2008-11-28 04:32:05 +00:00
|
|
|
extern bool blk_ordered_complete_seq(struct request_queue *, unsigned, int);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void blk_dump_rq_flags(struct request *, char *);
|
2007-07-24 07:28:11 +00:00
|
|
|
extern void generic_unplug_device(struct request_queue *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern long nr_blockdev_pages(void);
|
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
int blk_get_queue(struct request_queue *);
|
|
|
|
struct request_queue *blk_alloc_queue(gfp_t);
|
|
|
|
struct request_queue *blk_alloc_queue_node(gfp_t, int);
|
|
|
|
extern void blk_put_queue(struct request_queue *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* tag stuff
|
|
|
|
*/
|
2006-08-10 06:44:47 +00:00
|
|
|
#define blk_rq_tagged(rq) ((rq)->cmd_flags & REQ_QUEUED)
|
2007-07-24 07:28:11 +00:00
|
|
|
extern int blk_queue_start_tag(struct request_queue *, struct request *);
|
|
|
|
extern struct request *blk_queue_find_tag(struct request_queue *, int);
|
|
|
|
extern void blk_queue_end_tag(struct request_queue *, struct request *);
|
|
|
|
extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
|
|
|
|
extern void blk_queue_free_tags(struct request_queue *);
|
|
|
|
extern int blk_queue_resize_tags(struct request_queue *, int);
|
|
|
|
extern void blk_queue_invalidate_tags(struct request_queue *);
|
2006-08-30 19:48:45 +00:00
|
|
|
extern struct blk_queue_tag *blk_init_tags(int);
|
|
|
|
extern void blk_free_tags(struct blk_queue_tag *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-04 06:27:25 +00:00
|
|
|
static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
|
|
|
|
int tag)
|
|
|
|
{
|
|
|
|
if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
|
|
|
|
return NULL;
|
|
|
|
return bqt->tag_index[tag];
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int blkdev_issue_flush(struct block_device *, sector_t *);
|
2008-09-11 08:57:55 +00:00
|
|
|
extern int blkdev_issue_discard(struct block_device *,
|
|
|
|
sector_t sector, sector_t nr_sects, gfp_t);
|
2008-08-05 17:01:53 +00:00
|
|
|
|
|
|
|
static inline int sb_issue_discard(struct super_block *sb,
|
2008-09-11 08:57:55 +00:00
|
|
|
sector_t block, sector_t nr_blocks)
|
2008-08-05 17:01:53 +00:00
|
|
|
{
|
|
|
|
block <<= (sb->s_blocksize_bits - 9);
|
|
|
|
nr_blocks <<= (sb->s_blocksize_bits - 9);
|
2008-09-11 08:57:55 +00:00
|
|
|
return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL);
|
2008-08-05 17:01:53 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-26 11:48:27 +00:00
|
|
|
/*
|
|
|
|
* command filter functions
|
|
|
|
*/
|
2008-07-26 09:03:25 +00:00
|
|
|
extern int blk_verify_command(struct blk_cmd_filter *filter,
|
2008-09-02 19:28:45 +00:00
|
|
|
unsigned char *cmd, fmode_t has_write_perm);
|
|
|
|
extern void blk_unregister_filter(struct gendisk *disk);
|
2008-07-26 09:03:25 +00:00
|
|
|
extern void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter);
|
2008-06-26 11:48:27 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define MAX_PHYS_SEGMENTS 128
|
|
|
|
#define MAX_HW_SEGMENTS 128
|
2005-12-05 08:37:06 +00:00
|
|
|
#define SAFE_MAX_SECTORS 255
|
|
|
|
#define BLK_DEF_MAX_SECTORS 1024
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define MAX_SEGMENT_SIZE 65536
|
|
|
|
|
2008-12-03 11:55:08 +00:00
|
|
|
#define BLK_SEG_BOUNDARY_MASK 0xFFFFFFFFUL
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
|
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
static inline int queue_hardsect_size(struct request_queue *q)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int retval = 512;
|
|
|
|
|
|
|
|
if (q && q->hardsect_size)
|
|
|
|
retval = q->hardsect_size;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int bdev_hardsect_size(struct block_device *bdev)
|
|
|
|
{
|
|
|
|
return queue_hardsect_size(bdev_get_queue(bdev));
|
|
|
|
}
|
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
static inline int queue_dma_alignment(struct request_queue *q)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-01 15:23:02 +00:00
|
|
|
return q ? q->dma_alignment : 511;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-08-28 06:05:58 +00:00
|
|
|
static inline int blk_rq_aligned(struct request_queue *q, void *addr,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
|
|
|
unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
|
|
|
|
return !((unsigned long)addr & alignment) && !(len & alignment);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2005-09-10 07:27:17 +00:00
|
|
|
static inline unsigned int block_size(struct block_device *bdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
page_cache_release(p.v);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct work_struct;
|
2008-07-28 11:08:45 +00:00
|
|
|
int kblockd_schedule_work(struct request_queue *q, struct work_struct *work);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#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) "-*")
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
|
|
|
|
2008-06-27 07:12:09 +00:00
|
|
|
#define INTEGRITY_FLAG_READ 2 /* verify data integrity on read */
|
|
|
|
#define INTEGRITY_FLAG_WRITE 4 /* generate data integrity on write */
|
2008-06-30 18:04:41 +00:00
|
|
|
|
|
|
|
struct blk_integrity_exchg {
|
|
|
|
void *prot_buf;
|
|
|
|
void *data_buf;
|
|
|
|
sector_t sector;
|
|
|
|
unsigned int data_size;
|
|
|
|
unsigned short sector_size;
|
|
|
|
const char *disk_name;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef void (integrity_gen_fn) (struct blk_integrity_exchg *);
|
|
|
|
typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *);
|
|
|
|
typedef void (integrity_set_tag_fn) (void *, void *, unsigned int);
|
|
|
|
typedef void (integrity_get_tag_fn) (void *, void *, unsigned int);
|
|
|
|
|
|
|
|
struct blk_integrity {
|
|
|
|
integrity_gen_fn *generate_fn;
|
|
|
|
integrity_vrfy_fn *verify_fn;
|
|
|
|
integrity_set_tag_fn *set_tag_fn;
|
|
|
|
integrity_get_tag_fn *get_tag_fn;
|
|
|
|
|
|
|
|
unsigned short flags;
|
|
|
|
unsigned short tuple_size;
|
|
|
|
unsigned short sector_size;
|
|
|
|
unsigned short tag_size;
|
|
|
|
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
struct kobject kobj;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
|
|
|
|
extern void blk_integrity_unregister(struct gendisk *);
|
2008-10-01 07:38:39 +00:00
|
|
|
extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
|
2008-06-30 18:04:41 +00:00
|
|
|
extern int blk_rq_map_integrity_sg(struct request *, struct scatterlist *);
|
|
|
|
extern int blk_rq_count_integrity_sg(struct request *);
|
|
|
|
|
2008-10-02 10:53:22 +00:00
|
|
|
static inline
|
|
|
|
struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
|
|
|
|
{
|
|
|
|
return bdev->bd_disk->integrity;
|
|
|
|
}
|
|
|
|
|
2008-10-02 16:47:49 +00:00
|
|
|
static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
|
|
|
|
{
|
|
|
|
return disk->integrity;
|
|
|
|
}
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
static inline int blk_integrity_rq(struct request *rq)
|
|
|
|
{
|
2008-07-16 20:09:06 +00:00
|
|
|
if (rq->bio == NULL)
|
|
|
|
return 0;
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
return bio_integrity(rq->bio);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_BLK_DEV_INTEGRITY */
|
|
|
|
|
|
|
|
#define blk_integrity_rq(rq) (0)
|
|
|
|
#define blk_rq_count_integrity_sg(a) (0)
|
|
|
|
#define blk_rq_map_integrity_sg(a, b) (0)
|
2008-10-02 10:53:22 +00:00
|
|
|
#define bdev_get_integrity(a) (0)
|
2008-10-02 16:47:49 +00:00
|
|
|
#define blk_get_integrity(a) (0)
|
2008-06-30 18:04:41 +00:00
|
|
|
#define blk_integrity_compare(a, b) (0)
|
|
|
|
#define blk_integrity_register(a, b) (0)
|
|
|
|
#define blk_integrity_unregister(a) do { } while (0);
|
|
|
|
|
|
|
|
#endif /* CONFIG_BLK_DEV_INTEGRITY */
|
|
|
|
|
2007-10-08 17:26:20 +00:00
|
|
|
struct block_device_operations {
|
[PATCH] beginning of methods conversion
To keep the size of changesets sane we split the switch by drivers;
to keep the damn thing bisectable we do the following:
1) rename the affected methods, add ones with correct
prototypes, make (few) callers handle both. That's this changeset.
2) for each driver convert to new methods. *ALL* drivers
are converted in this series.
3) kill the old (renamed) methods.
Note that it _is_ a flagday; all in-tree drivers are converted and by the
end of this series no trace of old methods remain. The only reason why
we do that this way is to keep the damn thing bisectable and allow per-driver
debugging if anything goes wrong.
New methods:
open(bdev, mode)
release(disk, mode)
ioctl(bdev, mode, cmd, arg) /* Called without BKL */
compat_ioctl(bdev, mode, cmd, arg)
locked_ioctl(bdev, mode, cmd, arg) /* Called with BKL, legacy */
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2008-03-02 14:09:22 +00:00
|
|
|
int (*open) (struct block_device *, fmode_t);
|
|
|
|
int (*release) (struct gendisk *, fmode_t);
|
|
|
|
int (*locked_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
|
|
|
|
int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
|
|
|
|
int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
|
2007-10-08 17:26:20 +00:00
|
|
|
int (*direct_access) (struct block_device *, sector_t,
|
|
|
|
void **, unsigned long *);
|
|
|
|
int (*media_changed) (struct gendisk *);
|
|
|
|
int (*revalidate_disk) (struct gendisk *);
|
|
|
|
int (*getgeo)(struct block_device *, struct hd_geometry *);
|
|
|
|
struct module *owner;
|
|
|
|
};
|
|
|
|
|
2007-08-30 00:34:12 +00:00
|
|
|
extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
|
|
|
|
unsigned long);
|
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 18:45:40 +00:00
|
|
|
#else /* CONFIG_BLOCK */
|
|
|
|
/*
|
|
|
|
* stubs for when the block layer is configured out
|
|
|
|
*/
|
|
|
|
#define buffer_heads_over_limit 0
|
|
|
|
|
|
|
|
static inline long nr_blockdev_pages(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_BLOCK */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|