1 #ifndef _LINUX_BLKDEV_H 2 #define _LINUX_BLKDEV_H 3 4 #ifdef CONFIG_BLOCK 5 6 #include <linux/sched.h> 7 #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> 19 #include <linux/bsg.h> 20 21 #include <asm/scatterlist.h> 22 23 struct scsi_ioctl_command; 24 25 struct request_queue; 26 typedef struct request_queue request_queue_t __deprecated; 27 struct elevator_queue; 28 typedef struct elevator_queue elevator_t; 29 struct request_pm_state; 30 struct blk_trace; 31 struct request; 32 struct sg_io_hdr; 33 34 #define BLKDEV_MIN_RQ 4 35 #define BLKDEV_MAX_RQ 128 /* Default maximum */ 36 37 int put_io_context(struct io_context *ioc); 38 void exit_io_context(void); 39 struct io_context *get_io_context(gfp_t gfp_flags, int node); 40 struct io_context *alloc_io_context(gfp_t gfp_flags, int node); 41 void copy_io_context(struct io_context **pdst, struct io_context **psrc); 42 43 struct request; 44 typedef void (rq_end_io_fn)(struct request *, int); 45 46 struct request_list { 47 int count[2]; 48 int starved[2]; 49 int elvpriv; 50 mempool_t *rq_pool; 51 wait_queue_head_t wait[2]; 52 }; 53 54 /* 55 * request command types 56 */ 57 enum rq_cmd_type_bits { 58 REQ_TYPE_FS = 1, /* fs request */ 59 REQ_TYPE_BLOCK_PC, /* scsi command */ 60 REQ_TYPE_SENSE, /* sense request */ 61 REQ_TYPE_PM_SUSPEND, /* suspend request */ 62 REQ_TYPE_PM_RESUME, /* resume request */ 63 REQ_TYPE_PM_SHUTDOWN, /* shutdown request */ 64 REQ_TYPE_FLUSH, /* flush request */ 65 REQ_TYPE_SPECIAL, /* driver defined type */ 66 REQ_TYPE_LINUX_BLOCK, /* generic block layer message */ 67 /* 68 * for ATA/ATAPI devices. this really doesn't belong here, ide should 69 * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver 70 * private REQ_LB opcodes to differentiate what type of request this is 71 */ 72 REQ_TYPE_ATA_TASKFILE, 73 REQ_TYPE_ATA_PC, 74 }; 75 76 /* 77 * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being 78 * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a 79 * SCSI cdb. 80 * 81 * 0x00 -> 0x3f are driver private, to be used for whatever purpose they need, 82 * typically to differentiate REQ_TYPE_SPECIAL requests. 83 * 84 */ 85 enum { 86 /* 87 * just examples for now 88 */ 89 REQ_LB_OP_EJECT = 0x40, /* eject request */ 90 REQ_LB_OP_FLUSH = 0x41, /* flush device */ 91 }; 92 93 /* 94 * request type modified bits. first three bits match BIO_RW* bits, important 95 */ 96 enum rq_flag_bits { 97 __REQ_RW, /* not set, read. set, write */ 98 __REQ_FAILFAST, /* no low level driver retries */ 99 __REQ_SORTED, /* elevator knows about this request */ 100 __REQ_SOFTBARRIER, /* may not be passed by ioscheduler */ 101 __REQ_HARDBARRIER, /* may not be passed by drive either */ 102 __REQ_FUA, /* forced unit access */ 103 __REQ_NOMERGE, /* don't touch this for merging */ 104 __REQ_STARTED, /* drive already may have started this one */ 105 __REQ_DONTPREP, /* don't call prep for this one */ 106 __REQ_QUEUED, /* uses queueing */ 107 __REQ_ELVPRIV, /* elevator private data attached */ 108 __REQ_FAILED, /* set if the request failed */ 109 __REQ_QUIET, /* don't worry about errors */ 110 __REQ_PREEMPT, /* set for "ide_preempt" requests */ 111 __REQ_ORDERED_COLOR, /* is before or after barrier */ 112 __REQ_RW_SYNC, /* request is sync (O_DIRECT) */ 113 __REQ_ALLOCED, /* request came from our alloc pool */ 114 __REQ_RW_META, /* metadata io request */ 115 __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) 134 #define REQ_ALLOCED (1 << __REQ_ALLOCED) 135 #define REQ_RW_META (1 << __REQ_RW_META) 136 137 #define BLK_MAX_CDB 16 138 139 /* 140 * try to put the fields that are referenced together in the same cacheline. 141 * if you modify this structure, be sure to check block/blk-core.c:rq_init() 142 * as well! 143 */ 144 struct request { 145 struct list_head queuelist; 146 struct list_head donelist; 147 148 struct request_queue *q; 149 150 unsigned int cmd_flags; 151 enum rq_cmd_type_bits cmd_type; 152 153 /* Maintain bio traversal state for part by part I/O submission. 154 * hard_* are block layer internals, no driver should touch them! 155 */ 156 157 sector_t sector; /* next sector to submit */ 158 sector_t hard_sector; /* next sector to complete */ 159 unsigned long nr_sectors; /* no. of sectors left to submit */ 160 unsigned long hard_nr_sectors; /* no. of sectors left to complete */ 161 /* no. of sectors left to submit in the current segment */ 162 unsigned int current_nr_sectors; 163 164 /* no. of sectors left to complete in the current segment */ 165 unsigned int hard_cur_sectors; 166 167 struct bio *bio; 168 struct bio *biotail; 169 170 struct hlist_node hash; /* merge hash */ 171 /* 172 * The rb_node is only used inside the io scheduler, requests 173 * are pruned when moved to the dispatch queue. So let the 174 * completion_data share space with the rb_node. 175 */ 176 union { 177 struct rb_node rb_node; /* sort/lookup */ 178 void *completion_data; 179 }; 180 181 /* 182 * two pointers are available for the IO schedulers, if they need 183 * more they have to dynamically allocate it. 184 */ 185 void *elevator_private; 186 void *elevator_private2; 187 188 struct gendisk *rq_disk; 189 unsigned long start_time; 190 191 /* Number of scatter-gather DMA addr+len pairs after 192 * physical address coalescing is performed. 193 */ 194 unsigned short nr_phys_segments; 195 196 /* Number of scatter-gather addr+len pairs after 197 * physical and DMA remapping hardware coalescing is performed. 198 * This is the number of scatter-gather entries the driver 199 * will actually have to deal with after DMA mapping is done. 200 */ 201 unsigned short nr_hw_segments; 202 203 unsigned short ioprio; 204 205 void *special; 206 char *buffer; 207 208 int tag; 209 int errors; 210 211 int ref_count; 212 213 /* 214 * when request is used as a packet command carrier 215 */ 216 unsigned int cmd_len; 217 unsigned char cmd[BLK_MAX_CDB]; 218 219 unsigned int data_len; 220 unsigned int extra_len; /* length of alignment and padding */ 221 unsigned int sense_len; 222 void *data; 223 void *sense; 224 225 unsigned int timeout; 226 int retries; 227 228 /* 229 * completion callback. 230 */ 231 rq_end_io_fn *end_io; 232 void *end_io_data; 233 234 /* for bidi */ 235 struct request *next_rq; 236 }; 237 238 /* 239 * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME 240 * requests. Some step values could eventually be made generic. 241 */ 242 struct request_pm_state 243 { 244 /* PM state machine step value, currently driver specific */ 245 int pm_step; 246 /* requested PM state value (S1, S2, S3, S4, ...) */ 247 u32 pm_state; 248 void* data; /* for driver use */ 249 }; 250 251 #include <linux/elevator.h> 252 253 typedef void (request_fn_proc) (struct request_queue *q); 254 typedef int (make_request_fn) (struct request_queue *q, struct bio *bio); 255 typedef int (prep_rq_fn) (struct request_queue *, struct request *); 256 typedef void (unplug_fn) (struct request_queue *); 257 258 struct bio_vec; 259 typedef int (merge_bvec_fn) (struct request_queue *, struct bio *, struct bio_vec *); 260 typedef void (prepare_flush_fn) (struct request_queue *, struct request *); 261 typedef void (softirq_done_fn)(struct request *); 262 typedef int (dma_drain_needed_fn)(struct request *); 263 264 enum blk_queue_state { 265 Queue_down, 266 Queue_up, 267 }; 268 269 struct blk_queue_tag { 270 struct request **tag_index; /* map of busy tags */ 271 unsigned long *tag_map; /* bit map of free/busy tags */ 272 int busy; /* current depth */ 273 int max_depth; /* what we will send to device */ 274 int real_max_depth; /* what the array can hold */ 275 atomic_t refcnt; /* map can be shared */ 276 }; 277 278 struct request_queue 279 { 280 /* 281 * Together with queue_head for cacheline sharing 282 */ 283 struct list_head queue_head; 284 struct request *last_merge; 285 elevator_t *elevator; 286 287 /* 288 * the queue request freelist, one for reads and one for writes 289 */ 290 struct request_list rq; 291 292 request_fn_proc *request_fn; 293 make_request_fn *make_request_fn; 294 prep_rq_fn *prep_rq_fn; 295 unplug_fn *unplug_fn; 296 merge_bvec_fn *merge_bvec_fn; 297 prepare_flush_fn *prepare_flush_fn; 298 softirq_done_fn *softirq_done_fn; 299 dma_drain_needed_fn *dma_drain_needed; 300 301 /* 302 * Dispatch queue sorting 303 */ 304 sector_t end_sector; 305 struct request *boundary_rq; 306 307 /* 308 * Auto-unplugging state 309 */ 310 struct timer_list unplug_timer; 311 int unplug_thresh; /* After this many requests */ 312 unsigned long unplug_delay; /* After this many jiffies */ 313 struct work_struct unplug_work; 314 315 struct backing_dev_info backing_dev_info; 316 317 /* 318 * The queue owner gets to use this for whatever they like. 319 * ll_rw_blk doesn't touch it. 320 */ 321 void *queuedata; 322 323 /* 324 * queue needs bounce pages for pages above this limit 325 */ 326 unsigned long bounce_pfn; 327 gfp_t bounce_gfp; 328 329 /* 330 * various queue flags, see QUEUE_* below 331 */ 332 unsigned long queue_flags; 333 334 /* 335 * protects queue structures from reentrancy. ->__queue_lock should 336 * _never_ be used directly, it is queue private. always use 337 * ->queue_lock. 338 */ 339 spinlock_t __queue_lock; 340 spinlock_t *queue_lock; 341 342 /* 343 * queue kobject 344 */ 345 struct kobject kobj; 346 347 /* 348 * queue settings 349 */ 350 unsigned long nr_requests; /* Max # of requests */ 351 unsigned int nr_congestion_on; 352 unsigned int nr_congestion_off; 353 unsigned int nr_batching; 354 355 unsigned int max_sectors; 356 unsigned int max_hw_sectors; 357 unsigned short max_phys_segments; 358 unsigned short max_hw_segments; 359 unsigned short hardsect_size; 360 unsigned int max_segment_size; 361 362 unsigned long seg_boundary_mask; 363 void *dma_drain_buffer; 364 unsigned int dma_drain_size; 365 unsigned int dma_pad_mask; 366 unsigned int dma_alignment; 367 368 struct blk_queue_tag *queue_tags; 369 struct list_head tag_busy_list; 370 371 unsigned int nr_sorted; 372 unsigned int in_flight; 373 374 /* 375 * sg stuff 376 */ 377 unsigned int sg_timeout; 378 unsigned int sg_reserved_size; 379 int node; 380 #ifdef CONFIG_BLK_DEV_IO_TRACE 381 struct blk_trace *blk_trace; 382 #endif 383 /* 384 * reserved for flush operations 385 */ 386 unsigned int ordered, next_ordered, ordseq; 387 int orderr, ordcolor; 388 struct request pre_flush_rq, bar_rq, post_flush_rq; 389 struct request *orig_bar_rq; 390 391 struct mutex sysfs_lock; 392 393 #if defined(CONFIG_BLK_DEV_BSG) 394 struct bsg_class_device bsg_dev; 395 #endif 396 }; 397 398 #define QUEUE_FLAG_CLUSTER 0 /* cluster several segments into 1 */ 399 #define QUEUE_FLAG_QUEUED 1 /* uses generic tag queueing */ 400 #define QUEUE_FLAG_STOPPED 2 /* queue is stopped */ 401 #define QUEUE_FLAG_READFULL 3 /* read queue has been filled */ 402 #define QUEUE_FLAG_WRITEFULL 4 /* write queue has been filled */ 403 #define QUEUE_FLAG_DEAD 5 /* queue being torn down */ 404 #define QUEUE_FLAG_REENTER 6 /* Re-entrancy avoidance */ 405 #define QUEUE_FLAG_PLUGGED 7 /* queue is plugged */ 406 #define QUEUE_FLAG_ELVSWITCH 8 /* don't use elevator, just do FIFO */ 407 #define QUEUE_FLAG_BIDI 9 /* queue supports bidi requests */ 408 409 enum { 410 /* 411 * Hardbarrier is supported with one of the following methods. 412 * 413 * NONE : hardbarrier unsupported 414 * DRAIN : ordering by draining is enough 415 * DRAIN_FLUSH : ordering by draining w/ pre and post flushes 416 * DRAIN_FUA : ordering by draining w/ pre flush and FUA write 417 * TAG : ordering by tag is enough 418 * TAG_FLUSH : ordering by tag w/ pre and post flushes 419 * TAG_FUA : ordering by tag w/ pre flush and FUA write 420 */ 421 QUEUE_ORDERED_NONE = 0x00, 422 QUEUE_ORDERED_DRAIN = 0x01, 423 QUEUE_ORDERED_TAG = 0x02, 424 425 QUEUE_ORDERED_PREFLUSH = 0x10, 426 QUEUE_ORDERED_POSTFLUSH = 0x20, 427 QUEUE_ORDERED_FUA = 0x40, 428 429 QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN | 430 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH, 431 QUEUE_ORDERED_DRAIN_FUA = QUEUE_ORDERED_DRAIN | 432 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA, 433 QUEUE_ORDERED_TAG_FLUSH = QUEUE_ORDERED_TAG | 434 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH, 435 QUEUE_ORDERED_TAG_FUA = QUEUE_ORDERED_TAG | 436 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA, 437 438 /* 439 * Ordered operation sequence 440 */ 441 QUEUE_ORDSEQ_STARTED = 0x01, /* flushing in progress */ 442 QUEUE_ORDSEQ_DRAIN = 0x02, /* waiting for the queue to be drained */ 443 QUEUE_ORDSEQ_PREFLUSH = 0x04, /* pre-flushing in progress */ 444 QUEUE_ORDSEQ_BAR = 0x08, /* original barrier req in progress */ 445 QUEUE_ORDSEQ_POSTFLUSH = 0x10, /* post-flushing in progress */ 446 QUEUE_ORDSEQ_DONE = 0x20, 447 }; 448 449 #define blk_queue_plugged(q) test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags) 450 #define blk_queue_tagged(q) test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags) 451 #define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags) 452 #define blk_queue_flushing(q) ((q)->ordseq) 453 454 #define blk_fs_request(rq) ((rq)->cmd_type == REQ_TYPE_FS) 455 #define blk_pc_request(rq) ((rq)->cmd_type == REQ_TYPE_BLOCK_PC) 456 #define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL) 457 #define blk_sense_request(rq) ((rq)->cmd_type == REQ_TYPE_SENSE) 458 459 #define blk_noretry_request(rq) ((rq)->cmd_flags & REQ_FAILFAST) 460 #define blk_rq_started(rq) ((rq)->cmd_flags & REQ_STARTED) 461 462 #define blk_account_rq(rq) (blk_rq_started(rq) && blk_fs_request(rq)) 463 464 #define blk_pm_suspend_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND) 465 #define blk_pm_resume_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_RESUME) 466 #define blk_pm_request(rq) \ 467 (blk_pm_suspend_request(rq) || blk_pm_resume_request(rq)) 468 469 #define blk_sorted_rq(rq) ((rq)->cmd_flags & REQ_SORTED) 470 #define blk_barrier_rq(rq) ((rq)->cmd_flags & REQ_HARDBARRIER) 471 #define blk_fua_rq(rq) ((rq)->cmd_flags & REQ_FUA) 472 #define blk_bidi_rq(rq) ((rq)->next_rq != NULL) 473 #define blk_empty_barrier(rq) (blk_barrier_rq(rq) && blk_fs_request(rq) && !(rq)->hard_nr_sectors) 474 /* rq->queuelist of dequeued request must be list_empty() */ 475 #define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist)) 476 477 #define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist) 478 479 #define rq_data_dir(rq) ((rq)->cmd_flags & 1) 480 481 /* 482 * We regard a request as sync, if it's a READ or a SYNC write. 483 */ 484 #define rq_is_sync(rq) (rq_data_dir((rq)) == READ || (rq)->cmd_flags & REQ_RW_SYNC) 485 #define rq_is_meta(rq) ((rq)->cmd_flags & REQ_RW_META) 486 487 static inline int blk_queue_full(struct request_queue *q, int rw) 488 { 489 if (rw == READ) 490 return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags); 491 return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags); 492 } 493 494 static inline void blk_set_queue_full(struct request_queue *q, int rw) 495 { 496 if (rw == READ) 497 set_bit(QUEUE_FLAG_READFULL, &q->queue_flags); 498 else 499 set_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags); 500 } 501 502 static inline void blk_clear_queue_full(struct request_queue *q, int rw) 503 { 504 if (rw == READ) 505 clear_bit(QUEUE_FLAG_READFULL, &q->queue_flags); 506 else 507 clear_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags); 508 } 509 510 511 /* 512 * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may 513 * it already be started by driver. 514 */ 515 #define RQ_NOMERGE_FLAGS \ 516 (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER) 517 #define rq_mergeable(rq) \ 518 (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq))) 519 520 /* 521 * q->prep_rq_fn return values 522 */ 523 #define BLKPREP_OK 0 /* serve it */ 524 #define BLKPREP_KILL 1 /* fatal error, kill */ 525 #define BLKPREP_DEFER 2 /* leave on queue */ 526 527 extern unsigned long blk_max_low_pfn, blk_max_pfn; 528 529 /* 530 * standard bounce addresses: 531 * 532 * BLK_BOUNCE_HIGH : bounce all highmem pages 533 * BLK_BOUNCE_ANY : don't bounce anything 534 * BLK_BOUNCE_ISA : bounce pages above ISA DMA boundary 535 */ 536 #define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT) 537 #define BLK_BOUNCE_ANY ((u64)blk_max_pfn << PAGE_SHIFT) 538 #define BLK_BOUNCE_ISA (ISA_DMA_THRESHOLD) 539 540 /* 541 * default timeout for SG_IO if none specified 542 */ 543 #define BLK_DEFAULT_SG_TIMEOUT (60 * HZ) 544 545 #ifdef CONFIG_BOUNCE 546 extern int init_emergency_isa_pool(void); 547 extern void blk_queue_bounce(struct request_queue *q, struct bio **bio); 548 #else 549 static inline int init_emergency_isa_pool(void) 550 { 551 return 0; 552 } 553 static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio) 554 { 555 } 556 #endif /* CONFIG_MMU */ 557 558 struct req_iterator { 559 int i; 560 struct bio *bio; 561 }; 562 563 /* This should not be used directly - use rq_for_each_segment */ 564 #define __rq_for_each_bio(_bio, rq) \ 565 if ((rq->bio)) \ 566 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next) 567 568 #define rq_for_each_segment(bvl, _rq, _iter) \ 569 __rq_for_each_bio(_iter.bio, _rq) \ 570 bio_for_each_segment(bvl, _iter.bio, _iter.i) 571 572 #define rq_iter_last(rq, _iter) \ 573 (_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1) 574 575 extern int blk_register_queue(struct gendisk *disk); 576 extern void blk_unregister_queue(struct gendisk *disk); 577 extern void register_disk(struct gendisk *dev); 578 extern void generic_make_request(struct bio *bio); 579 extern void blk_put_request(struct request *); 580 extern void __blk_put_request(struct request_queue *, struct request *); 581 extern void blk_end_sync_rq(struct request *rq, int error); 582 extern struct request *blk_get_request(struct request_queue *, int, gfp_t); 583 extern void blk_insert_request(struct request_queue *, struct request *, int, void *); 584 extern void blk_requeue_request(struct request_queue *, struct request *); 585 extern void blk_plug_device(struct request_queue *); 586 extern int blk_remove_plug(struct request_queue *); 587 extern void blk_recount_segments(struct request_queue *, struct bio *); 588 extern int scsi_cmd_ioctl(struct file *, struct request_queue *, 589 struct gendisk *, unsigned int, void __user *); 590 extern int sg_scsi_ioctl(struct file *, struct request_queue *, 591 struct gendisk *, struct scsi_ioctl_command __user *); 592 593 /* 594 * Temporary export, until SCSI gets fixed up. 595 */ 596 extern int blk_rq_append_bio(struct request_queue *q, struct request *rq, 597 struct bio *bio); 598 599 /* 600 * A queue has just exitted congestion. Note this in the global counter of 601 * congested queues, and wake up anyone who was waiting for requests to be 602 * put back. 603 */ 604 static inline void blk_clear_queue_congested(struct request_queue *q, int rw) 605 { 606 clear_bdi_congested(&q->backing_dev_info, rw); 607 } 608 609 /* 610 * A queue has just entered congestion. Flag that in the queue's VM-visible 611 * state flags and increment the global gounter of congested queues. 612 */ 613 static inline void blk_set_queue_congested(struct request_queue *q, int rw) 614 { 615 set_bdi_congested(&q->backing_dev_info, rw); 616 } 617 618 extern void blk_start_queue(struct request_queue *q); 619 extern void blk_stop_queue(struct request_queue *q); 620 extern void blk_sync_queue(struct request_queue *q); 621 extern void __blk_stop_queue(struct request_queue *q); 622 extern void blk_run_queue(struct request_queue *); 623 extern void blk_start_queueing(struct request_queue *); 624 extern int blk_rq_map_user(struct request_queue *, struct request *, void __user *, unsigned long); 625 extern int blk_rq_unmap_user(struct bio *); 626 extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t); 627 extern int blk_rq_map_user_iov(struct request_queue *, struct request *, 628 struct sg_iovec *, int, unsigned int); 629 extern int blk_execute_rq(struct request_queue *, struct gendisk *, 630 struct request *, int); 631 extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *, 632 struct request *, int, rq_end_io_fn *); 633 extern int blk_verify_command(unsigned char *, int); 634 extern void blk_unplug(struct request_queue *q); 635 636 static inline struct request_queue *bdev_get_queue(struct block_device *bdev) 637 { 638 return bdev->bd_disk->queue; 639 } 640 641 static inline void blk_run_backing_dev(struct backing_dev_info *bdi, 642 struct page *page) 643 { 644 if (bdi && bdi->unplug_io_fn) 645 bdi->unplug_io_fn(bdi, page); 646 } 647 648 static inline void blk_run_address_space(struct address_space *mapping) 649 { 650 if (mapping) 651 blk_run_backing_dev(mapping->backing_dev_info, NULL); 652 } 653 654 /* 655 * blk_end_request() and friends. 656 * __blk_end_request() and end_request() must be called with 657 * the request queue spinlock acquired. 658 * 659 * Several drivers define their own end_request and call 660 * blk_end_request() for parts of the original function. 661 * This prevents code duplication in drivers. 662 */ 663 extern int blk_end_request(struct request *rq, int error, 664 unsigned int nr_bytes); 665 extern int __blk_end_request(struct request *rq, int error, 666 unsigned int nr_bytes); 667 extern int blk_end_bidi_request(struct request *rq, int error, 668 unsigned int nr_bytes, unsigned int bidi_bytes); 669 extern void end_request(struct request *, int); 670 extern void end_queued_request(struct request *, int); 671 extern void end_dequeued_request(struct request *, int); 672 extern int blk_end_request_callback(struct request *rq, int error, 673 unsigned int nr_bytes, 674 int (drv_callback)(struct request *)); 675 extern void blk_complete_request(struct request *); 676 677 /* 678 * blk_end_request() takes bytes instead of sectors as a complete size. 679 * blk_rq_bytes() returns bytes left to complete in the entire request. 680 * blk_rq_cur_bytes() returns bytes left to complete in the current segment. 681 */ 682 extern unsigned int blk_rq_bytes(struct request *rq); 683 extern unsigned int blk_rq_cur_bytes(struct request *rq); 684 685 static inline void blkdev_dequeue_request(struct request *req) 686 { 687 elv_dequeue_request(req->q, req); 688 } 689 690 /* 691 * Access functions for manipulating queue properties 692 */ 693 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn, 694 spinlock_t *lock, int node_id); 695 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *); 696 extern void blk_cleanup_queue(struct request_queue *); 697 extern void blk_queue_make_request(struct request_queue *, make_request_fn *); 698 extern void blk_queue_bounce_limit(struct request_queue *, u64); 699 extern void blk_queue_max_sectors(struct request_queue *, unsigned int); 700 extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short); 701 extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short); 702 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int); 703 extern void blk_queue_hardsect_size(struct request_queue *, unsigned short); 704 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b); 705 extern void blk_queue_dma_pad(struct request_queue *, unsigned int); 706 extern int blk_queue_dma_drain(struct request_queue *q, 707 dma_drain_needed_fn *dma_drain_needed, 708 void *buf, unsigned int size); 709 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long); 710 extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn); 711 extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *); 712 extern void blk_queue_dma_alignment(struct request_queue *, int); 713 extern void blk_queue_update_dma_alignment(struct request_queue *, int); 714 extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *); 715 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev); 716 extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *); 717 extern int blk_do_ordered(struct request_queue *, struct request **); 718 extern unsigned blk_ordered_cur_seq(struct request_queue *); 719 extern unsigned blk_ordered_req_seq(struct request *); 720 extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int); 721 722 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *); 723 extern void blk_dump_rq_flags(struct request *, char *); 724 extern void generic_unplug_device(struct request_queue *); 725 extern void __generic_unplug_device(struct request_queue *); 726 extern long nr_blockdev_pages(void); 727 728 int blk_get_queue(struct request_queue *); 729 struct request_queue *blk_alloc_queue(gfp_t); 730 struct request_queue *blk_alloc_queue_node(gfp_t, int); 731 extern void blk_put_queue(struct request_queue *); 732 733 /* 734 * tag stuff 735 */ 736 #define blk_queue_tag_depth(q) ((q)->queue_tags->busy) 737 #define blk_queue_tag_queue(q) ((q)->queue_tags->busy < (q)->queue_tags->max_depth) 738 #define blk_rq_tagged(rq) ((rq)->cmd_flags & REQ_QUEUED) 739 extern int blk_queue_start_tag(struct request_queue *, struct request *); 740 extern struct request *blk_queue_find_tag(struct request_queue *, int); 741 extern void blk_queue_end_tag(struct request_queue *, struct request *); 742 extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *); 743 extern void blk_queue_free_tags(struct request_queue *); 744 extern int blk_queue_resize_tags(struct request_queue *, int); 745 extern void blk_queue_invalidate_tags(struct request_queue *); 746 extern struct blk_queue_tag *blk_init_tags(int); 747 extern void blk_free_tags(struct blk_queue_tag *); 748 749 static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt, 750 int tag) 751 { 752 if (unlikely(bqt == NULL || tag >= bqt->real_max_depth)) 753 return NULL; 754 return bqt->tag_index[tag]; 755 } 756 757 extern int blkdev_issue_flush(struct block_device *, sector_t *); 758 759 #define MAX_PHYS_SEGMENTS 128 760 #define MAX_HW_SEGMENTS 128 761 #define SAFE_MAX_SECTORS 255 762 #define BLK_DEF_MAX_SECTORS 1024 763 764 #define MAX_SEGMENT_SIZE 65536 765 766 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist) 767 768 static inline int queue_hardsect_size(struct request_queue *q) 769 { 770 int retval = 512; 771 772 if (q && q->hardsect_size) 773 retval = q->hardsect_size; 774 775 return retval; 776 } 777 778 static inline int bdev_hardsect_size(struct block_device *bdev) 779 { 780 return queue_hardsect_size(bdev_get_queue(bdev)); 781 } 782 783 static inline int queue_dma_alignment(struct request_queue *q) 784 { 785 return q ? q->dma_alignment : 511; 786 } 787 788 /* assumes size > 256 */ 789 static inline unsigned int blksize_bits(unsigned int size) 790 { 791 unsigned int bits = 8; 792 do { 793 bits++; 794 size >>= 1; 795 } while (size > 256); 796 return bits; 797 } 798 799 static inline unsigned int block_size(struct block_device *bdev) 800 { 801 return bdev->bd_block_size; 802 } 803 804 typedef struct {struct page *v;} Sector; 805 806 unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *); 807 808 static inline void put_dev_sector(Sector p) 809 { 810 page_cache_release(p.v); 811 } 812 813 struct work_struct; 814 int kblockd_schedule_work(struct work_struct *work); 815 void kblockd_flush_work(struct work_struct *work); 816 817 #define MODULE_ALIAS_BLOCKDEV(major,minor) \ 818 MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor)) 819 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \ 820 MODULE_ALIAS("block-major-" __stringify(major) "-*") 821 822 823 #else /* CONFIG_BLOCK */ 824 /* 825 * stubs for when the block layer is configured out 826 */ 827 #define buffer_heads_over_limit 0 828 829 static inline long nr_blockdev_pages(void) 830 { 831 return 0; 832 } 833 834 static inline void exit_io_context(void) 835 { 836 } 837 838 struct io_context; 839 static inline int put_io_context(struct io_context *ioc) 840 { 841 return 1; 842 } 843 844 845 #endif /* CONFIG_BLOCK */ 846 847 #endif 848