blob: 6a3da6717135d62dc4b581dc84f920a6ac1cc0d8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_BLKDEV_H
2#define _LINUX_BLKDEV_H
3
Jens Axboef5ff8422007-09-21 09:19:54 +02004#ifdef CONFIG_BLOCK
5
Andrew Mortonbcfd8d32006-08-31 12:56:06 +02006#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/major.h>
8#include <linux/genhd.h>
9#include <linux/list.h>
10#include <linux/timer.h>
11#include <linux/workqueue.h>
12#include <linux/pagemap.h>
13#include <linux/backing-dev.h>
14#include <linux/wait.h>
15#include <linux/mempool.h>
16#include <linux/bio.h>
17#include <linux/module.h>
18#include <linux/stringify.h>
FUJITA Tomonorid351af02007-07-09 12:40:35 +020019#include <linux/bsg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
21#include <asm/scatterlist.h>
22
Christoph Hellwig21b2f0c2006-03-22 17:52:04 +010023struct scsi_ioctl_command;
24
Linus Torvalds1da177e2005-04-16 15:20:36 -070025struct request_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -070026struct elevator_queue;
27typedef struct elevator_queue elevator_t;
28struct request_pm_state;
Jens Axboe2056a782006-03-23 20:00:26 +010029struct blk_trace;
Jens Axboe3d6392c2007-07-09 12:38:05 +020030struct request;
31struct sg_io_hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33#define BLKDEV_MIN_RQ 4
34#define BLKDEV_MAX_RQ 128 /* Default maximum */
35
Jens Axboed38ecf92008-01-24 08:53:35 +010036int put_io_context(struct io_context *ioc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070037void exit_io_context(void);
Jens Axboeb5deef92006-07-19 23:39:40 +020038struct io_context *get_io_context(gfp_t gfp_flags, int node);
Jens Axboefd0928d2008-01-24 08:52:45 +010039struct io_context *alloc_io_context(gfp_t gfp_flags, int node);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040void copy_io_context(struct io_context **pdst, struct io_context **psrc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42struct request;
Tejun Heo8ffdc652006-01-06 09:49:03 +010043typedef void (rq_end_io_fn)(struct request *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45struct request_list {
46 int count[2];
47 int starved[2];
Tejun Heocb98fc82005-10-28 08:29:39 +020048 int elvpriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 mempool_t *rq_pool;
50 wait_queue_head_t wait[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -070051};
52
Jens Axboe4aff5e22006-08-10 08:44:47 +020053/*
54 * request command types
55 */
56enum rq_cmd_type_bits {
57 REQ_TYPE_FS = 1, /* fs request */
58 REQ_TYPE_BLOCK_PC, /* scsi command */
59 REQ_TYPE_SENSE, /* sense request */
60 REQ_TYPE_PM_SUSPEND, /* suspend request */
61 REQ_TYPE_PM_RESUME, /* resume request */
62 REQ_TYPE_PM_SHUTDOWN, /* shutdown request */
63 REQ_TYPE_FLUSH, /* flush request */
64 REQ_TYPE_SPECIAL, /* driver defined type */
65 REQ_TYPE_LINUX_BLOCK, /* generic block layer message */
66 /*
67 * for ATA/ATAPI devices. this really doesn't belong here, ide should
68 * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
69 * private REQ_LB opcodes to differentiate what type of request this is
70 */
Jens Axboe4aff5e22006-08-10 08:44:47 +020071 REQ_TYPE_ATA_TASKFILE,
Jens Axboecea28852006-10-12 15:08:45 +020072 REQ_TYPE_ATA_PC,
Jens Axboe4aff5e22006-08-10 08:44:47 +020073};
74
75/*
76 * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
77 * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
78 * SCSI cdb.
79 *
80 * 0x00 -> 0x3f are driver private, to be used for whatever purpose they need,
81 * typically to differentiate REQ_TYPE_SPECIAL requests.
82 *
83 */
84enum {
85 /*
86 * just examples for now
87 */
88 REQ_LB_OP_EJECT = 0x40, /* eject request */
89 REQ_LB_OP_FLUSH = 0x41, /* flush device */
90};
91
92/*
93 * request type modified bits. first three bits match BIO_RW* bits, important
94 */
95enum rq_flag_bits {
96 __REQ_RW, /* not set, read. set, write */
97 __REQ_FAILFAST, /* no low level driver retries */
98 __REQ_SORTED, /* elevator knows about this request */
99 __REQ_SOFTBARRIER, /* may not be passed by ioscheduler */
100 __REQ_HARDBARRIER, /* may not be passed by drive either */
101 __REQ_FUA, /* forced unit access */
102 __REQ_NOMERGE, /* don't touch this for merging */
103 __REQ_STARTED, /* drive already may have started this one */
104 __REQ_DONTPREP, /* don't call prep for this one */
105 __REQ_QUEUED, /* uses queueing */
106 __REQ_ELVPRIV, /* elevator private data attached */
107 __REQ_FAILED, /* set if the request failed */
108 __REQ_QUIET, /* don't worry about errors */
109 __REQ_PREEMPT, /* set for "ide_preempt" requests */
110 __REQ_ORDERED_COLOR, /* is before or after barrier */
111 __REQ_RW_SYNC, /* request is sync (O_DIRECT) */
Jens Axboe49171e52006-08-10 08:59:11 +0200112 __REQ_ALLOCED, /* request came from our alloc pool */
Jens Axboe5404bc72006-08-10 09:01:02 +0200113 __REQ_RW_META, /* metadata io request */
FUJITA Tomonorif18573a2008-04-11 12:56:52 +0200114 __REQ_COPY_USER, /* contains copies of user pages */
Jens Axboe4aff5e22006-08-10 08:44:47 +0200115 __REQ_NR_BITS, /* stops here */
116};
117
118#define REQ_RW (1 << __REQ_RW)
119#define REQ_FAILFAST (1 << __REQ_FAILFAST)
120#define REQ_SORTED (1 << __REQ_SORTED)
121#define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER)
122#define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER)
123#define REQ_FUA (1 << __REQ_FUA)
124#define REQ_NOMERGE (1 << __REQ_NOMERGE)
125#define REQ_STARTED (1 << __REQ_STARTED)
126#define REQ_DONTPREP (1 << __REQ_DONTPREP)
127#define REQ_QUEUED (1 << __REQ_QUEUED)
128#define REQ_ELVPRIV (1 << __REQ_ELVPRIV)
129#define REQ_FAILED (1 << __REQ_FAILED)
130#define REQ_QUIET (1 << __REQ_QUIET)
131#define REQ_PREEMPT (1 << __REQ_PREEMPT)
132#define REQ_ORDERED_COLOR (1 << __REQ_ORDERED_COLOR)
133#define REQ_RW_SYNC (1 << __REQ_RW_SYNC)
Jens Axboe49171e52006-08-10 08:59:11 +0200134#define REQ_ALLOCED (1 << __REQ_ALLOCED)
Jens Axboe5404bc72006-08-10 09:01:02 +0200135#define REQ_RW_META (1 << __REQ_RW_META)
FUJITA Tomonorif18573a2008-04-11 12:56:52 +0200136#define REQ_COPY_USER (1 << __REQ_COPY_USER)
Jens Axboe4aff5e22006-08-10 08:44:47 +0200137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138#define BLK_MAX_CDB 16
139
140/*
Jens Axboe63a71382008-02-08 12:41:03 +0100141 * try to put the fields that are referenced together in the same cacheline.
142 * if you modify this structure, be sure to check block/blk-core.c:rq_init()
143 * as well!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 */
145struct request {
Jens Axboeff856ba2006-01-09 16:02:34 +0100146 struct list_head queuelist;
147 struct list_head donelist;
148
Jens Axboe165125e2007-07-24 09:28:11 +0200149 struct request_queue *q;
Jens Axboee6a1c872006-08-10 09:00:21 +0200150
Jens Axboe4aff5e22006-08-10 08:44:47 +0200151 unsigned int cmd_flags;
152 enum rq_cmd_type_bits cmd_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 /* Maintain bio traversal state for part by part I/O submission.
155 * hard_* are block layer internals, no driver should touch them!
156 */
157
158 sector_t sector; /* next sector to submit */
Jens Axboee6a1c872006-08-10 09:00:21 +0200159 sector_t hard_sector; /* next sector to complete */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 unsigned long nr_sectors; /* no. of sectors left to submit */
Jens Axboee6a1c872006-08-10 09:00:21 +0200161 unsigned long hard_nr_sectors; /* no. of sectors left to complete */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 /* no. of sectors left to submit in the current segment */
163 unsigned int current_nr_sectors;
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 /* no. of sectors left to complete in the current segment */
166 unsigned int hard_cur_sectors;
167
168 struct bio *bio;
169 struct bio *biotail;
170
Jens Axboe98170642006-07-28 09:23:08 +0200171 struct hlist_node hash; /* merge hash */
Jens Axboee6a1c872006-08-10 09:00:21 +0200172 /*
173 * The rb_node is only used inside the io scheduler, requests
174 * are pruned when moved to the dispatch queue. So let the
175 * completion_data share space with the rb_node.
176 */
177 union {
178 struct rb_node rb_node; /* sort/lookup */
179 void *completion_data;
180 };
Jens Axboe98170642006-07-28 09:23:08 +0200181
Jens Axboeff7d1452006-07-12 14:04:37 +0200182 /*
183 * two pointers are available for the IO schedulers, if they need
184 * more they have to dynamically allocate it.
185 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 void *elevator_private;
Jens Axboeff7d1452006-07-12 14:04:37 +0200187 void *elevator_private2;
188
Jens Axboe8f34ee72006-06-13 09:02:34 +0200189 struct gendisk *rq_disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 unsigned long start_time;
191
192 /* Number of scatter-gather DMA addr+len pairs after
193 * physical address coalescing is performed.
194 */
195 unsigned short nr_phys_segments;
196
197 /* Number of scatter-gather addr+len pairs after
198 * physical and DMA remapping hardware coalescing is performed.
199 * This is the number of scatter-gather entries the driver
200 * will actually have to deal with after DMA mapping is done.
201 */
202 unsigned short nr_hw_segments;
203
Jens Axboe8f34ee72006-06-13 09:02:34 +0200204 unsigned short ioprio;
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 void *special;
Jens Axboe8f34ee72006-06-13 09:02:34 +0200207 char *buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Jens Axboecdd60262006-07-28 09:32:07 +0200209 int tag;
210 int errors;
211
212 int ref_count;
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 /*
215 * when request is used as a packet command carrier
216 */
FUJITA Tomonorid7e3c322008-04-29 09:54:39 +0200217 unsigned short cmd_len;
218 unsigned char __cmd[BLK_MAX_CDB];
219 unsigned char *cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221 unsigned int data_len;
FUJITA Tomonori7a85f882008-03-04 11:17:11 +0100222 unsigned int extra_len; /* length of alignment and padding */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 unsigned int sense_len;
Jens Axboe8f34ee72006-06-13 09:02:34 +0200224 void *data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 void *sense;
226
227 unsigned int timeout;
Mike Christie17e01f22005-11-11 05:31:37 -0600228 int retries;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
230 /*
Jens Axboec00895a2006-09-30 20:29:12 +0200231 * completion callback.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 */
233 rq_end_io_fn *end_io;
234 void *end_io_data;
FUJITA Tomonoriabae1fd2007-07-16 08:52:14 +0200235
236 /* for bidi */
237 struct request *next_rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238};
239
240/*
Jens Axboe4aff5e22006-08-10 08:44:47 +0200241 * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 * requests. Some step values could eventually be made generic.
243 */
244struct request_pm_state
245{
246 /* PM state machine step value, currently driver specific */
247 int pm_step;
248 /* requested PM state value (S1, S2, S3, S4, ...) */
249 u32 pm_state;
250 void* data; /* for driver use */
251};
252
253#include <linux/elevator.h>
254
Jens Axboe165125e2007-07-24 09:28:11 +0200255typedef void (request_fn_proc) (struct request_queue *q);
256typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
257typedef int (prep_rq_fn) (struct request_queue *, struct request *);
258typedef void (unplug_fn) (struct request_queue *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260struct bio_vec;
Jens Axboe165125e2007-07-24 09:28:11 +0200261typedef int (merge_bvec_fn) (struct request_queue *, struct bio *, struct bio_vec *);
Jens Axboe165125e2007-07-24 09:28:11 +0200262typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
Jens Axboeff856ba2006-01-09 16:02:34 +0100263typedef void (softirq_done_fn)(struct request *);
Tejun Heo2fb98e82008-02-19 11:36:53 +0100264typedef int (dma_drain_needed_fn)(struct request *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266enum blk_queue_state {
267 Queue_down,
268 Queue_up,
269};
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271struct blk_queue_tag {
272 struct request **tag_index; /* map of busy tags */
273 unsigned long *tag_map; /* bit map of free/busy tags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 int busy; /* current depth */
275 int max_depth; /* what we will send to device */
Tejun Heoba025082005-08-05 13:28:11 -0700276 int real_max_depth; /* what the array can hold */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 atomic_t refcnt; /* map can be shared */
278};
279
280struct request_queue
281{
282 /*
283 * Together with queue_head for cacheline sharing
284 */
285 struct list_head queue_head;
286 struct request *last_merge;
287 elevator_t *elevator;
288
289 /*
290 * the queue request freelist, one for reads and one for writes
291 */
292 struct request_list rq;
293
294 request_fn_proc *request_fn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 make_request_fn *make_request_fn;
296 prep_rq_fn *prep_rq_fn;
297 unplug_fn *unplug_fn;
298 merge_bvec_fn *merge_bvec_fn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 prepare_flush_fn *prepare_flush_fn;
Jens Axboeff856ba2006-01-09 16:02:34 +0100300 softirq_done_fn *softirq_done_fn;
Tejun Heo2fb98e82008-02-19 11:36:53 +0100301 dma_drain_needed_fn *dma_drain_needed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303 /*
Tejun Heo8922e162005-10-20 16:23:44 +0200304 * Dispatch queue sorting
305 */
Jens Axboe1b47f532005-10-20 16:37:00 +0200306 sector_t end_sector;
Tejun Heo8922e162005-10-20 16:23:44 +0200307 struct request *boundary_rq;
Tejun Heo8922e162005-10-20 16:23:44 +0200308
309 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 * Auto-unplugging state
311 */
312 struct timer_list unplug_timer;
313 int unplug_thresh; /* After this many requests */
314 unsigned long unplug_delay; /* After this many jiffies */
315 struct work_struct unplug_work;
316
317 struct backing_dev_info backing_dev_info;
318
319 /*
320 * The queue owner gets to use this for whatever they like.
321 * ll_rw_blk doesn't touch it.
322 */
323 void *queuedata;
324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 /*
326 * queue needs bounce pages for pages above this limit
327 */
328 unsigned long bounce_pfn;
Al Viro8267e262005-10-21 03:20:53 -0400329 gfp_t bounce_gfp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
331 /*
332 * various queue flags, see QUEUE_* below
333 */
334 unsigned long queue_flags;
335
336 /*
152587d2005-04-12 16:22:06 -0500337 * protects queue structures from reentrancy. ->__queue_lock should
338 * _never_ be used directly, it is queue private. always use
339 * ->queue_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 */
152587d2005-04-12 16:22:06 -0500341 spinlock_t __queue_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 spinlock_t *queue_lock;
343
344 /*
345 * queue kobject
346 */
347 struct kobject kobj;
348
349 /*
350 * queue settings
351 */
352 unsigned long nr_requests; /* Max # of requests */
353 unsigned int nr_congestion_on;
354 unsigned int nr_congestion_off;
355 unsigned int nr_batching;
356
Jens Axboe2cb2e142006-01-17 09:04:32 +0100357 unsigned int max_sectors;
358 unsigned int max_hw_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 unsigned short max_phys_segments;
360 unsigned short max_hw_segments;
361 unsigned short hardsect_size;
362 unsigned int max_segment_size;
363
364 unsigned long seg_boundary_mask;
James Bottomleyfa0ccd82008-01-10 11:30:36 -0600365 void *dma_drain_buffer;
366 unsigned int dma_drain_size;
Tejun Heoe3790c72008-03-04 11:18:17 +0100367 unsigned int dma_pad_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 unsigned int dma_alignment;
369
370 struct blk_queue_tag *queue_tags;
Jens Axboe6eca9002007-10-25 10:14:47 +0200371 struct list_head tag_busy_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Tejun Heo15853af2005-11-10 08:52:05 +0100373 unsigned int nr_sorted;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 unsigned int in_flight;
375
376 /*
377 * sg stuff
378 */
379 unsigned int sg_timeout;
380 unsigned int sg_reserved_size;
Christoph Lameter19460892005-06-23 00:08:19 -0700381 int node;
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -0700382#ifdef CONFIG_BLK_DEV_IO_TRACE
Jens Axboe2056a782006-03-23 20:00:26 +0100383 struct blk_trace *blk_trace;
Alexey Dobriyan6c5c9342006-09-29 01:59:40 -0700384#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 /*
386 * reserved for flush operations
387 */
Tejun Heo797e7db2006-01-06 09:51:03 +0100388 unsigned int ordered, next_ordered, ordseq;
389 int orderr, ordcolor;
390 struct request pre_flush_rq, bar_rq, post_flush_rq;
391 struct request *orig_bar_rq;
Al Viro483f4af2006-03-18 18:34:37 -0500392
393 struct mutex sysfs_lock;
FUJITA Tomonorid351af02007-07-09 12:40:35 +0200394
395#if defined(CONFIG_BLK_DEV_BSG)
396 struct bsg_class_device bsg_dev;
397#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398};
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400#define QUEUE_FLAG_CLUSTER 0 /* cluster several segments into 1 */
401#define QUEUE_FLAG_QUEUED 1 /* uses generic tag queueing */
402#define QUEUE_FLAG_STOPPED 2 /* queue is stopped */
Qi Yong4e971822007-07-25 08:45:51 +0200403#define QUEUE_FLAG_READFULL 3 /* read queue has been filled */
404#define QUEUE_FLAG_WRITEFULL 4 /* write queue has been filled */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405#define QUEUE_FLAG_DEAD 5 /* queue being torn down */
406#define QUEUE_FLAG_REENTER 6 /* Re-entrancy avoidance */
407#define QUEUE_FLAG_PLUGGED 7 /* queue is plugged */
Jens Axboe64521d12005-10-28 08:30:39 +0200408#define QUEUE_FLAG_ELVSWITCH 8 /* don't use elevator, just do FIFO */
FUJITA Tomonoriabae1fd2007-07-16 08:52:14 +0200409#define QUEUE_FLAG_BIDI 9 /* queue supports bidi requests */
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200410#define QUEUE_FLAG_NOMERGES 10 /* disable merge attempts */
Tejun Heo797e7db2006-01-06 09:51:03 +0100411
Linus Torvalds8f45c1a2008-04-29 10:16:38 -0700412static inline int queue_is_locked(struct request_queue *q)
413{
Jens Axboe7663c1e2008-04-29 21:31:27 +0200414#ifdef CONFIG_SMP
Linus Torvalds8f45c1a2008-04-29 10:16:38 -0700415 spinlock_t *lock = q->queue_lock;
416 return lock && spin_is_locked(lock);
Jens Axboe7663c1e2008-04-29 21:31:27 +0200417#else
418 return 1;
419#endif
Linus Torvalds8f45c1a2008-04-29 10:16:38 -0700420}
421
Nick Piggin75ad23b2008-04-29 14:48:33 +0200422static inline void queue_flag_set_unlocked(unsigned int flag,
423 struct request_queue *q)
424{
425 __set_bit(flag, &q->queue_flags);
426}
427
428static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
429{
Linus Torvalds8f45c1a2008-04-29 10:16:38 -0700430 WARN_ON_ONCE(!queue_is_locked(q));
Nick Piggin75ad23b2008-04-29 14:48:33 +0200431 __set_bit(flag, &q->queue_flags);
432}
433
434static inline void queue_flag_clear_unlocked(unsigned int flag,
435 struct request_queue *q)
436{
437 __clear_bit(flag, &q->queue_flags);
438}
439
440static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
441{
Linus Torvalds8f45c1a2008-04-29 10:16:38 -0700442 WARN_ON_ONCE(!queue_is_locked(q));
Nick Piggin75ad23b2008-04-29 14:48:33 +0200443 __clear_bit(flag, &q->queue_flags);
444}
445
Tejun Heo797e7db2006-01-06 09:51:03 +0100446enum {
447 /*
448 * Hardbarrier is supported with one of the following methods.
449 *
450 * NONE : hardbarrier unsupported
451 * DRAIN : ordering by draining is enough
452 * DRAIN_FLUSH : ordering by draining w/ pre and post flushes
453 * DRAIN_FUA : ordering by draining w/ pre flush and FUA write
454 * TAG : ordering by tag is enough
455 * TAG_FLUSH : ordering by tag w/ pre and post flushes
456 * TAG_FUA : ordering by tag w/ pre flush and FUA write
457 */
458 QUEUE_ORDERED_NONE = 0x00,
459 QUEUE_ORDERED_DRAIN = 0x01,
460 QUEUE_ORDERED_TAG = 0x02,
461
462 QUEUE_ORDERED_PREFLUSH = 0x10,
463 QUEUE_ORDERED_POSTFLUSH = 0x20,
464 QUEUE_ORDERED_FUA = 0x40,
465
466 QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN |
467 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
468 QUEUE_ORDERED_DRAIN_FUA = QUEUE_ORDERED_DRAIN |
469 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
470 QUEUE_ORDERED_TAG_FLUSH = QUEUE_ORDERED_TAG |
471 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
472 QUEUE_ORDERED_TAG_FUA = QUEUE_ORDERED_TAG |
473 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
474
475 /*
476 * Ordered operation sequence
477 */
478 QUEUE_ORDSEQ_STARTED = 0x01, /* flushing in progress */
479 QUEUE_ORDSEQ_DRAIN = 0x02, /* waiting for the queue to be drained */
480 QUEUE_ORDSEQ_PREFLUSH = 0x04, /* pre-flushing in progress */
481 QUEUE_ORDSEQ_BAR = 0x08, /* original barrier req in progress */
482 QUEUE_ORDSEQ_POSTFLUSH = 0x10, /* post-flushing in progress */
483 QUEUE_ORDSEQ_DONE = 0x20,
484};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486#define blk_queue_plugged(q) test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
487#define blk_queue_tagged(q) test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
488#define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
Alan D. Brunelleac9fafa2008-04-29 14:44:19 +0200489#define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
Tejun Heo797e7db2006-01-06 09:51:03 +0100490#define blk_queue_flushing(q) ((q)->ordseq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Jens Axboe4aff5e22006-08-10 08:44:47 +0200492#define blk_fs_request(rq) ((rq)->cmd_type == REQ_TYPE_FS)
493#define blk_pc_request(rq) ((rq)->cmd_type == REQ_TYPE_BLOCK_PC)
494#define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL)
495#define blk_sense_request(rq) ((rq)->cmd_type == REQ_TYPE_SENSE)
496
497#define blk_noretry_request(rq) ((rq)->cmd_flags & REQ_FAILFAST)
498#define blk_rq_started(rq) ((rq)->cmd_flags & REQ_STARTED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
500#define blk_account_rq(rq) (blk_rq_started(rq) && blk_fs_request(rq))
501
Jens Axboe4aff5e22006-08-10 08:44:47 +0200502#define blk_pm_suspend_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND)
503#define blk_pm_resume_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_RESUME)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504#define blk_pm_request(rq) \
Jens Axboe4aff5e22006-08-10 08:44:47 +0200505 (blk_pm_suspend_request(rq) || blk_pm_resume_request(rq))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Jens Axboe4aff5e22006-08-10 08:44:47 +0200507#define blk_sorted_rq(rq) ((rq)->cmd_flags & REQ_SORTED)
508#define blk_barrier_rq(rq) ((rq)->cmd_flags & REQ_HARDBARRIER)
509#define blk_fua_rq(rq) ((rq)->cmd_flags & REQ_FUA)
FUJITA Tomonoriabae1fd2007-07-16 08:52:14 +0200510#define blk_bidi_rq(rq) ((rq)->next_rq != NULL)
Jens Axboebf2de6f2007-09-27 13:01:25 +0200511#define blk_empty_barrier(rq) (blk_barrier_rq(rq) && blk_fs_request(rq) && !(rq)->hard_nr_sectors)
Kiyoshi Ueda336cdb42007-12-11 17:40:30 -0500512/* rq->queuelist of dequeued request must be list_empty() */
513#define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515#define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist)
516
Jens Axboe4aff5e22006-08-10 08:44:47 +0200517#define rq_data_dir(rq) ((rq)->cmd_flags & 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Jens Axboe9e2585a2006-07-28 09:26:13 +0200519/*
520 * We regard a request as sync, if it's a READ or a SYNC write.
521 */
522#define rq_is_sync(rq) (rq_data_dir((rq)) == READ || (rq)->cmd_flags & REQ_RW_SYNC)
Jens Axboe5404bc72006-08-10 09:01:02 +0200523#define rq_is_meta(rq) ((rq)->cmd_flags & REQ_RW_META)
Jens Axboe9e2585a2006-07-28 09:26:13 +0200524
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525static inline int blk_queue_full(struct request_queue *q, int rw)
526{
527 if (rw == READ)
528 return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
529 return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
530}
531
532static inline void blk_set_queue_full(struct request_queue *q, int rw)
533{
534 if (rw == READ)
Nick Piggin75ad23b2008-04-29 14:48:33 +0200535 queue_flag_set(QUEUE_FLAG_READFULL, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 else
Nick Piggin75ad23b2008-04-29 14:48:33 +0200537 queue_flag_set(QUEUE_FLAG_WRITEFULL, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538}
539
540static inline void blk_clear_queue_full(struct request_queue *q, int rw)
541{
542 if (rw == READ)
Nick Piggin75ad23b2008-04-29 14:48:33 +0200543 queue_flag_clear(QUEUE_FLAG_READFULL, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 else
Nick Piggin75ad23b2008-04-29 14:48:33 +0200545 queue_flag_clear(QUEUE_FLAG_WRITEFULL, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546}
547
548
549/*
550 * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may
551 * it already be started by driver.
552 */
553#define RQ_NOMERGE_FLAGS \
554 (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
555#define rq_mergeable(rq) \
Jens Axboe4aff5e22006-08-10 08:44:47 +0200556 (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
558/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 * q->prep_rq_fn return values
560 */
561#define BLKPREP_OK 0 /* serve it */
562#define BLKPREP_KILL 1 /* fatal error, kill */
563#define BLKPREP_DEFER 2 /* leave on queue */
564
565extern unsigned long blk_max_low_pfn, blk_max_pfn;
566
567/*
568 * standard bounce addresses:
569 *
570 * BLK_BOUNCE_HIGH : bounce all highmem pages
571 * BLK_BOUNCE_ANY : don't bounce anything
572 * BLK_BOUNCE_ISA : bounce pages above ISA DMA boundary
573 */
Andi Kleen24728922008-04-21 09:51:05 +0200574
575#if BITS_PER_LONG == 32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576#define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT)
Andi Kleen24728922008-04-21 09:51:05 +0200577#else
578#define BLK_BOUNCE_HIGH -1ULL
579#endif
580#define BLK_BOUNCE_ANY (-1ULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581#define BLK_BOUNCE_ISA (ISA_DMA_THRESHOLD)
582
Jens Axboe3d6392c2007-07-09 12:38:05 +0200583/*
584 * default timeout for SG_IO if none specified
585 */
586#define BLK_DEFAULT_SG_TIMEOUT (60 * HZ)
587
Christoph Lameter2a7326b2007-07-17 04:03:37 -0700588#ifdef CONFIG_BOUNCE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589extern int init_emergency_isa_pool(void);
Jens Axboe165125e2007-07-24 09:28:11 +0200590extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591#else
592static inline int init_emergency_isa_pool(void)
593{
594 return 0;
595}
Jens Axboe165125e2007-07-24 09:28:11 +0200596static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598}
599#endif /* CONFIG_MMU */
600
NeilBrown5705f702007-09-25 12:35:59 +0200601struct req_iterator {
602 int i;
603 struct bio *bio;
604};
605
606/* This should not be used directly - use rq_for_each_segment */
607#define __rq_for_each_bio(_bio, rq) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 if ((rq->bio)) \
609 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
610
NeilBrown5705f702007-09-25 12:35:59 +0200611#define rq_for_each_segment(bvl, _rq, _iter) \
612 __rq_for_each_bio(_iter.bio, _rq) \
613 bio_for_each_segment(bvl, _iter.bio, _iter.i)
614
615#define rq_iter_last(rq, _iter) \
616 (_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1)
617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618extern int blk_register_queue(struct gendisk *disk);
619extern void blk_unregister_queue(struct gendisk *disk);
620extern void register_disk(struct gendisk *dev);
621extern void generic_make_request(struct bio *bio);
FUJITA Tomonori2a4aa302008-04-29 09:54:36 +0200622extern void blk_rq_init(struct request_queue *q, struct request *rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623extern void blk_put_request(struct request *);
Jens Axboe165125e2007-07-24 09:28:11 +0200624extern void __blk_put_request(struct request_queue *, struct request *);
Tejun Heo8ffdc652006-01-06 09:49:03 +0100625extern void blk_end_sync_rq(struct request *rq, int error);
Jens Axboe165125e2007-07-24 09:28:11 +0200626extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
627extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
628extern void blk_requeue_request(struct request_queue *, struct request *);
629extern void blk_plug_device(struct request_queue *);
630extern int blk_remove_plug(struct request_queue *);
631extern void blk_recount_segments(struct request_queue *, struct bio *);
FUJITA Tomonori45e79a32007-07-09 12:39:20 +0200632extern int scsi_cmd_ioctl(struct file *, struct request_queue *,
633 struct gendisk *, unsigned int, void __user *);
Christoph Hellwig21b2f0c2006-03-22 17:52:04 +0100634extern int sg_scsi_ioctl(struct file *, struct request_queue *,
635 struct gendisk *, struct scsi_ioctl_command __user *);
Andrew Morton3fcfab12006-10-19 23:28:16 -0700636
637/*
Jens Axboe1aa4f242006-12-19 08:33:11 +0100638 * Temporary export, until SCSI gets fixed up.
639 */
NeilBrown3001ca72007-08-16 13:31:27 +0200640extern int blk_rq_append_bio(struct request_queue *q, struct request *rq,
641 struct bio *bio);
Jens Axboe1aa4f242006-12-19 08:33:11 +0100642
643/*
Andrew Morton3fcfab12006-10-19 23:28:16 -0700644 * A queue has just exitted congestion. Note this in the global counter of
645 * congested queues, and wake up anyone who was waiting for requests to be
646 * put back.
647 */
Jens Axboe165125e2007-07-24 09:28:11 +0200648static inline void blk_clear_queue_congested(struct request_queue *q, int rw)
Andrew Morton3fcfab12006-10-19 23:28:16 -0700649{
650 clear_bdi_congested(&q->backing_dev_info, rw);
651}
652
653/*
654 * A queue has just entered congestion. Flag that in the queue's VM-visible
655 * state flags and increment the global gounter of congested queues.
656 */
Jens Axboe165125e2007-07-24 09:28:11 +0200657static inline void blk_set_queue_congested(struct request_queue *q, int rw)
Andrew Morton3fcfab12006-10-19 23:28:16 -0700658{
659 set_bdi_congested(&q->backing_dev_info, rw);
660}
661
Jens Axboe165125e2007-07-24 09:28:11 +0200662extern void blk_start_queue(struct request_queue *q);
663extern void blk_stop_queue(struct request_queue *q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664extern void blk_sync_queue(struct request_queue *q);
Jens Axboe165125e2007-07-24 09:28:11 +0200665extern void __blk_stop_queue(struct request_queue *q);
Nick Piggin75ad23b2008-04-29 14:48:33 +0200666extern void __blk_run_queue(struct request_queue *);
Jens Axboe165125e2007-07-24 09:28:11 +0200667extern void blk_run_queue(struct request_queue *);
668extern void blk_start_queueing(struct request_queue *);
669extern int blk_rq_map_user(struct request_queue *, struct request *, void __user *, unsigned long);
Jens Axboe8e5cfc42006-12-19 11:12:46 +0100670extern int blk_rq_unmap_user(struct bio *);
Jens Axboe165125e2007-07-24 09:28:11 +0200671extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
672extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
Mike Christie0e75f902006-12-01 10:40:55 +0100673 struct sg_iovec *, int, unsigned int);
Jens Axboe165125e2007-07-24 09:28:11 +0200674extern int blk_execute_rq(struct request_queue *, struct gendisk *,
James Bottomley 994ca9a2005-06-20 14:11:09 +0200675 struct request *, int);
Jens Axboe165125e2007-07-24 09:28:11 +0200676extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
Jens Axboe15fc8582006-01-06 10:00:50 +0100677 struct request *, int, rq_end_io_fn *);
FUJITA Tomonori337ad41d2006-12-20 11:18:54 +0100678extern int blk_verify_command(unsigned char *, int);
Alan D. Brunelle2ad8b1e2007-11-07 14:26:56 -0500679extern void blk_unplug(struct request_queue *q);
Mike Christie6e39b692005-11-11 05:30:24 -0600680
Jens Axboe165125e2007-07-24 09:28:11 +0200681static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682{
683 return bdev->bd_disk->queue;
684}
685
686static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
687 struct page *page)
688{
689 if (bdi && bdi->unplug_io_fn)
690 bdi->unplug_io_fn(bdi, page);
691}
692
693static inline void blk_run_address_space(struct address_space *mapping)
694{
695 if (mapping)
696 blk_run_backing_dev(mapping->backing_dev_info, NULL);
697}
698
699/*
Kiyoshi Ueda3bcddea2007-12-11 17:52:28 -0500700 * blk_end_request() and friends.
701 * __blk_end_request() and end_request() must be called with
702 * the request queue spinlock acquired.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 *
704 * Several drivers define their own end_request and call
Kiyoshi Ueda3bcddea2007-12-11 17:52:28 -0500705 * blk_end_request() for parts of the original function.
706 * This prevents code duplication in drivers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 */
Jens Axboe22b13212008-01-31 12:36:19 +0100708extern int blk_end_request(struct request *rq, int error,
709 unsigned int nr_bytes);
710extern int __blk_end_request(struct request *rq, int error,
711 unsigned int nr_bytes);
712extern int blk_end_bidi_request(struct request *rq, int error,
713 unsigned int nr_bytes, unsigned int bidi_bytes);
Jens Axboea0cd1282007-09-21 10:41:07 +0200714extern void end_request(struct request *, int);
715extern void end_queued_request(struct request *, int);
716extern void end_dequeued_request(struct request *, int);
Jens Axboe22b13212008-01-31 12:36:19 +0100717extern int blk_end_request_callback(struct request *rq, int error,
718 unsigned int nr_bytes,
719 int (drv_callback)(struct request *));
Jens Axboeff856ba2006-01-09 16:02:34 +0100720extern void blk_complete_request(struct request *);
721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722/*
Kiyoshi Ueda3b113132007-12-11 17:41:17 -0500723 * blk_end_request() takes bytes instead of sectors as a complete size.
724 * blk_rq_bytes() returns bytes left to complete in the entire request.
725 * blk_rq_cur_bytes() returns bytes left to complete in the current segment.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 */
Kiyoshi Ueda3b113132007-12-11 17:41:17 -0500727extern unsigned int blk_rq_bytes(struct request *rq);
728extern unsigned int blk_rq_cur_bytes(struct request *rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730static inline void blkdev_dequeue_request(struct request *req)
731{
Tejun Heo8922e162005-10-20 16:23:44 +0200732 elv_dequeue_request(req->q, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735/*
736 * Access functions for manipulating queue properties
737 */
Jens Axboe165125e2007-07-24 09:28:11 +0200738extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
Christoph Lameter19460892005-06-23 00:08:19 -0700739 spinlock_t *lock, int node_id);
Jens Axboe165125e2007-07-24 09:28:11 +0200740extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
741extern void blk_cleanup_queue(struct request_queue *);
742extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
743extern void blk_queue_bounce_limit(struct request_queue *, u64);
744extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
745extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
746extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
747extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
748extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
749extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
Tejun Heoe3790c72008-03-04 11:18:17 +0100750extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
Tejun Heo2fb98e82008-02-19 11:36:53 +0100751extern int blk_queue_dma_drain(struct request_queue *q,
752 dma_drain_needed_fn *dma_drain_needed,
753 void *buf, unsigned int size);
Jens Axboe165125e2007-07-24 09:28:11 +0200754extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
755extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
756extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
757extern void blk_queue_dma_alignment(struct request_queue *, int);
James Bottomley11c3e682007-12-31 16:37:00 -0600758extern void blk_queue_update_dma_alignment(struct request_queue *, int);
Jens Axboe165125e2007-07-24 09:28:11 +0200759extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
Jens Axboe165125e2007-07-24 09:28:11 +0200761extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
Jens Axboe165125e2007-07-24 09:28:11 +0200762extern int blk_do_ordered(struct request_queue *, struct request **);
763extern unsigned blk_ordered_cur_seq(struct request_queue *);
Tejun Heo797e7db2006-01-06 09:51:03 +0100764extern unsigned blk_ordered_req_seq(struct request *);
Jens Axboe165125e2007-07-24 09:28:11 +0200765extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Jens Axboe165125e2007-07-24 09:28:11 +0200767extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768extern void blk_dump_rq_flags(struct request *, char *);
Jens Axboe165125e2007-07-24 09:28:11 +0200769extern void generic_unplug_device(struct request_queue *);
770extern void __generic_unplug_device(struct request_queue *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771extern long nr_blockdev_pages(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Jens Axboe165125e2007-07-24 09:28:11 +0200773int blk_get_queue(struct request_queue *);
774struct request_queue *blk_alloc_queue(gfp_t);
775struct request_queue *blk_alloc_queue_node(gfp_t, int);
776extern void blk_put_queue(struct request_queue *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
778/*
779 * tag stuff
780 */
781#define blk_queue_tag_depth(q) ((q)->queue_tags->busy)
782#define blk_queue_tag_queue(q) ((q)->queue_tags->busy < (q)->queue_tags->max_depth)
Jens Axboe4aff5e22006-08-10 08:44:47 +0200783#define blk_rq_tagged(rq) ((rq)->cmd_flags & REQ_QUEUED)
Jens Axboe165125e2007-07-24 09:28:11 +0200784extern int blk_queue_start_tag(struct request_queue *, struct request *);
785extern struct request *blk_queue_find_tag(struct request_queue *, int);
786extern void blk_queue_end_tag(struct request_queue *, struct request *);
787extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
788extern void blk_queue_free_tags(struct request_queue *);
789extern int blk_queue_resize_tags(struct request_queue *, int);
790extern void blk_queue_invalidate_tags(struct request_queue *);
James Bottomley492dfb42006-08-30 15:48:45 -0400791extern struct blk_queue_tag *blk_init_tags(int);
792extern void blk_free_tags(struct blk_queue_tag *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
David C Somayajuluf583f492006-10-04 08:27:25 +0200794static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
795 int tag)
796{
797 if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
798 return NULL;
799 return bqt->tag_index[tag];
800}
801
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802extern int blkdev_issue_flush(struct block_device *, sector_t *);
803
804#define MAX_PHYS_SEGMENTS 128
805#define MAX_HW_SEGMENTS 128
Mike Christiedefd94b2005-12-05 02:37:06 -0600806#define SAFE_MAX_SECTORS 255
807#define BLK_DEF_MAX_SECTORS 1024
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
809#define MAX_SEGMENT_SIZE 65536
810
811#define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
812
Jens Axboe165125e2007-07-24 09:28:11 +0200813static inline int queue_hardsect_size(struct request_queue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814{
815 int retval = 512;
816
817 if (q && q->hardsect_size)
818 retval = q->hardsect_size;
819
820 return retval;
821}
822
823static inline int bdev_hardsect_size(struct block_device *bdev)
824{
825 return queue_hardsect_size(bdev_get_queue(bdev));
826}
827
Jens Axboe165125e2007-07-24 09:28:11 +0200828static inline int queue_dma_alignment(struct request_queue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829{
Pete Wyckoff482eb682008-01-01 10:23:02 -0500830 return q ? q->dma_alignment : 511;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831}
832
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833/* assumes size > 256 */
834static inline unsigned int blksize_bits(unsigned int size)
835{
836 unsigned int bits = 8;
837 do {
838 bits++;
839 size >>= 1;
840 } while (size > 256);
841 return bits;
842}
843
Adrian Bunk2befb9e2005-09-10 00:27:17 -0700844static inline unsigned int block_size(struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845{
846 return bdev->bd_block_size;
847}
848
849typedef struct {struct page *v;} Sector;
850
851unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
852
853static inline void put_dev_sector(Sector p)
854{
855 page_cache_release(p.v);
856}
857
858struct work_struct;
859int kblockd_schedule_work(struct work_struct *work);
Andrew Morton19a75d82007-05-09 02:33:56 -0700860void kblockd_flush_work(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862#define MODULE_ALIAS_BLOCKDEV(major,minor) \
863 MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
864#define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
865 MODULE_ALIAS("block-major-" __stringify(major) "-*")
866
867
David Howells93614012006-09-30 20:45:40 +0200868#else /* CONFIG_BLOCK */
869/*
870 * stubs for when the block layer is configured out
871 */
872#define buffer_heads_over_limit 0
873
David Howells93614012006-09-30 20:45:40 +0200874static inline long nr_blockdev_pages(void)
875{
876 return 0;
877}
878
Andrew Mortonbcfd8d32006-08-31 12:56:06 +0200879static inline void exit_io_context(void)
880{
881}
David Howells93614012006-09-30 20:45:40 +0200882
Jens Axboe023ccde2008-01-29 14:08:06 +0100883struct io_context;
Jens Axboefd0928d2008-01-24 08:52:45 +0100884static inline int put_io_context(struct io_context *ioc)
885{
886 return 1;
887}
888
889
David Howells93614012006-09-30 20:45:40 +0200890#endif /* CONFIG_BLOCK */
891
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892#endif