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 sense_len; 221 void *data; 222 void *sense; 223 224 unsigned int timeout; 225 int retries; 226 227 /* 228 * completion callback. 229 */ 230 rq_end_io_fn *end_io; 231 void *end_io_data; 232 233 /* for bidi */ 234 struct request *next_rq; 235 }; 236 237 /* 238 * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME 239 * requests. Some step values could eventually be made generic. 240 */ 241 struct request_pm_state 242 { 243 /* PM state machine step value, currently driver specific */ 244 int pm_step; 245 /* requested PM state value (S1, S2, S3, S4, ...) */ 246 u32 pm_state; 247 void* data; /* for driver use */ 248 }; 249 250 #include <linux/elevator.h> 251 252 typedef void (request_fn_proc) (struct request_queue *q); 253 typedef int (make_request_fn) (struct request_queue *q, struct bio *bio); 254 typedef int (prep_rq_fn) (struct request_queue *, struct request *); 255 typedef void (unplug_fn) (struct request_queue *); 256 257 struct bio_vec; 258 typedef int (merge_bvec_fn) (struct request_queue *, struct bio *, struct bio_vec *); 259 typedef void (prepare_flush_fn) (struct request_queue *, struct request *); 260 typedef void (softirq_done_fn)(struct request *); 261 262 enum blk_queue_state { 263 Queue_down, 264 Queue_up, 265 }; 266 267 struct blk_queue_tag { 268 struct request **tag_index; /* map of busy tags */ 269 unsigned long *tag_map; /* bit map of free/busy tags */ 270 int busy; /* current depth */ 271 int max_depth; /* what we will send to device */ 272 int real_max_depth; /* what the array can hold */ 273 atomic_t refcnt; /* map can be shared */ 274 }; 275 276 struct request_queue 277 { 278 /* 279 * Together with queue_head for cacheline sharing 280 */ 281 struct list_head queue_head; 282 struct request *last_merge; 283 elevator_t *elevator; 284 285 /* 286 * the queue request freelist, one for reads and one for writes 287 */ 288 struct request_list rq; 289 290 request_fn_proc *request_fn; 291 make_request_fn *make_request_fn; 292 prep_rq_fn *prep_rq_fn; 293 unplug_fn *unplug_fn; 294 merge_bvec_fn *merge_bvec_fn; 295 prepare_flush_fn *prepare_flush_fn; 296 softirq_done_fn *softirq_done_fn; 297 298 /* 299 * Dispatch queue sorting 300 */ 301 sector_t end_sector; 302 struct request *boundary_rq; 303 304 /* 305 * Auto-unplugging state 306 */ 307 struct timer_list unplug_timer; 308 int unplug_thresh; /* After this many requests */ 309 unsigned long unplug_delay; /* After this many jiffies */ 310 struct work_struct unplug_work; 311 312 struct backing_dev_info backing_dev_info; 313 314 /* 315 * The queue owner gets to use this for whatever they like. 316 * ll_rw_blk doesn't touch it. 317 */ 318 void *queuedata; 319 320 /* 321 * queue needs bounce pages for pages above this limit 322 */ 323 unsigned long bounce_pfn; 324 gfp_t bounce_gfp; 325 326 /* 327 * various queue flags, see QUEUE_* below 328 */ 329 unsigned long queue_flags; 330 331 /* 332 * protects queue structures from reentrancy. ->__queue_lock should 333 * _never_ be used directly, it is queue private. always use 334 * ->queue_lock. 335 */ 336 spinlock_t __queue_lock; 337 spinlock_t *queue_lock; 338 339 /* 340 * queue kobject 341 */ 342 struct kobject kobj; 343 344 /* 345 * queue settings 346 */ 347 unsigned long nr_requests; /* Max # of requests */ 348 unsigned int nr_congestion_on; 349 unsigned int nr_congestion_off; 350 unsigned int nr_batching; 351 352 unsigned int max_sectors; 353 unsigned int max_hw_sectors; 354 unsigned short max_phys_segments; 355 unsigned short max_hw_segments; 356 unsigned short hardsect_size; 357 unsigned int max_segment_size; 358 359 unsigned long seg_boundary_mask; 360 void *dma_drain_buffer; 361 unsigned int dma_drain_size; 362 unsigned int dma_alignment; 363 364 struct blk_queue_tag *queue_tags; 365 struct list_head tag_busy_list; 366 367 unsigned int nr_sorted; 368 unsigned int in_flight; 369 370 /* 371 * sg stuff 372 */ 373 unsigned int sg_timeout; 374 unsigned int sg_reserved_size; 375 int node; 376 #ifdef CONFIG_BLK_DEV_IO_TRACE 377 struct blk_trace *blk_trace; 378 #endif 379 /* 380 * reserved for flush operations 381 */ 382 unsigned int ordered, next_ordered, ordseq; 383 int orderr, ordcolor; 384 struct request pre_flush_rq, bar_rq, post_flush_rq; 385 struct request *orig_bar_rq; 386 387 struct mutex sysfs_lock; 388 389 #if defined(CONFIG_BLK_DEV_BSG) 390 struct bsg_class_device bsg_dev; 391 #endif 392 }; 393 394 #define QUEUE_FLAG_CLUSTER 0 /* cluster several segments into 1 */ 395 #define QUEUE_FLAG_QUEUED 1 /* uses generic tag queueing */ 396 #define QUEUE_FLAG_STOPPED 2 /* queue is stopped */ 397 #define QUEUE_FLAG_READFULL 3 /* read queue has been filled */ 398 #define QUEUE_FLAG_WRITEFULL 4 /* write queue has been filled */ 399 #define QUEUE_FLAG_DEAD 5 /* queue being torn down */ 400 #define QUEUE_FLAG_REENTER 6 /* Re-entrancy avoidance */ 401 #define QUEUE_FLAG_PLUGGED 7 /* queue is plugged */ 402 #define QUEUE_FLAG_ELVSWITCH 8 /* don't use elevator, just do FIFO */ 403 #define QUEUE_FLAG_BIDI 9 /* queue supports bidi requests */ 404 405 enum { 406 /* 407 * Hardbarrier is supported with one of the following methods. 408 * 409 * NONE : hardbarrier unsupported 410 * DRAIN : ordering by draining is enough 411 * DRAIN_FLUSH : ordering by draining w/ pre and post flushes 412 * DRAIN_FUA : ordering by draining w/ pre flush and FUA write 413 * TAG : ordering by tag is enough 414 * TAG_FLUSH : ordering by tag w/ pre and post flushes 415 * TAG_FUA : ordering by tag w/ pre flush and FUA write 416 */ 417 QUEUE_ORDERED_NONE = 0x00, 418 QUEUE_ORDERED_DRAIN = 0x01, 419 QUEUE_ORDERED_TAG = 0x02, 420 421 QUEUE_ORDERED_PREFLUSH = 0x10, 422 QUEUE_ORDERED_POSTFLUSH = 0x20, 423 QUEUE_ORDERED_FUA = 0x40, 424 425 QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN | 426 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH, 427 QUEUE_ORDERED_DRAIN_FUA = QUEUE_ORDERED_DRAIN | 428 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA, 429 QUEUE_ORDERED_TAG_FLUSH = QUEUE_ORDERED_TAG | 430 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH, 431 QUEUE_ORDERED_TAG_FUA = QUEUE_ORDERED_TAG | 432 QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA, 433 434 /* 435 * Ordered operation sequence 436 */ 437 QUEUE_ORDSEQ_STARTED = 0x01, /* flushing in progress */ 438 QUEUE_ORDSEQ_DRAIN = 0x02, /* waiting for the queue to be drained */ 439 QUEUE_ORDSEQ_PREFLUSH = 0x04, /* pre-flushing in progress */ 440 QUEUE_ORDSEQ_BAR = 0x08, /* original barrier req in progress */ 441 QUEUE_ORDSEQ_POSTFLUSH = 0x10, /* post-flushing in progress */ 442 QUEUE_ORDSEQ_DONE = 0x20, 443 }; 444 445 #define blk_queue_plugged(q) test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags) 446 #define blk_queue_tagged(q) test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags) 447 #define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags) 448 #define blk_queue_flushing(q) ((q)->ordseq) 449 450 #define blk_fs_request(rq) ((rq)->cmd_type == REQ_TYPE_FS) 451 #define blk_pc_request(rq) ((rq)->cmd_type == REQ_TYPE_BLOCK_PC) 452 #define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL) 453 #define blk_sense_request(rq) ((rq)->cmd_type == REQ_TYPE_SENSE) 454 455 #define blk_noretry_request(rq) ((rq)->cmd_flags & REQ_FAILFAST) 456 #define blk_rq_started(rq) ((rq)->cmd_flags & REQ_STARTED) 457 458 #define blk_account_rq(rq) (blk_rq_started(rq) && blk_fs_request(rq)) 459 460 #define blk_pm_suspend_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND) 461 #define blk_pm_resume_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_RESUME) 462 #define blk_pm_request(rq) \ 463 (blk_pm_suspend_request(rq) || blk_pm_resume_request(rq)) 464 465 #define blk_sorted_rq(rq) ((rq)->cmd_flags & REQ_SORTED) 466 #define blk_barrier_rq(rq) ((rq)->cmd_flags & REQ_HARDBARRIER) 467 #define blk_fua_rq(rq) ((rq)->cmd_flags & REQ_FUA) 468 #define blk_bidi_rq(rq) ((rq)->next_rq != NULL) 469 #define blk_empty_barrier(rq) (blk_barrier_rq(rq) && blk_fs_request(rq) && !(rq)->hard_nr_sectors) 470 /* rq->queuelist of dequeued request must be list_empty() */ 471 #define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist)) 472 473 #define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist) 474 475 #define rq_data_dir(rq) ((rq)->cmd_flags & 1) 476 477 /* 478 * We regard a request as sync, if it's a READ or a SYNC write. 479 */ 480 #define rq_is_sync(rq) (rq_data_dir((rq)) == READ || (rq)->cmd_flags & REQ_RW_SYNC) 481 #define rq_is_meta(rq) ((rq)->cmd_flags & REQ_RW_META) 482 483 static inline int blk_queue_full(struct request_queue *q, int rw) 484 { 485 if (rw == READ) 486 return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags); 487 return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags); 488 } 489 490 static inline void blk_set_queue_full(struct request_queue *q, int rw) 491 { 492 if (rw == READ) 493 set_bit(QUEUE_FLAG_READFULL, &q->queue_flags); 494 else 495 set_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags); 496 } 497 498 static inline void blk_clear_queue_full(struct request_queue *q, int rw) 499 { 500 if (rw == READ) 501 clear_bit(QUEUE_FLAG_READFULL, &q->queue_flags); 502 else 503 clear_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags); 504 } 505 506 507 /* 508 * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may 509 * it already be started by driver. 510 */ 511 #define RQ_NOMERGE_FLAGS \ 512 (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER) 513 #define rq_mergeable(rq) \ 514 (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq))) 515 516 /* 517 * q->prep_rq_fn return values 518 */ 519 #define BLKPREP_OK 0 /* serve it */ 520 #define BLKPREP_KILL 1 /* fatal error, kill */ 521 #define BLKPREP_DEFER 2 /* leave on queue */ 522 523 extern unsigned long blk_max_low_pfn, blk_max_pfn; 524 525 /* 526 * standard bounce addresses: 527 * 528 * BLK_BOUNCE_HIGH : bounce all highmem pages 529 * BLK_BOUNCE_ANY : don't bounce anything 530 * BLK_BOUNCE_ISA : bounce pages above ISA DMA boundary 531 */ 532 #define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT) 533 #define BLK_BOUNCE_ANY ((u64)blk_max_pfn << PAGE_SHIFT) 534 #define BLK_BOUNCE_ISA (ISA_DMA_THRESHOLD) 535 536 /* 537 * default timeout for SG_IO if none specified 538 */ 539 #define BLK_DEFAULT_SG_TIMEOUT (60 * HZ) 540 541 #ifdef CONFIG_BOUNCE 542 extern int init_emergency_isa_pool(void); 543 extern void blk_queue_bounce(struct request_queue *q, struct bio **bio); 544 #else 545 static inline int init_emergency_isa_pool(void) 546 { 547 return 0; 548 } 549 static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio) 550 { 551 } 552 #endif /* CONFIG_MMU */ 553 554 struct req_iterator { 555 int i; 556 struct bio *bio; 557 }; 558 559 /* This should not be used directly - use rq_for_each_segment */ 560 #define __rq_for_each_bio(_bio, rq) \ 561 if ((rq->bio)) \ 562 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next) 563 564 #define rq_for_each_segment(bvl, _rq, _iter) \ 565 __rq_for_each_bio(_iter.bio, _rq) \ 566 bio_for_each_segment(bvl, _iter.bio, _iter.i) 567 568 #define rq_iter_last(rq, _iter) \ 569 (_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1) 570 571 extern int blk_register_queue(struct gendisk *disk); 572 extern void blk_unregister_queue(struct gendisk *disk); 573 extern void register_disk(struct gendisk *dev); 574 extern void generic_make_request(struct bio *bio); 575 extern void blk_put_request(struct request *); 576 extern void __blk_put_request(struct request_queue *, struct request *); 577 extern void blk_end_sync_rq(struct request *rq, int error); 578 extern struct request *blk_get_request(struct request_queue *, int, gfp_t); 579 extern void blk_insert_request(struct request_queue *, struct request *, int, void *); 580 extern void blk_requeue_request(struct request_queue *, struct request *); 581 extern void blk_plug_device(struct request_queue *); 582 extern int blk_remove_plug(struct request_queue *); 583 extern void blk_recount_segments(struct request_queue *, struct bio *); 584 extern int scsi_cmd_ioctl(struct file *, struct request_queue *, 585 struct gendisk *, unsigned int, void __user *); 586 extern int sg_scsi_ioctl(struct file *, struct request_queue *, 587 struct gendisk *, struct scsi_ioctl_command __user *); 588 589 /* 590 * Temporary export, until SCSI gets fixed up. 591 */ 592 extern int blk_rq_append_bio(struct request_queue *q, struct request *rq, 593 struct bio *bio); 594 595 /* 596 * A queue has just exitted congestion. Note this in the global counter of 597 * congested queues, and wake up anyone who was waiting for requests to be 598 * put back. 599 */ 600 static inline void blk_clear_queue_congested(struct request_queue *q, int rw) 601 { 602 clear_bdi_congested(&q->backing_dev_info, rw); 603 } 604 605 /* 606 * A queue has just entered congestion. Flag that in the queue's VM-visible 607 * state flags and increment the global gounter of congested queues. 608 */ 609 static inline void blk_set_queue_congested(struct request_queue *q, int rw) 610 { 611 set_bdi_congested(&q->backing_dev_info, rw); 612 } 613 614 extern void blk_start_queue(struct request_queue *q); 615 extern void blk_stop_queue(struct request_queue *q); 616 extern void blk_sync_queue(struct request_queue *q); 617 extern void __blk_stop_queue(struct request_queue *q); 618 extern void blk_run_queue(struct request_queue *); 619 extern void blk_start_queueing(struct request_queue *); 620 extern int blk_rq_map_user(struct request_queue *, struct request *, void __user *, unsigned long); 621 extern int blk_rq_unmap_user(struct bio *); 622 extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t); 623 extern int blk_rq_map_user_iov(struct request_queue *, struct request *, 624 struct sg_iovec *, int, unsigned int); 625 extern int blk_execute_rq(struct request_queue *, struct gendisk *, 626 struct request *, int); 627 extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *, 628 struct request *, int, rq_end_io_fn *); 629 extern int blk_verify_command(unsigned char *, int); 630 extern void blk_unplug(struct request_queue *q); 631 632 static inline struct request_queue *bdev_get_queue(struct block_device *bdev) 633 { 634 return bdev->bd_disk->queue; 635 } 636 637 static inline void blk_run_backing_dev(struct backing_dev_info *bdi, 638 struct page *page) 639 { 640 if (bdi && bdi->unplug_io_fn) 641 bdi->unplug_io_fn(bdi, page); 642 } 643 644 static inline void blk_run_address_space(struct address_space *mapping) 645 { 646 if (mapping) 647 blk_run_backing_dev(mapping->backing_dev_info, NULL); 648 } 649 650 /* 651 * blk_end_request() and friends. 652 * __blk_end_request() and end_request() must be called with 653 * the request queue spinlock acquired. 654 * 655 * Several drivers define their own end_request and call 656 * blk_end_request() for parts of the original function. 657 * This prevents code duplication in drivers. 658 */ 659 extern int blk_end_request(struct request *rq, int error, 660 unsigned int nr_bytes); 661 extern int __blk_end_request(struct request *rq, int error, 662 unsigned int nr_bytes); 663 extern int blk_end_bidi_request(struct request *rq, int error, 664 unsigned int nr_bytes, unsigned int bidi_bytes); 665 extern void end_request(struct request *, int); 666 extern void end_queued_request(struct request *, int); 667 extern void end_dequeued_request(struct request *, int); 668 extern int blk_end_request_callback(struct request *rq, int error, 669 unsigned int nr_bytes, 670 int (drv_callback)(struct request *)); 671 extern void blk_complete_request(struct request *); 672 673 /* 674 * blk_end_request() takes bytes instead of sectors as a complete size. 675 * blk_rq_bytes() returns bytes left to complete in the entire request. 676 * blk_rq_cur_bytes() returns bytes left to complete in the current segment. 677 */ 678 extern unsigned int blk_rq_bytes(struct request *rq); 679 extern unsigned int blk_rq_cur_bytes(struct request *rq); 680 681 static inline void blkdev_dequeue_request(struct request *req) 682 { 683 elv_dequeue_request(req->q, req); 684 } 685 686 /* 687 * Access functions for manipulating queue properties 688 */ 689 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn, 690 spinlock_t *lock, int node_id); 691 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *); 692 extern void blk_cleanup_queue(struct request_queue *); 693 extern void blk_queue_make_request(struct request_queue *, make_request_fn *); 694 extern void blk_queue_bounce_limit(struct request_queue *, u64); 695 extern void blk_queue_max_sectors(struct request_queue *, unsigned int); 696 extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short); 697 extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short); 698 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int); 699 extern void blk_queue_hardsect_size(struct request_queue *, unsigned short); 700 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b); 701 extern int blk_queue_dma_drain(struct request_queue *q, void *buf, 702 unsigned int size); 703 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long); 704 extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn); 705 extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *); 706 extern void blk_queue_dma_alignment(struct request_queue *, int); 707 extern void blk_queue_update_dma_alignment(struct request_queue *, int); 708 extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *); 709 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev); 710 extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *); 711 extern int blk_do_ordered(struct request_queue *, struct request **); 712 extern unsigned blk_ordered_cur_seq(struct request_queue *); 713 extern unsigned blk_ordered_req_seq(struct request *); 714 extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int); 715 716 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *); 717 extern void blk_dump_rq_flags(struct request *, char *); 718 extern void generic_unplug_device(struct request_queue *); 719 extern void __generic_unplug_device(struct request_queue *); 720 extern long nr_blockdev_pages(void); 721 722 int blk_get_queue(struct request_queue *); 723 struct request_queue *blk_alloc_queue(gfp_t); 724 struct request_queue *blk_alloc_queue_node(gfp_t, int); 725 extern void blk_put_queue(struct request_queue *); 726 727 /* 728 * tag stuff 729 */ 730 #define blk_queue_tag_depth(q) ((q)->queue_tags->busy) 731 #define blk_queue_tag_queue(q) ((q)->queue_tags->busy < (q)->queue_tags->max_depth) 732 #define blk_rq_tagged(rq) ((rq)->cmd_flags & REQ_QUEUED) 733 extern int blk_queue_start_tag(struct request_queue *, struct request *); 734 extern struct request *blk_queue_find_tag(struct request_queue *, int); 735 extern void blk_queue_end_tag(struct request_queue *, struct request *); 736 extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *); 737 extern void blk_queue_free_tags(struct request_queue *); 738 extern int blk_queue_resize_tags(struct request_queue *, int); 739 extern void blk_queue_invalidate_tags(struct request_queue *); 740 extern struct blk_queue_tag *blk_init_tags(int); 741 extern void blk_free_tags(struct blk_queue_tag *); 742 743 static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt, 744 int tag) 745 { 746 if (unlikely(bqt == NULL || tag >= bqt->real_max_depth)) 747 return NULL; 748 return bqt->tag_index[tag]; 749 } 750 751 extern int blkdev_issue_flush(struct block_device *, sector_t *); 752 753 #define MAX_PHYS_SEGMENTS 128 754 #define MAX_HW_SEGMENTS 128 755 #define SAFE_MAX_SECTORS 255 756 #define BLK_DEF_MAX_SECTORS 1024 757 758 #define MAX_SEGMENT_SIZE 65536 759 760 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist) 761 762 static inline int queue_hardsect_size(struct request_queue *q) 763 { 764 int retval = 512; 765 766 if (q && q->hardsect_size) 767 retval = q->hardsect_size; 768 769 return retval; 770 } 771 772 static inline int bdev_hardsect_size(struct block_device *bdev) 773 { 774 return queue_hardsect_size(bdev_get_queue(bdev)); 775 } 776 777 static inline int queue_dma_alignment(struct request_queue *q) 778 { 779 return q ? q->dma_alignment : 511; 780 } 781 782 /* assumes size > 256 */ 783 static inline unsigned int blksize_bits(unsigned int size) 784 { 785 unsigned int bits = 8; 786 do { 787 bits++; 788 size >>= 1; 789 } while (size > 256); 790 return bits; 791 } 792 793 static inline unsigned int block_size(struct block_device *bdev) 794 { 795 return bdev->bd_block_size; 796 } 797 798 typedef struct {struct page *v;} Sector; 799 800 unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *); 801 802 static inline void put_dev_sector(Sector p) 803 { 804 page_cache_release(p.v); 805 } 806 807 struct work_struct; 808 int kblockd_schedule_work(struct work_struct *work); 809 void kblockd_flush_work(struct work_struct *work); 810 811 #define MODULE_ALIAS_BLOCKDEV(major,minor) \ 812 MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor)) 813 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \ 814 MODULE_ALIAS("block-major-" __stringify(major) "-*") 815 816 817 #else /* CONFIG_BLOCK */ 818 /* 819 * stubs for when the block layer is configured out 820 */ 821 #define buffer_heads_over_limit 0 822 823 static inline long nr_blockdev_pages(void) 824 { 825 return 0; 826 } 827 828 static inline void exit_io_context(void) 829 { 830 } 831 832 struct io_context; 833 static inline int put_io_context(struct io_context *ioc) 834 { 835 return 1; 836 } 837 838 839 #endif /* CONFIG_BLOCK */ 840 841 #endif 842