projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6-block.git] / include / linux / blkdev.h
CommitLineData
1da177e4
LT		 1#ifndef _LINUX_BLKDEV_H
2#define _LINUX_BLKDEV_H
3
4#include <linux/config.h>
5#include <linux/major.h>
6#include <linux/genhd.h>
7#include <linux/list.h>
8#include <linux/timer.h>
9#include <linux/workqueue.h>
10#include <linux/pagemap.h>
11#include <linux/backing-dev.h>
12#include <linux/wait.h>
13#include <linux/mempool.h>
14#include <linux/bio.h>
15#include <linux/module.h>
16#include <linux/stringify.h>
17
18#include <asm/scatterlist.h>
19
20struct request_queue;
21typedef struct request_queue request_queue_t;
22struct elevator_queue;
23typedef struct elevator_queue elevator_t;
24struct request_pm_state;
2056a782 25struct blk_trace;
1da177e4
LT		 26
27#define BLKDEV_MIN_RQ 4
28#define BLKDEV_MAX_RQ 128 /* Default maximum */
29
30/*
31 * This is the per-process anticipatory I/O scheduler state.
32 */
33struct as_io_context {
34 spinlock_t lock;
35
36 void (*dtor)(struct as_io_context *aic); /* destructor */
37 void (*exit)(struct as_io_context *aic); /* called on task exit */
38
39 unsigned long state;
40 atomic_t nr_queued; /* queued reads & sync writes */
41 atomic_t nr_dispatched; /* number of requests gone to the drivers */
42
43 /* IO History tracking */
44 /* Thinktime */
45 unsigned long last_end_request;
46 unsigned long ttime_total;
47 unsigned long ttime_samples;
48 unsigned long ttime_mean;
49 /* Layout pattern */
50 unsigned int seek_samples;
51 sector_t last_request_pos;
52 u64 seek_total;
53 sector_t seek_mean;
54};
55
56struct cfq_queue;
57struct cfq_io_context {
1da177e4
LT		 58 /*
59 * circular list of cfq_io_contexts belonging to a process io context
60 */
61 struct list_head list;
12a05732 62 struct cfq_queue *cfqq[2];
22e2c507
JA		 63 void *key;
64
65 struct io_context *ioc;
66
67 unsigned long last_end_request;
68 unsigned long last_queue;
69 unsigned long ttime_total;
70 unsigned long ttime_samples;
71 unsigned long ttime_mean;
72
d9ff4187
AV		 73 struct list_head queue_list;
74
22e2c507
JA		 75 void (*dtor)(struct cfq_io_context *);
76 void (*exit)(struct cfq_io_context *);
1da177e4
LT		 77};
78
79/*
80 * This is the per-process I/O subsystem state. It is refcounted and
81 * kmalloc'ed. Currently all fields are modified in process io context
82 * (apart from the atomic refcount), so require no locking.
83 */
84struct io_context {
85 atomic_t refcount;
22e2c507
JA		 86 struct task_struct *task;
87
88 int (*set_ioprio)(struct io_context *, unsigned int);
1da177e4
LT		 89
90 /*
91 * For request batching
92 */
93 unsigned long last_waited; /* Time last woken after wait for request */
94 int nr_batch_requests; /* Number of requests left in the batch */
95
1da177e4
LT		 96 struct as_io_context *aic;
97 struct cfq_io_context *cic;
98};
99
100void put_io_context(struct io_context *ioc);
101void exit_io_context(void);
8267e268
AV		 102struct io_context *current_io_context(gfp_t gfp_flags);
103struct io_context *get_io_context(gfp_t gfp_flags);
1da177e4
LT		 104void copy_io_context(struct io_context **pdst, struct io_context **psrc);
105void swap_io_context(struct io_context **ioc1, struct io_context **ioc2);
106
107struct request;
8ffdc655 108typedef void (rq_end_io_fn)(struct request *, int);
1da177e4
LT		 109
110struct request_list {
111 int count[2];
112 int starved[2];
cb98fc8b 113 int elvpriv;
1da177e4
LT		 114 mempool_t *rq_pool;
115 wait_queue_head_t wait[2];
1da177e4
LT		 116};
117
118#define BLK_MAX_CDB 16
119
120/*
121 * try to put the fields that are referenced together in the same cacheline
122 */
123struct request {
ff856bad
JA		 124 struct list_head queuelist;
125 struct list_head donelist;
126
1da177e4
LT		 127 unsigned long flags; /* see REQ_ bits below */
128
129 /* Maintain bio traversal state for part by part I/O submission.
130 * hard_* are block layer internals, no driver should touch them!
131 */
132
133 sector_t sector; /* next sector to submit */
134 unsigned long nr_sectors; /* no. of sectors left to submit */
135 /* no. of sectors left to submit in the current segment */
136 unsigned int current_nr_sectors;
137
138 sector_t hard_sector; /* next sector to complete */
139 unsigned long hard_nr_sectors; /* no. of sectors left to complete */
140 /* no. of sectors left to complete in the current segment */
141 unsigned int hard_cur_sectors;
142
143 struct bio *bio;
144 struct bio *biotail;
145
146 void *elevator_private;
ff856bad 147 void *completion_data;
1da177e4 148
22e2c507
JA		 149 unsigned short ioprio;
150
1da177e4
LT		 151 int rq_status; /* should split this into a few status bits */
152 struct gendisk *rq_disk;
153 int errors;
154 unsigned long start_time;
155
156 /* Number of scatter-gather DMA addr+len pairs after
157 * physical address coalescing is performed.
158 */
159 unsigned short nr_phys_segments;
160
161 /* Number of scatter-gather addr+len pairs after
162 * physical and DMA remapping hardware coalescing is performed.
163 * This is the number of scatter-gather entries the driver
164 * will actually have to deal with after DMA mapping is done.
165 */
166 unsigned short nr_hw_segments;
167
168 int tag;
169 char *buffer;
170
171 int ref_count;
172 request_queue_t *q;
173 struct request_list *rl;
174
175 struct completion *waiting;
176 void *special;
177
178 /*
179 * when request is used as a packet command carrier
180 */
181 unsigned int cmd_len;
182 unsigned char cmd[BLK_MAX_CDB];
183
184 unsigned int data_len;
185 void *data;
186
187 unsigned int sense_len;
188 void *sense;
189
190 unsigned int timeout;
17e01f21 191 int retries;
1da177e4
LT		 192
193 /*
194 * For Power Management requests
195 */
196 struct request_pm_state *pm;
197
198 /*
199 * completion callback. end_io_data should be folded in with waiting
200 */
201 rq_end_io_fn *end_io;
202 void *end_io_data;
203};
204
205/*
206 * first three bits match BIO_RW* bits, important
207 */
208enum rq_flag_bits {
209 __REQ_RW, /* not set, read. set, write */
210 __REQ_FAILFAST, /* no low level driver retries */
8922e16c 211 __REQ_SORTED, /* elevator knows about this request */
1da177e4
LT		 212 __REQ_SOFTBARRIER, /* may not be passed by ioscheduler */
213 __REQ_HARDBARRIER, /* may not be passed by drive either */
797e7dbb 214 __REQ_FUA, /* forced unit access */
1da177e4
LT		 215 __REQ_CMD, /* is a regular fs rw request */
216 __REQ_NOMERGE, /* don't touch this for merging */
217 __REQ_STARTED, /* drive already may have started this one */
218 __REQ_DONTPREP, /* don't call prep for this one */
219 __REQ_QUEUED, /* uses queueing */
cb98fc8b 220 __REQ_ELVPRIV, /* elevator private data attached */
1da177e4
LT		 221 /*
222 * for ATA/ATAPI devices
223 */
224 __REQ_PC, /* packet command (special) */
225 __REQ_BLOCK_PC, /* queued down pc from block layer */
226 __REQ_SENSE, /* sense retrival */
227
228 __REQ_FAILED, /* set if the request failed */
229 __REQ_QUIET, /* don't worry about errors */
230 __REQ_SPECIAL, /* driver suplied command */
231 __REQ_DRIVE_CMD,
232 __REQ_DRIVE_TASK,
233 __REQ_DRIVE_TASKFILE,
234 __REQ_PREEMPT, /* set for "ide_preempt" requests */
235 __REQ_PM_SUSPEND, /* suspend request */
236 __REQ_PM_RESUME, /* resume request */
237 __REQ_PM_SHUTDOWN, /* shutdown request */
797e7dbb 238 __REQ_ORDERED_COLOR, /* is before or after barrier */
1da177e4
LT		 239 __REQ_NR_BITS, /* stops here */
240};
241
242#define REQ_RW (1 << __REQ_RW)
243#define REQ_FAILFAST (1 << __REQ_FAILFAST)
8922e16c 244#define REQ_SORTED (1 << __REQ_SORTED)
1da177e4
LT		 245#define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER)
246#define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER)
797e7dbb 247#define REQ_FUA (1 << __REQ_FUA)
1da177e4
LT		 248#define REQ_CMD (1 << __REQ_CMD)
249#define REQ_NOMERGE (1 << __REQ_NOMERGE)
250#define REQ_STARTED (1 << __REQ_STARTED)
251#define REQ_DONTPREP (1 << __REQ_DONTPREP)
252#define REQ_QUEUED (1 << __REQ_QUEUED)
cb98fc8b 253#define REQ_ELVPRIV (1 << __REQ_ELVPRIV)
1da177e4
LT		 254#define REQ_PC (1 << __REQ_PC)
255#define REQ_BLOCK_PC (1 << __REQ_BLOCK_PC)
256#define REQ_SENSE (1 << __REQ_SENSE)
257#define REQ_FAILED (1 << __REQ_FAILED)
258#define REQ_QUIET (1 << __REQ_QUIET)
259#define REQ_SPECIAL (1 << __REQ_SPECIAL)
260#define REQ_DRIVE_CMD (1 << __REQ_DRIVE_CMD)
261#define REQ_DRIVE_TASK (1 << __REQ_DRIVE_TASK)
262#define REQ_DRIVE_TASKFILE (1 << __REQ_DRIVE_TASKFILE)
263#define REQ_PREEMPT (1 << __REQ_PREEMPT)
264#define REQ_PM_SUSPEND (1 << __REQ_PM_SUSPEND)
265#define REQ_PM_RESUME (1 << __REQ_PM_RESUME)
266#define REQ_PM_SHUTDOWN (1 << __REQ_PM_SHUTDOWN)
797e7dbb 267#define REQ_ORDERED_COLOR (1 << __REQ_ORDERED_COLOR)
1da177e4
LT		 268
269/*
270 * State information carried for REQ_PM_SUSPEND and REQ_PM_RESUME
271 * requests. Some step values could eventually be made generic.
272 */
273struct request_pm_state
274{
275 /* PM state machine step value, currently driver specific */
276 int pm_step;
277 /* requested PM state value (S1, S2, S3, S4, ...) */
278 u32 pm_state;
279 void* data; /* for driver use */
280};
281
282#include <linux/elevator.h>
283
284typedef int (merge_request_fn) (request_queue_t *, struct request *,
285 struct bio *);
286typedef int (merge_requests_fn) (request_queue_t *, struct request *,
287 struct request *);
288typedef void (request_fn_proc) (request_queue_t *q);
289typedef int (make_request_fn) (request_queue_t *q, struct bio *bio);
290typedef int (prep_rq_fn) (request_queue_t *, struct request *);
291typedef void (unplug_fn) (request_queue_t *);
292
293struct bio_vec;
294typedef int (merge_bvec_fn) (request_queue_t *, struct bio *, struct bio_vec *);
295typedef void (activity_fn) (void *data, int rw);
296typedef int (issue_flush_fn) (request_queue_t *, struct gendisk *, sector_t *);
797e7dbb 297typedef void (prepare_flush_fn) (request_queue_t *, struct request *);
ff856bad 298typedef void (softirq_done_fn)(struct request *);
1da177e4
LT		 299
300enum blk_queue_state {
301 Queue_down,
302 Queue_up,
303};
304
1da177e4
LT		 305struct blk_queue_tag {
306 struct request **tag_index; /* map of busy tags */
307 unsigned long *tag_map; /* bit map of free/busy tags */
308 struct list_head busy_list; /* fifo list of busy tags */
309 int busy; /* current depth */
310 int max_depth; /* what we will send to device */
ba025082 311 int real_max_depth; /* what the array can hold */
1da177e4
LT		 312 atomic_t refcnt; /* map can be shared */
313};
314
315struct request_queue
316{
317 /*
318 * Together with queue_head for cacheline sharing
319 */
320 struct list_head queue_head;
321 struct request *last_merge;
322 elevator_t *elevator;
323
324 /*
325 * the queue request freelist, one for reads and one for writes
326 */
327 struct request_list rq;
328
329 request_fn_proc *request_fn;
330 merge_request_fn *back_merge_fn;
331 merge_request_fn *front_merge_fn;
332 merge_requests_fn *merge_requests_fn;
333 make_request_fn *make_request_fn;
334 prep_rq_fn *prep_rq_fn;
335 unplug_fn *unplug_fn;
336 merge_bvec_fn *merge_bvec_fn;
337 activity_fn *activity_fn;
338 issue_flush_fn *issue_flush_fn;
339 prepare_flush_fn *prepare_flush_fn;
ff856bad 340 softirq_done_fn *softirq_done_fn;
1da177e4 341
8922e16c
TH		 342 /*
343 * Dispatch queue sorting
344 */
1b47f531 345 sector_t end_sector;
8922e16c 346 struct request *boundary_rq;
8922e16c 347
1da177e4
LT		 348 /*
349 * Auto-unplugging state
350 */
351 struct timer_list unplug_timer;
352 int unplug_thresh; /* After this many requests */
353 unsigned long unplug_delay; /* After this many jiffies */
354 struct work_struct unplug_work;
355
356 struct backing_dev_info backing_dev_info;
357
358 /*
359 * The queue owner gets to use this for whatever they like.
360 * ll_rw_blk doesn't touch it.
361 */
362 void *queuedata;
363
364 void *activity_data;
365
366 /*
367 * queue needs bounce pages for pages above this limit
368 */
369 unsigned long bounce_pfn;
8267e268 370 gfp_t bounce_gfp;
1da177e4
LT		 371
372 /*
373 * various queue flags, see QUEUE_* below
374 */
375 unsigned long queue_flags;
376
377 /*
152587de 378 * protects queue structures from reentrancy. ->__queue_lock should
379 * _never_ be used directly, it is queue private. always use
380 * ->queue_lock.
1da177e4 381 */
152587de 382 spinlock_t __queue_lock;
1da177e4
LT		 383 spinlock_t *queue_lock;
384
385 /*
386 * queue kobject
387 */
388 struct kobject kobj;
389
390 /*
391 * queue settings
392 */
393 unsigned long nr_requests; /* Max # of requests */
394 unsigned int nr_congestion_on;
395 unsigned int nr_congestion_off;
396 unsigned int nr_batching;
397
2cb2e147
JA		 398 unsigned int max_sectors;
399 unsigned int max_hw_sectors;
1da177e4
LT		 400 unsigned short max_phys_segments;
401 unsigned short max_hw_segments;
402 unsigned short hardsect_size;
403 unsigned int max_segment_size;
404
405 unsigned long seg_boundary_mask;
406 unsigned int dma_alignment;
407
408 struct blk_queue_tag *queue_tags;
409
15853af9 410 unsigned int nr_sorted;
1da177e4
LT		 411 unsigned int in_flight;
412
413 /*
414 * sg stuff
415 */
416 unsigned int sg_timeout;
417 unsigned int sg_reserved_size;
1946089a 418 int node;
1da177e4 419
2056a782
JA		 420 struct blk_trace *blk_trace;
421
1da177e4
LT		 422 /*
423 * reserved for flush operations
424 */
797e7dbb
TH		 425 unsigned int ordered, next_ordered, ordseq;
426 int orderr, ordcolor;
427 struct request pre_flush_rq, bar_rq, post_flush_rq;
428 struct request *orig_bar_rq;
429 unsigned int bi_size;
483f4afc
AV		 430
431 struct mutex sysfs_lock;
1da177e4
LT		 432};
433
434#define RQ_INACTIVE (-1)
435#define RQ_ACTIVE 1
436#define RQ_SCSI_BUSY 0xffff
437#define RQ_SCSI_DONE 0xfffe
438#define RQ_SCSI_DISCONNECTING 0xffe0
439
440#define QUEUE_FLAG_CLUSTER 0 /* cluster several segments into 1 */
441#define QUEUE_FLAG_QUEUED 1 /* uses generic tag queueing */
442#define QUEUE_FLAG_STOPPED 2 /* queue is stopped */
443#define QUEUE_FLAG_READFULL 3 /* write queue has been filled */
444#define QUEUE_FLAG_WRITEFULL 4 /* read queue has been filled */
445#define QUEUE_FLAG_DEAD 5 /* queue being torn down */
446#define QUEUE_FLAG_REENTER 6 /* Re-entrancy avoidance */
447#define QUEUE_FLAG_PLUGGED 7 /* queue is plugged */
64521d1a 448#define QUEUE_FLAG_ELVSWITCH 8 /* don't use elevator, just do FIFO */
797e7dbb
TH		 449
450enum {
451 /*
452 * Hardbarrier is supported with one of the following methods.
453 *
454 * NONE : hardbarrier unsupported
455 * DRAIN : ordering by draining is enough
456 * DRAIN_FLUSH : ordering by draining w/ pre and post flushes
457 * DRAIN_FUA : ordering by draining w/ pre flush and FUA write
458 * TAG : ordering by tag is enough
459 * TAG_FLUSH : ordering by tag w/ pre and post flushes
460 * TAG_FUA : ordering by tag w/ pre flush and FUA write
461 */
462 QUEUE_ORDERED_NONE = 0x00,
463 QUEUE_ORDERED_DRAIN = 0x01,
464 QUEUE_ORDERED_TAG = 0x02,
465
466 QUEUE_ORDERED_PREFLUSH = 0x10,
467 QUEUE_ORDERED_POSTFLUSH = 0x20,
468 QUEUE_ORDERED_FUA = 0x40,
469
470 QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN |
471 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
472 QUEUE_ORDERED_DRAIN_FUA = QUEUE_ORDERED_DRAIN |
473 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
474 QUEUE_ORDERED_TAG_FLUSH = QUEUE_ORDERED_TAG |
475 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
476 QUEUE_ORDERED_TAG_FUA = QUEUE_ORDERED_TAG |
477 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
478
479 /*
480 * Ordered operation sequence
481 */
482 QUEUE_ORDSEQ_STARTED = 0x01, /* flushing in progress */
483 QUEUE_ORDSEQ_DRAIN = 0x02, /* waiting for the queue to be drained */
484 QUEUE_ORDSEQ_PREFLUSH = 0x04, /* pre-flushing in progress */
485 QUEUE_ORDSEQ_BAR = 0x08, /* original barrier req in progress */
486 QUEUE_ORDSEQ_POSTFLUSH = 0x10, /* post-flushing in progress */
487 QUEUE_ORDSEQ_DONE = 0x20,
488};
1da177e4
LT		 489
490#define blk_queue_plugged(q) test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
491#define blk_queue_tagged(q) test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
492#define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
797e7dbb 493#define blk_queue_flushing(q) ((q)->ordseq)
1da177e4
LT		 494
495#define blk_fs_request(rq) ((rq)->flags & REQ_CMD)
496#define blk_pc_request(rq) ((rq)->flags & REQ_BLOCK_PC)
497#define blk_noretry_request(rq) ((rq)->flags & REQ_FAILFAST)
498#define blk_rq_started(rq) ((rq)->flags & REQ_STARTED)
499
500#define blk_account_rq(rq) (blk_rq_started(rq) && blk_fs_request(rq))
501
502#define blk_pm_suspend_request(rq) ((rq)->flags & REQ_PM_SUSPEND)
503#define blk_pm_resume_request(rq) ((rq)->flags & REQ_PM_RESUME)
504#define blk_pm_request(rq) \
505 ((rq)->flags & (REQ_PM_SUSPEND | REQ_PM_RESUME))
506
8922e16c 507#define blk_sorted_rq(rq) ((rq)->flags & REQ_SORTED)
1da177e4 508#define blk_barrier_rq(rq) ((rq)->flags & REQ_HARDBARRIER)
797e7dbb 509#define blk_fua_rq(rq) ((rq)->flags & REQ_FUA)
1da177e4
LT		 510
511#define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist)
512
513#define rq_data_dir(rq) ((rq)->flags & 1)
514
515static inline int blk_queue_full(struct request_queue *q, int rw)
516{
517 if (rw == READ)
518 return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
519 return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
520}
521
522static inline void blk_set_queue_full(struct request_queue *q, int rw)
523{
524 if (rw == READ)
525 set_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
526 else
527 set_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
528}
529
530static inline void blk_clear_queue_full(struct request_queue *q, int rw)
531{
532 if (rw == READ)
533 clear_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
534 else
535 clear_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
536}
537
538
539/*
540 * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may
541 * it already be started by driver.
542 */
543#define RQ_NOMERGE_FLAGS \
544 (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
545#define rq_mergeable(rq) \
546 (!((rq)->flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq)))
547
548/*
549 * noop, requests are automagically marked as active/inactive by I/O
550 * scheduler -- see elv_next_request
551 */
552#define blk_queue_headactive(q, head_active)
553
554/*
555 * q->prep_rq_fn return values
556 */
557#define BLKPREP_OK 0 /* serve it */
558#define BLKPREP_KILL 1 /* fatal error, kill */
559#define BLKPREP_DEFER 2 /* leave on queue */
560
561extern unsigned long blk_max_low_pfn, blk_max_pfn;
562
563/*
564 * standard bounce addresses:
565 *
566 * BLK_BOUNCE_HIGH : bounce all highmem pages
567 * BLK_BOUNCE_ANY : don't bounce anything
568 * BLK_BOUNCE_ISA : bounce pages above ISA DMA boundary
569 */
570#define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT)
571#define BLK_BOUNCE_ANY ((u64)blk_max_pfn << PAGE_SHIFT)
572#define BLK_BOUNCE_ISA (ISA_DMA_THRESHOLD)
573
574#ifdef CONFIG_MMU
575extern int init_emergency_isa_pool(void);
576extern void blk_queue_bounce(request_queue_t *q, struct bio **bio);
577#else
578static inline int init_emergency_isa_pool(void)
579{
580 return 0;
581}
582static inline void blk_queue_bounce(request_queue_t *q, struct bio **bio)
583{
584}
585#endif /* CONFIG_MMU */
586
587#define rq_for_each_bio(_bio, rq) \
588 if ((rq->bio)) \
589 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
590
591struct sec_size {
592 unsigned block_size;
593 unsigned block_size_bits;
594};
595
596extern int blk_register_queue(struct gendisk *disk);
597extern void blk_unregister_queue(struct gendisk *disk);
598extern void register_disk(struct gendisk *dev);
599extern void generic_make_request(struct bio *bio);
600extern void blk_put_request(struct request *);
6e39b69e 601extern void __blk_put_request(request_queue_t *, struct request *);
8ffdc655 602extern void blk_end_sync_rq(struct request *rq, int error);
8267e268 603extern struct request *blk_get_request(request_queue_t *, int, gfp_t);
867d1191 604extern void blk_insert_request(request_queue_t *, struct request *, int, void *);
1da177e4
LT		 605extern void blk_requeue_request(request_queue_t *, struct request *);
606extern void blk_plug_device(request_queue_t *);
607extern int blk_remove_plug(request_queue_t *);
608extern void blk_recount_segments(request_queue_t *, struct bio *);
1da177e4
LT		 609extern int scsi_cmd_ioctl(struct file *, struct gendisk *, unsigned int, void __user *);
610extern void blk_start_queue(request_queue_t *q);
611extern void blk_stop_queue(request_queue_t *q);
612extern void blk_sync_queue(struct request_queue *q);
613extern void __blk_stop_queue(request_queue_t *q);
614extern void blk_run_queue(request_queue_t *);
615extern void blk_queue_activity_fn(request_queue_t *, activity_fn *, void *);
dd1cab95
JA		 616extern int blk_rq_map_user(request_queue_t *, struct request *, void __user *, unsigned int);
617extern int blk_rq_unmap_user(struct bio *, unsigned int);
8267e268 618extern int blk_rq_map_kern(request_queue_t *, struct request *, void *, unsigned int, gfp_t);
f1970baf 619extern int blk_rq_map_user_iov(request_queue_t *, struct request *, struct sg_iovec *, int);
994ca9a1
JB		 620extern int blk_execute_rq(request_queue_t *, struct gendisk *,
621 struct request *, int);
6e39b69e 622extern void blk_execute_rq_nowait(request_queue_t *, struct gendisk *,
15fc858a 623 struct request *, int, rq_end_io_fn *);
6e39b69e 624
1da177e4
LT		 625static inline request_queue_t *bdev_get_queue(struct block_device *bdev)
626{
627 return bdev->bd_disk->queue;
628}
629
630static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
631 struct page *page)
632{
633 if (bdi && bdi->unplug_io_fn)
634 bdi->unplug_io_fn(bdi, page);
635}
636
637static inline void blk_run_address_space(struct address_space *mapping)
638{
639 if (mapping)
640 blk_run_backing_dev(mapping->backing_dev_info, NULL);
641}
642
643/*
644 * end_request() and friends. Must be called with the request queue spinlock
645 * acquired. All functions called within end_request() _must_be_ atomic.
646 *
647 * Several drivers define their own end_request and call
648 * end_that_request_first() and end_that_request_last()
649 * for parts of the original function. This prevents
650 * code duplication in drivers.
651 */
652extern int end_that_request_first(struct request *, int, int);
653extern int end_that_request_chunk(struct request *, int, int);
8ffdc655 654extern void end_that_request_last(struct request *, int);
1da177e4 655extern void end_request(struct request *req, int uptodate);
ff856bad
JA		 656extern void blk_complete_request(struct request *);
657
658static inline int rq_all_done(struct request *rq, unsigned int nr_bytes)
659{
660 if (blk_fs_request(rq))
661 return (nr_bytes >= (rq->hard_nr_sectors << 9));
662 else if (blk_pc_request(rq))
663 return nr_bytes >= rq->data_len;
664
665 return 0;
666}
1da177e4
LT		 667
668/*
669 * end_that_request_first/chunk() takes an uptodate argument. we account
670 * any value <= as an io error. 0 means -EIO for compatability reasons,
671 * any other < 0 value is the direct error type. An uptodate value of
672 * 1 indicates successful io completion
673 */
674#define end_io_error(uptodate) (unlikely((uptodate) <= 0))
675
676static inline void blkdev_dequeue_request(struct request *req)
677{
8922e16c 678 elv_dequeue_request(req->q, req);
1da177e4 679}
1da177e4 680
1b47f531
JA		 681/*
682 * This should be in elevator.h, but that requires pulling in rq and q
683 */
684static inline void elv_dispatch_add_tail(struct request_queue *q,
685 struct request *rq)
686{
06b86245
TH		 687 if (q->last_merge == rq)
688 q->last_merge = NULL;
15853af9 689 q->nr_sorted--;
1da177e4 690
1b47f531
JA		 691 q->end_sector = rq_end_sector(rq);
692 q->boundary_rq = rq;
693 list_add_tail(&rq->queuelist, &q->queue_head);
1da177e4
LT		 694}
695
696/*
697 * Access functions for manipulating queue properties
698 */
1946089a
CL		 699extern request_queue_t *blk_init_queue_node(request_fn_proc *rfn,
700 spinlock_t *lock, int node_id);
1da177e4
LT		 701extern request_queue_t *blk_init_queue(request_fn_proc *, spinlock_t *);
702extern void blk_cleanup_queue(request_queue_t *);
703extern void blk_queue_make_request(request_queue_t *, make_request_fn *);
704extern void blk_queue_bounce_limit(request_queue_t *, u64);
2cb2e147 705extern void blk_queue_max_sectors(request_queue_t *, unsigned int);
1da177e4
LT		 706extern void blk_queue_max_phys_segments(request_queue_t *, unsigned short);
707extern void blk_queue_max_hw_segments(request_queue_t *, unsigned short);
708extern void blk_queue_max_segment_size(request_queue_t *, unsigned int);
709extern void blk_queue_hardsect_size(request_queue_t *, unsigned short);
710extern void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b);
711extern void blk_queue_segment_boundary(request_queue_t *, unsigned long);
712extern void blk_queue_prep_rq(request_queue_t *, prep_rq_fn *pfn);
713extern void blk_queue_merge_bvec(request_queue_t *, merge_bvec_fn *);
714extern void blk_queue_dma_alignment(request_queue_t *, int);
ff856bad 715extern void blk_queue_softirq_done(request_queue_t *, softirq_done_fn *);
1da177e4 716extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
797e7dbb 717extern int blk_queue_ordered(request_queue_t *, unsigned, prepare_flush_fn *);
1da177e4 718extern void blk_queue_issue_flush_fn(request_queue_t *, issue_flush_fn *);
797e7dbb
TH		 719extern int blk_do_ordered(request_queue_t *, struct request **);
720extern unsigned blk_ordered_cur_seq(request_queue_t *);
721extern unsigned blk_ordered_req_seq(struct request *);
722extern void blk_ordered_complete_seq(request_queue_t *, unsigned, int);
1da177e4
LT		 723
724extern int blk_rq_map_sg(request_queue_t *, struct request *, struct scatterlist *);
725extern void blk_dump_rq_flags(struct request *, char *);
726extern void generic_unplug_device(request_queue_t *);
727extern void __generic_unplug_device(request_queue_t *);
728extern long nr_blockdev_pages(void);
1da177e4
LT		 729
730int blk_get_queue(request_queue_t *);
8267e268
AV		 731request_queue_t *blk_alloc_queue(gfp_t);
732request_queue_t *blk_alloc_queue_node(gfp_t, int);
483f4afc 733extern void blk_put_queue(request_queue_t *);
1da177e4
LT		 734
735/*
736 * tag stuff
737 */
738#define blk_queue_tag_depth(q) ((q)->queue_tags->busy)
739#define blk_queue_tag_queue(q) ((q)->queue_tags->busy < (q)->queue_tags->max_depth)
740#define blk_rq_tagged(rq) ((rq)->flags & REQ_QUEUED)
741extern int blk_queue_start_tag(request_queue_t *, struct request *);
742extern struct request *blk_queue_find_tag(request_queue_t *, int);
743extern void blk_queue_end_tag(request_queue_t *, struct request *);
744extern int blk_queue_init_tags(request_queue_t *, int, struct blk_queue_tag *);
745extern void blk_queue_free_tags(request_queue_t *);
746extern int blk_queue_resize_tags(request_queue_t *, int);
747extern void blk_queue_invalidate_tags(request_queue_t *);
748extern long blk_congestion_wait(int rw, long timeout);
749
750extern void blk_rq_bio_prep(request_queue_t *, struct request *, struct bio *);
751extern int blkdev_issue_flush(struct block_device *, sector_t *);
752
753#define MAX_PHYS_SEGMENTS 128
754#define MAX_HW_SEGMENTS 128
defd94b7
MC		 755#define SAFE_MAX_SECTORS 255
756#define BLK_DEF_MAX_SECTORS 1024
1da177e4
LT		 757
758#define MAX_SEGMENT_SIZE 65536
759
760#define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
761
1da177e4
LT		 762static inline int queue_hardsect_size(request_queue_t *q)
763{
764 int retval = 512;
765
766 if (q && q->hardsect_size)
767 retval = q->hardsect_size;
768
769 return retval;
770}
771
772static inline int bdev_hardsect_size(struct block_device *bdev)
773{
774 return queue_hardsect_size(bdev_get_queue(bdev));
775}
776
777static inline int queue_dma_alignment(request_queue_t *q)
778{
779 int retval = 511;
780
781 if (q && q->dma_alignment)
782 retval = q->dma_alignment;
783
784 return retval;
785}
786
787static inline int bdev_dma_aligment(struct block_device *bdev)
788{
789 return queue_dma_alignment(bdev_get_queue(bdev));
790}
791
792#define blk_finished_io(nsects) do { } while (0)
793#define blk_started_io(nsects) do { } while (0)
794
795/* assumes size > 256 */
796static inline unsigned int blksize_bits(unsigned int size)
797{
798 unsigned int bits = 8;
799 do {
800 bits++;
801 size >>= 1;
802 } while (size > 256);
803 return bits;
804}
805
2befb9e3 806static inline unsigned int block_size(struct block_device *bdev)
1da177e4
LT		 807{
808 return bdev->bd_block_size;
809}
810
811typedef struct {struct page *v;} Sector;
812
813unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
814
815static inline void put_dev_sector(Sector p)
816{
817 page_cache_release(p.v);
818}
819
820struct work_struct;
821int kblockd_schedule_work(struct work_struct *work);
822void kblockd_flush(void);
823
824#ifdef CONFIG_LBD
825# include <asm/div64.h>
826# define sector_div(a, b) do_div(a, b)
827#else
828# define sector_div(n, b)( \
829{ \
830 int _res; \
831 _res = (n) % (b); \
832 (n) /= (b); \
833 _res; \
834} \
835)
836#endif
837
838#define MODULE_ALIAS_BLOCKDEV(major,minor) \
839 MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
840#define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
841 MODULE_ALIAS("block-major-" __stringify(major) "-*")
842
843
844#endif
Linux 6.x block layer and io_uring tree(s)