1 #ifndef _LINUX_BLKDEV_H 2 #define _LINUX_BLKDEV_H 3 4 #include <linux/sched.h> 5 6 #ifdef CONFIG_BLOCK 7 8 #include <linux/major.h> 9 #include <linux/genhd.h> 10 #include <linux/list.h> 11 #include <linux/timer.h> 12 #include <linux/workqueue.h> 13 #include <linux/pagemap.h> 14 #include <linux/backing-dev.h> 15 #include <linux/wait.h> 16 #include <linux/mempool.h> 17 #include <linux/bio.h> 18 #include <linux/stringify.h> 19 #include <linux/gfp.h> 20 #include <linux/bsg.h> 21 #include <linux/smp.h> 22 23 #include <asm/scatterlist.h> 24 25 struct module; 26 struct scsi_ioctl_command; 27 28 struct request_queue; 29 struct elevator_queue; 30 struct request_pm_state; 31 struct blk_trace; 32 struct request; 33 struct sg_io_hdr; 34 struct bsg_job; 35 36 #define BLKDEV_MIN_RQ 4 37 #define BLKDEV_MAX_RQ 128 /* Default maximum */ 38 39 struct request; 40 typedef void (rq_end_io_fn)(struct request *, int); 41 42 struct request_list { 43 /* 44 * count[], starved[], and wait[] are indexed by 45 * BLK_RW_SYNC/BLK_RW_ASYNC 46 */ 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_SPECIAL, /* driver defined type */ 65 /* 66 * for ATA/ATAPI devices. this really doesn't belong here, ide should 67 * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver 68 * private REQ_LB opcodes to differentiate what type of request this is 69 */ 70 REQ_TYPE_ATA_TASKFILE, 71 REQ_TYPE_ATA_PC, 72 }; 73 74 #define BLK_MAX_CDB 16 75 76 /* 77 * try to put the fields that are referenced together in the same cacheline. 78 * if you modify this structure, be sure to check block/blk-core.c:blk_rq_init() 79 * as well! 80 */ 81 struct request { 82 struct list_head queuelist; 83 struct call_single_data csd; 84 85 struct request_queue *q; 86 87 unsigned int cmd_flags; 88 enum rq_cmd_type_bits cmd_type; 89 unsigned long atomic_flags; 90 91 int cpu; 92 93 /* the following two fields are internal, NEVER access directly */ 94 unsigned int __data_len; /* total data len */ 95 sector_t __sector; /* sector cursor */ 96 97 struct bio *bio; 98 struct bio *biotail; 99 100 struct hlist_node hash; /* merge hash */ 101 /* 102 * The rb_node is only used inside the io scheduler, requests 103 * are pruned when moved to the dispatch queue. So let the 104 * completion_data share space with the rb_node. 105 */ 106 union { 107 struct rb_node rb_node; /* sort/lookup */ 108 void *completion_data; 109 }; 110 111 /* 112 * Three pointers are available for the IO schedulers, if they need 113 * more they have to dynamically allocate it. Flush requests are 114 * never put on the IO scheduler. So let the flush fields share 115 * space with the elevator data. 116 */ 117 union { 118 struct { 119 struct io_cq *icq; 120 void *priv[2]; 121 } elv; 122 123 struct { 124 unsigned int seq; 125 struct list_head list; 126 rq_end_io_fn *saved_end_io; 127 } flush; 128 }; 129 130 struct gendisk *rq_disk; 131 struct hd_struct *part; 132 unsigned long start_time; 133 #ifdef CONFIG_BLK_CGROUP 134 unsigned long long start_time_ns; 135 unsigned long long io_start_time_ns; /* when passed to hardware */ 136 #endif 137 /* Number of scatter-gather DMA addr+len pairs after 138 * physical address coalescing is performed. 139 */ 140 unsigned short nr_phys_segments; 141 #if defined(CONFIG_BLK_DEV_INTEGRITY) 142 unsigned short nr_integrity_segments; 143 #endif 144 145 unsigned short ioprio; 146 147 int ref_count; 148 149 void *special; /* opaque pointer available for LLD use */ 150 char *buffer; /* kaddr of the current segment if available */ 151 152 int tag; 153 int errors; 154 155 /* 156 * when request is used as a packet command carrier 157 */ 158 unsigned char __cmd[BLK_MAX_CDB]; 159 unsigned char *cmd; 160 unsigned short cmd_len; 161 162 unsigned int extra_len; /* length of alignment and padding */ 163 unsigned int sense_len; 164 unsigned int resid_len; /* residual count */ 165 void *sense; 166 167 unsigned long deadline; 168 struct list_head timeout_list; 169 unsigned int timeout; 170 int retries; 171 172 /* 173 * completion callback. 174 */ 175 rq_end_io_fn *end_io; 176 void *end_io_data; 177 178 /* for bidi */ 179 struct request *next_rq; 180 }; 181 182 static inline unsigned short req_get_ioprio(struct request *req) 183 { 184 return req->ioprio; 185 } 186 187 /* 188 * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME 189 * requests. Some step values could eventually be made generic. 190 */ 191 struct request_pm_state 192 { 193 /* PM state machine step value, currently driver specific */ 194 int pm_step; 195 /* requested PM state value (S1, S2, S3, S4, ...) */ 196 u32 pm_state; 197 void* data; /* for driver use */ 198 }; 199 200 #include <linux/elevator.h> 201 202 typedef void (request_fn_proc) (struct request_queue *q); 203 typedef void (make_request_fn) (struct request_queue *q, struct bio *bio); 204 typedef int (prep_rq_fn) (struct request_queue *, struct request *); 205 typedef void (unprep_rq_fn) (struct request_queue *, struct request *); 206 207 struct bio_vec; 208 struct bvec_merge_data { 209 struct block_device *bi_bdev; 210 sector_t bi_sector; 211 unsigned bi_size; 212 unsigned long bi_rw; 213 }; 214 typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *, 215 struct bio_vec *); 216 typedef void (softirq_done_fn)(struct request *); 217 typedef int (dma_drain_needed_fn)(struct request *); 218 typedef int (lld_busy_fn) (struct request_queue *q); 219 typedef int (bsg_job_fn) (struct bsg_job *); 220 221 enum blk_eh_timer_return { 222 BLK_EH_NOT_HANDLED, 223 BLK_EH_HANDLED, 224 BLK_EH_RESET_TIMER, 225 }; 226 227 typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *); 228 229 enum blk_queue_state { 230 Queue_down, 231 Queue_up, 232 }; 233 234 struct blk_queue_tag { 235 struct request **tag_index; /* map of busy tags */ 236 unsigned long *tag_map; /* bit map of free/busy tags */ 237 int busy; /* current depth */ 238 int max_depth; /* what we will send to device */ 239 int real_max_depth; /* what the array can hold */ 240 atomic_t refcnt; /* map can be shared */ 241 }; 242 243 #define BLK_SCSI_MAX_CMDS (256) 244 #define BLK_SCSI_CMD_PER_LONG (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8)) 245 246 struct queue_limits { 247 unsigned long bounce_pfn; 248 unsigned long seg_boundary_mask; 249 250 unsigned int max_hw_sectors; 251 unsigned int max_sectors; 252 unsigned int max_segment_size; 253 unsigned int physical_block_size; 254 unsigned int alignment_offset; 255 unsigned int io_min; 256 unsigned int io_opt; 257 unsigned int max_discard_sectors; 258 unsigned int discard_granularity; 259 unsigned int discard_alignment; 260 261 unsigned short logical_block_size; 262 unsigned short max_segments; 263 unsigned short max_integrity_segments; 264 265 unsigned char misaligned; 266 unsigned char discard_misaligned; 267 unsigned char cluster; 268 unsigned char discard_zeroes_data; 269 }; 270 271 struct request_queue { 272 /* 273 * Together with queue_head for cacheline sharing 274 */ 275 struct list_head queue_head; 276 struct request *last_merge; 277 struct elevator_queue *elevator; 278 279 /* 280 * the queue request freelist, one for reads and one for writes 281 */ 282 struct request_list rq; 283 284 request_fn_proc *request_fn; 285 make_request_fn *make_request_fn; 286 prep_rq_fn *prep_rq_fn; 287 unprep_rq_fn *unprep_rq_fn; 288 merge_bvec_fn *merge_bvec_fn; 289 softirq_done_fn *softirq_done_fn; 290 rq_timed_out_fn *rq_timed_out_fn; 291 dma_drain_needed_fn *dma_drain_needed; 292 lld_busy_fn *lld_busy_fn; 293 294 /* 295 * Dispatch queue sorting 296 */ 297 sector_t end_sector; 298 struct request *boundary_rq; 299 300 /* 301 * Delayed queue handling 302 */ 303 struct delayed_work delay_work; 304 305 struct backing_dev_info backing_dev_info; 306 307 /* 308 * The queue owner gets to use this for whatever they like. 309 * ll_rw_blk doesn't touch it. 310 */ 311 void *queuedata; 312 313 /* 314 * various queue flags, see QUEUE_* below 315 */ 316 unsigned long queue_flags; 317 318 /* 319 * ida allocated id for this queue. Used to index queues from 320 * ioctx. 321 */ 322 int id; 323 324 /* 325 * queue needs bounce pages for pages above this limit 326 */ 327 gfp_t bounce_gfp; 328 329 /* 330 * protects queue structures from reentrancy. ->__queue_lock should 331 * _never_ be used directly, it is queue private. always use 332 * ->queue_lock. 333 */ 334 spinlock_t __queue_lock; 335 spinlock_t *queue_lock; 336 337 /* 338 * queue kobject 339 */ 340 struct kobject kobj; 341 342 /* 343 * queue settings 344 */ 345 unsigned long nr_requests; /* Max # of requests */ 346 unsigned int nr_congestion_on; 347 unsigned int nr_congestion_off; 348 unsigned int nr_batching; 349 350 unsigned int dma_drain_size; 351 void *dma_drain_buffer; 352 unsigned int dma_pad_mask; 353 unsigned int dma_alignment; 354 355 struct blk_queue_tag *queue_tags; 356 struct list_head tag_busy_list; 357 358 unsigned int nr_sorted; 359 unsigned int in_flight[2]; 360 361 unsigned int rq_timeout; 362 struct timer_list timeout; 363 struct list_head timeout_list; 364 365 struct list_head icq_list; 366 367 struct queue_limits limits; 368 369 /* 370 * sg stuff 371 */ 372 unsigned int sg_timeout; 373 unsigned int sg_reserved_size; 374 int node; 375 #ifdef CONFIG_BLK_DEV_IO_TRACE 376 struct blk_trace *blk_trace; 377 #endif 378 /* 379 * for flush operations 380 */ 381 unsigned int flush_flags; 382 unsigned int flush_not_queueable:1; 383 unsigned int flush_queue_delayed:1; 384 unsigned int flush_pending_idx:1; 385 unsigned int flush_running_idx:1; 386 unsigned long flush_pending_since; 387 struct list_head flush_queue[2]; 388 struct list_head flush_data_in_flight; 389 struct request flush_rq; 390 391 struct mutex sysfs_lock; 392 393 #if defined(CONFIG_BLK_DEV_BSG) 394 bsg_job_fn *bsg_job_fn; 395 int bsg_job_size; 396 struct bsg_class_device bsg_dev; 397 #endif 398 399 #ifdef CONFIG_BLK_DEV_THROTTLING 400 /* Throttle data */ 401 struct throtl_data *td; 402 #endif 403 }; 404 405 #define QUEUE_FLAG_QUEUED 1 /* uses generic tag queueing */ 406 #define QUEUE_FLAG_STOPPED 2 /* queue is stopped */ 407 #define QUEUE_FLAG_SYNCFULL 3 /* read queue has been filled */ 408 #define QUEUE_FLAG_ASYNCFULL 4 /* write queue has been filled */ 409 #define QUEUE_FLAG_DEAD 5 /* queue being torn down */ 410 #define QUEUE_FLAG_ELVSWITCH 6 /* don't use elevator, just do FIFO */ 411 #define QUEUE_FLAG_BIDI 7 /* queue supports bidi requests */ 412 #define QUEUE_FLAG_NOMERGES 8 /* disable merge attempts */ 413 #define QUEUE_FLAG_SAME_COMP 9 /* complete on same CPU-group */ 414 #define QUEUE_FLAG_FAIL_IO 10 /* fake timeout */ 415 #define QUEUE_FLAG_STACKABLE 11 /* supports request stacking */ 416 #define QUEUE_FLAG_NONROT 12 /* non-rotational device (SSD) */ 417 #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */ 418 #define QUEUE_FLAG_IO_STAT 13 /* do IO stats */ 419 #define QUEUE_FLAG_DISCARD 14 /* supports DISCARD */ 420 #define QUEUE_FLAG_NOXMERGES 15 /* No extended merges */ 421 #define QUEUE_FLAG_ADD_RANDOM 16 /* Contributes to random pool */ 422 #define QUEUE_FLAG_SECDISCARD 17 /* supports SECDISCARD */ 423 #define QUEUE_FLAG_SAME_FORCE 18 /* force complete on same CPU */ 424 425 #define QUEUE_FLAG_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \ 426 (1 << QUEUE_FLAG_STACKABLE) | \ 427 (1 << QUEUE_FLAG_SAME_COMP) | \ 428 (1 << QUEUE_FLAG_ADD_RANDOM)) 429 430 static inline void queue_lockdep_assert_held(struct request_queue *q) 431 { 432 if (q->queue_lock) 433 lockdep_assert_held(q->queue_lock); 434 } 435 436 static inline void queue_flag_set_unlocked(unsigned int flag, 437 struct request_queue *q) 438 { 439 __set_bit(flag, &q->queue_flags); 440 } 441 442 static inline int queue_flag_test_and_clear(unsigned int flag, 443 struct request_queue *q) 444 { 445 queue_lockdep_assert_held(q); 446 447 if (test_bit(flag, &q->queue_flags)) { 448 __clear_bit(flag, &q->queue_flags); 449 return 1; 450 } 451 452 return 0; 453 } 454 455 static inline int queue_flag_test_and_set(unsigned int flag, 456 struct request_queue *q) 457 { 458 queue_lockdep_assert_held(q); 459 460 if (!test_bit(flag, &q->queue_flags)) { 461 __set_bit(flag, &q->queue_flags); 462 return 0; 463 } 464 465 return 1; 466 } 467 468 static inline void queue_flag_set(unsigned int flag, struct request_queue *q) 469 { 470 queue_lockdep_assert_held(q); 471 __set_bit(flag, &q->queue_flags); 472 } 473 474 static inline void queue_flag_clear_unlocked(unsigned int flag, 475 struct request_queue *q) 476 { 477 __clear_bit(flag, &q->queue_flags); 478 } 479 480 static inline int queue_in_flight(struct request_queue *q) 481 { 482 return q->in_flight[0] + q->in_flight[1]; 483 } 484 485 static inline void queue_flag_clear(unsigned int flag, struct request_queue *q) 486 { 487 queue_lockdep_assert_held(q); 488 __clear_bit(flag, &q->queue_flags); 489 } 490 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) 493 #define blk_queue_dead(q) test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags) 494 #define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags) 495 #define blk_queue_noxmerges(q) \ 496 test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags) 497 #define blk_queue_nonrot(q) test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags) 498 #define blk_queue_io_stat(q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags) 499 #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags) 500 #define blk_queue_stackable(q) \ 501 test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags) 502 #define blk_queue_discard(q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags) 503 #define blk_queue_secdiscard(q) (blk_queue_discard(q) && \ 504 test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags)) 505 506 #define blk_noretry_request(rq) \ 507 ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \ 508 REQ_FAILFAST_DRIVER)) 509 510 #define blk_account_rq(rq) \ 511 (((rq)->cmd_flags & REQ_STARTED) && \ 512 ((rq)->cmd_type == REQ_TYPE_FS || \ 513 ((rq)->cmd_flags & REQ_DISCARD))) 514 515 #define blk_pm_request(rq) \ 516 ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND || \ 517 (rq)->cmd_type == REQ_TYPE_PM_RESUME) 518 519 #define blk_rq_cpu_valid(rq) ((rq)->cpu != -1) 520 #define blk_bidi_rq(rq) ((rq)->next_rq != NULL) 521 /* rq->queuelist of dequeued request must be list_empty() */ 522 #define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist)) 523 524 #define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist) 525 526 #define rq_data_dir(rq) ((rq)->cmd_flags & 1) 527 528 static inline unsigned int blk_queue_cluster(struct request_queue *q) 529 { 530 return q->limits.cluster; 531 } 532 533 /* 534 * We regard a request as sync, if either a read or a sync write 535 */ 536 static inline bool rw_is_sync(unsigned int rw_flags) 537 { 538 return !(rw_flags & REQ_WRITE) || (rw_flags & REQ_SYNC); 539 } 540 541 static inline bool rq_is_sync(struct request *rq) 542 { 543 return rw_is_sync(rq->cmd_flags); 544 } 545 546 static inline int blk_queue_full(struct request_queue *q, int sync) 547 { 548 if (sync) 549 return test_bit(QUEUE_FLAG_SYNCFULL, &q->queue_flags); 550 return test_bit(QUEUE_FLAG_ASYNCFULL, &q->queue_flags); 551 } 552 553 static inline void blk_set_queue_full(struct request_queue *q, int sync) 554 { 555 if (sync) 556 queue_flag_set(QUEUE_FLAG_SYNCFULL, q); 557 else 558 queue_flag_set(QUEUE_FLAG_ASYNCFULL, q); 559 } 560 561 static inline void blk_clear_queue_full(struct request_queue *q, int sync) 562 { 563 if (sync) 564 queue_flag_clear(QUEUE_FLAG_SYNCFULL, q); 565 else 566 queue_flag_clear(QUEUE_FLAG_ASYNCFULL, q); 567 } 568 569 570 /* 571 * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may 572 * it already be started by driver. 573 */ 574 #define RQ_NOMERGE_FLAGS \ 575 (REQ_NOMERGE | REQ_STARTED | REQ_SOFTBARRIER | REQ_FLUSH | REQ_FUA) 576 #define rq_mergeable(rq) \ 577 (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && \ 578 (((rq)->cmd_flags & REQ_DISCARD) || \ 579 (rq)->cmd_type == REQ_TYPE_FS)) 580 581 /* 582 * q->prep_rq_fn return values 583 */ 584 #define BLKPREP_OK 0 /* serve it */ 585 #define BLKPREP_KILL 1 /* fatal error, kill */ 586 #define BLKPREP_DEFER 2 /* leave on queue */ 587 588 extern unsigned long blk_max_low_pfn, blk_max_pfn; 589 590 /* 591 * standard bounce addresses: 592 * 593 * BLK_BOUNCE_HIGH : bounce all highmem pages 594 * BLK_BOUNCE_ANY : don't bounce anything 595 * BLK_BOUNCE_ISA : bounce pages above ISA DMA boundary 596 */ 597 598 #if BITS_PER_LONG == 32 599 #define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT) 600 #else 601 #define BLK_BOUNCE_HIGH -1ULL 602 #endif 603 #define BLK_BOUNCE_ANY (-1ULL) 604 #define BLK_BOUNCE_ISA (DMA_BIT_MASK(24)) 605 606 /* 607 * default timeout for SG_IO if none specified 608 */ 609 #define BLK_DEFAULT_SG_TIMEOUT (60 * HZ) 610 #define BLK_MIN_SG_TIMEOUT (7 * HZ) 611 612 #ifdef CONFIG_BOUNCE 613 extern int init_emergency_isa_pool(void); 614 extern void blk_queue_bounce(struct request_queue *q, struct bio **bio); 615 #else 616 static inline int init_emergency_isa_pool(void) 617 { 618 return 0; 619 } 620 static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio) 621 { 622 } 623 #endif /* CONFIG_MMU */ 624 625 struct rq_map_data { 626 struct page **pages; 627 int page_order; 628 int nr_entries; 629 unsigned long offset; 630 int null_mapped; 631 int from_user; 632 }; 633 634 struct req_iterator { 635 int i; 636 struct bio *bio; 637 }; 638 639 /* This should not be used directly - use rq_for_each_segment */ 640 #define for_each_bio(_bio) \ 641 for (; _bio; _bio = _bio->bi_next) 642 #define __rq_for_each_bio(_bio, rq) \ 643 if ((rq->bio)) \ 644 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next) 645 646 #define rq_for_each_segment(bvl, _rq, _iter) \ 647 __rq_for_each_bio(_iter.bio, _rq) \ 648 bio_for_each_segment(bvl, _iter.bio, _iter.i) 649 650 #define rq_iter_last(rq, _iter) \ 651 (_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1) 652 653 #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 654 # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform" 655 #endif 656 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 657 extern void rq_flush_dcache_pages(struct request *rq); 658 #else 659 static inline void rq_flush_dcache_pages(struct request *rq) 660 { 661 } 662 #endif 663 664 extern int blk_register_queue(struct gendisk *disk); 665 extern void blk_unregister_queue(struct gendisk *disk); 666 extern void generic_make_request(struct bio *bio); 667 extern void blk_rq_init(struct request_queue *q, struct request *rq); 668 extern void blk_put_request(struct request *); 669 extern void __blk_put_request(struct request_queue *, struct request *); 670 extern struct request *blk_get_request(struct request_queue *, int, gfp_t); 671 extern struct request *blk_make_request(struct request_queue *, struct bio *, 672 gfp_t); 673 extern void blk_requeue_request(struct request_queue *, struct request *); 674 extern void blk_add_request_payload(struct request *rq, struct page *page, 675 unsigned int len); 676 extern int blk_rq_check_limits(struct request_queue *q, struct request *rq); 677 extern int blk_lld_busy(struct request_queue *q); 678 extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src, 679 struct bio_set *bs, gfp_t gfp_mask, 680 int (*bio_ctr)(struct bio *, struct bio *, void *), 681 void *data); 682 extern void blk_rq_unprep_clone(struct request *rq); 683 extern int blk_insert_cloned_request(struct request_queue *q, 684 struct request *rq); 685 extern void blk_delay_queue(struct request_queue *, unsigned long); 686 extern void blk_recount_segments(struct request_queue *, struct bio *); 687 extern int scsi_verify_blk_ioctl(struct block_device *, unsigned int); 688 extern int scsi_cmd_blk_ioctl(struct block_device *, fmode_t, 689 unsigned int, void __user *); 690 extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t, 691 unsigned int, void __user *); 692 extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t, 693 struct scsi_ioctl_command __user *); 694 695 extern void blk_queue_bio(struct request_queue *q, struct bio *bio); 696 697 /* 698 * A queue has just exitted congestion. Note this in the global counter of 699 * congested queues, and wake up anyone who was waiting for requests to be 700 * put back. 701 */ 702 static inline void blk_clear_queue_congested(struct request_queue *q, int sync) 703 { 704 clear_bdi_congested(&q->backing_dev_info, sync); 705 } 706 707 /* 708 * A queue has just entered congestion. Flag that in the queue's VM-visible 709 * state flags and increment the global gounter of congested queues. 710 */ 711 static inline void blk_set_queue_congested(struct request_queue *q, int sync) 712 { 713 set_bdi_congested(&q->backing_dev_info, sync); 714 } 715 716 extern void blk_start_queue(struct request_queue *q); 717 extern void blk_stop_queue(struct request_queue *q); 718 extern void blk_sync_queue(struct request_queue *q); 719 extern void __blk_stop_queue(struct request_queue *q); 720 extern void __blk_run_queue(struct request_queue *q); 721 extern void blk_run_queue(struct request_queue *); 722 extern void blk_run_queue_async(struct request_queue *q); 723 extern int blk_rq_map_user(struct request_queue *, struct request *, 724 struct rq_map_data *, void __user *, unsigned long, 725 gfp_t); 726 extern int blk_rq_unmap_user(struct bio *); 727 extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t); 728 extern int blk_rq_map_user_iov(struct request_queue *, struct request *, 729 struct rq_map_data *, struct sg_iovec *, int, 730 unsigned int, gfp_t); 731 extern int blk_execute_rq(struct request_queue *, struct gendisk *, 732 struct request *, int); 733 extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *, 734 struct request *, int, rq_end_io_fn *); 735 736 static inline struct request_queue *bdev_get_queue(struct block_device *bdev) 737 { 738 return bdev->bd_disk->queue; 739 } 740 741 /* 742 * blk_rq_pos() : the current sector 743 * blk_rq_bytes() : bytes left in the entire request 744 * blk_rq_cur_bytes() : bytes left in the current segment 745 * blk_rq_err_bytes() : bytes left till the next error boundary 746 * blk_rq_sectors() : sectors left in the entire request 747 * blk_rq_cur_sectors() : sectors left in the current segment 748 */ 749 static inline sector_t blk_rq_pos(const struct request *rq) 750 { 751 return rq->__sector; 752 } 753 754 static inline unsigned int blk_rq_bytes(const struct request *rq) 755 { 756 return rq->__data_len; 757 } 758 759 static inline int blk_rq_cur_bytes(const struct request *rq) 760 { 761 return rq->bio ? bio_cur_bytes(rq->bio) : 0; 762 } 763 764 extern unsigned int blk_rq_err_bytes(const struct request *rq); 765 766 static inline unsigned int blk_rq_sectors(const struct request *rq) 767 { 768 return blk_rq_bytes(rq) >> 9; 769 } 770 771 static inline unsigned int blk_rq_cur_sectors(const struct request *rq) 772 { 773 return blk_rq_cur_bytes(rq) >> 9; 774 } 775 776 /* 777 * Request issue related functions. 778 */ 779 extern struct request *blk_peek_request(struct request_queue *q); 780 extern void blk_start_request(struct request *rq); 781 extern struct request *blk_fetch_request(struct request_queue *q); 782 783 /* 784 * Request completion related functions. 785 * 786 * blk_update_request() completes given number of bytes and updates 787 * the request without completing it. 788 * 789 * blk_end_request() and friends. __blk_end_request() must be called 790 * with the request queue spinlock acquired. 791 * 792 * Several drivers define their own end_request and call 793 * blk_end_request() for parts of the original function. 794 * This prevents code duplication in drivers. 795 */ 796 extern bool blk_update_request(struct request *rq, int error, 797 unsigned int nr_bytes); 798 extern bool blk_end_request(struct request *rq, int error, 799 unsigned int nr_bytes); 800 extern void blk_end_request_all(struct request *rq, int error); 801 extern bool blk_end_request_cur(struct request *rq, int error); 802 extern bool blk_end_request_err(struct request *rq, int error); 803 extern bool __blk_end_request(struct request *rq, int error, 804 unsigned int nr_bytes); 805 extern void __blk_end_request_all(struct request *rq, int error); 806 extern bool __blk_end_request_cur(struct request *rq, int error); 807 extern bool __blk_end_request_err(struct request *rq, int error); 808 809 extern void blk_complete_request(struct request *); 810 extern void __blk_complete_request(struct request *); 811 extern void blk_abort_request(struct request *); 812 extern void blk_abort_queue(struct request_queue *); 813 extern void blk_unprep_request(struct request *); 814 815 /* 816 * Access functions for manipulating queue properties 817 */ 818 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn, 819 spinlock_t *lock, int node_id); 820 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *); 821 extern struct request_queue *blk_init_allocated_queue(struct request_queue *, 822 request_fn_proc *, spinlock_t *); 823 extern void blk_cleanup_queue(struct request_queue *); 824 extern void blk_queue_make_request(struct request_queue *, make_request_fn *); 825 extern void blk_queue_bounce_limit(struct request_queue *, u64); 826 extern void blk_limits_max_hw_sectors(struct queue_limits *, unsigned int); 827 extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int); 828 extern void blk_queue_max_segments(struct request_queue *, unsigned short); 829 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int); 830 extern void blk_queue_max_discard_sectors(struct request_queue *q, 831 unsigned int max_discard_sectors); 832 extern void blk_queue_logical_block_size(struct request_queue *, unsigned short); 833 extern void blk_queue_physical_block_size(struct request_queue *, unsigned int); 834 extern void blk_queue_alignment_offset(struct request_queue *q, 835 unsigned int alignment); 836 extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min); 837 extern void blk_queue_io_min(struct request_queue *q, unsigned int min); 838 extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt); 839 extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt); 840 extern void blk_set_default_limits(struct queue_limits *lim); 841 extern void blk_set_stacking_limits(struct queue_limits *lim); 842 extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, 843 sector_t offset); 844 extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev, 845 sector_t offset); 846 extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev, 847 sector_t offset); 848 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b); 849 extern void blk_queue_dma_pad(struct request_queue *, unsigned int); 850 extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int); 851 extern int blk_queue_dma_drain(struct request_queue *q, 852 dma_drain_needed_fn *dma_drain_needed, 853 void *buf, unsigned int size); 854 extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn); 855 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long); 856 extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn); 857 extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn); 858 extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *); 859 extern void blk_queue_dma_alignment(struct request_queue *, int); 860 extern void blk_queue_update_dma_alignment(struct request_queue *, int); 861 extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *); 862 extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *); 863 extern void blk_queue_rq_timeout(struct request_queue *, unsigned int); 864 extern void blk_queue_flush(struct request_queue *q, unsigned int flush); 865 extern void blk_queue_flush_queueable(struct request_queue *q, bool queueable); 866 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev); 867 868 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *); 869 extern void blk_dump_rq_flags(struct request *, char *); 870 extern long nr_blockdev_pages(void); 871 872 bool __must_check blk_get_queue(struct request_queue *); 873 struct request_queue *blk_alloc_queue(gfp_t); 874 struct request_queue *blk_alloc_queue_node(gfp_t, int); 875 extern void blk_put_queue(struct request_queue *); 876 877 /* 878 * blk_plug permits building a queue of related requests by holding the I/O 879 * fragments for a short period. This allows merging of sequential requests 880 * into single larger request. As the requests are moved from a per-task list to 881 * the device's request_queue in a batch, this results in improved scalability 882 * as the lock contention for request_queue lock is reduced. 883 * 884 * It is ok not to disable preemption when adding the request to the plug list 885 * or when attempting a merge, because blk_schedule_flush_list() will only flush 886 * the plug list when the task sleeps by itself. For details, please see 887 * schedule() where blk_schedule_flush_plug() is called. 888 */ 889 struct blk_plug { 890 unsigned long magic; /* detect uninitialized use-cases */ 891 struct list_head list; /* requests */ 892 struct list_head cb_list; /* md requires an unplug callback */ 893 unsigned int should_sort; /* list to be sorted before flushing? */ 894 }; 895 #define BLK_MAX_REQUEST_COUNT 16 896 897 struct blk_plug_cb { 898 struct list_head list; 899 void (*callback)(struct blk_plug_cb *); 900 }; 901 902 extern void blk_start_plug(struct blk_plug *); 903 extern void blk_finish_plug(struct blk_plug *); 904 extern void blk_flush_plug_list(struct blk_plug *, bool); 905 906 static inline void blk_flush_plug(struct task_struct *tsk) 907 { 908 struct blk_plug *plug = tsk->plug; 909 910 if (plug) 911 blk_flush_plug_list(plug, false); 912 } 913 914 static inline void blk_schedule_flush_plug(struct task_struct *tsk) 915 { 916 struct blk_plug *plug = tsk->plug; 917 918 if (plug) 919 blk_flush_plug_list(plug, true); 920 } 921 922 static inline bool blk_needs_flush_plug(struct task_struct *tsk) 923 { 924 struct blk_plug *plug = tsk->plug; 925 926 return plug && (!list_empty(&plug->list) || !list_empty(&plug->cb_list)); 927 } 928 929 /* 930 * tag stuff 931 */ 932 #define blk_rq_tagged(rq) ((rq)->cmd_flags & REQ_QUEUED) 933 extern int blk_queue_start_tag(struct request_queue *, struct request *); 934 extern struct request *blk_queue_find_tag(struct request_queue *, int); 935 extern void blk_queue_end_tag(struct request_queue *, struct request *); 936 extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *); 937 extern void blk_queue_free_tags(struct request_queue *); 938 extern int blk_queue_resize_tags(struct request_queue *, int); 939 extern void blk_queue_invalidate_tags(struct request_queue *); 940 extern struct blk_queue_tag *blk_init_tags(int); 941 extern void blk_free_tags(struct blk_queue_tag *); 942 943 static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt, 944 int tag) 945 { 946 if (unlikely(bqt == NULL || tag >= bqt->real_max_depth)) 947 return NULL; 948 return bqt->tag_index[tag]; 949 } 950 951 #define BLKDEV_DISCARD_SECURE 0x01 /* secure discard */ 952 953 extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *); 954 extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector, 955 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags); 956 extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, 957 sector_t nr_sects, gfp_t gfp_mask); 958 static inline int sb_issue_discard(struct super_block *sb, sector_t block, 959 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags) 960 { 961 return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9), 962 nr_blocks << (sb->s_blocksize_bits - 9), 963 gfp_mask, flags); 964 } 965 static inline int sb_issue_zeroout(struct super_block *sb, sector_t block, 966 sector_t nr_blocks, gfp_t gfp_mask) 967 { 968 return blkdev_issue_zeroout(sb->s_bdev, 969 block << (sb->s_blocksize_bits - 9), 970 nr_blocks << (sb->s_blocksize_bits - 9), 971 gfp_mask); 972 } 973 974 extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm); 975 976 enum blk_default_limits { 977 BLK_MAX_SEGMENTS = 128, 978 BLK_SAFE_MAX_SECTORS = 255, 979 BLK_DEF_MAX_SECTORS = 1024, 980 BLK_MAX_SEGMENT_SIZE = 65536, 981 BLK_SEG_BOUNDARY_MASK = 0xFFFFFFFFUL, 982 }; 983 984 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist) 985 986 static inline unsigned long queue_bounce_pfn(struct request_queue *q) 987 { 988 return q->limits.bounce_pfn; 989 } 990 991 static inline unsigned long queue_segment_boundary(struct request_queue *q) 992 { 993 return q->limits.seg_boundary_mask; 994 } 995 996 static inline unsigned int queue_max_sectors(struct request_queue *q) 997 { 998 return q->limits.max_sectors; 999 } 1000 1001 static inline unsigned int queue_max_hw_sectors(struct request_queue *q) 1002 { 1003 return q->limits.max_hw_sectors; 1004 } 1005 1006 static inline unsigned short queue_max_segments(struct request_queue *q) 1007 { 1008 return q->limits.max_segments; 1009 } 1010 1011 static inline unsigned int queue_max_segment_size(struct request_queue *q) 1012 { 1013 return q->limits.max_segment_size; 1014 } 1015 1016 static inline unsigned short queue_logical_block_size(struct request_queue *q) 1017 { 1018 int retval = 512; 1019 1020 if (q && q->limits.logical_block_size) 1021 retval = q->limits.logical_block_size; 1022 1023 return retval; 1024 } 1025 1026 static inline unsigned short bdev_logical_block_size(struct block_device *bdev) 1027 { 1028 return queue_logical_block_size(bdev_get_queue(bdev)); 1029 } 1030 1031 static inline unsigned int queue_physical_block_size(struct request_queue *q) 1032 { 1033 return q->limits.physical_block_size; 1034 } 1035 1036 static inline unsigned int bdev_physical_block_size(struct block_device *bdev) 1037 { 1038 return queue_physical_block_size(bdev_get_queue(bdev)); 1039 } 1040 1041 static inline unsigned int queue_io_min(struct request_queue *q) 1042 { 1043 return q->limits.io_min; 1044 } 1045 1046 static inline int bdev_io_min(struct block_device *bdev) 1047 { 1048 return queue_io_min(bdev_get_queue(bdev)); 1049 } 1050 1051 static inline unsigned int queue_io_opt(struct request_queue *q) 1052 { 1053 return q->limits.io_opt; 1054 } 1055 1056 static inline int bdev_io_opt(struct block_device *bdev) 1057 { 1058 return queue_io_opt(bdev_get_queue(bdev)); 1059 } 1060 1061 static inline int queue_alignment_offset(struct request_queue *q) 1062 { 1063 if (q->limits.misaligned) 1064 return -1; 1065 1066 return q->limits.alignment_offset; 1067 } 1068 1069 static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector) 1070 { 1071 unsigned int granularity = max(lim->physical_block_size, lim->io_min); 1072 unsigned int alignment = (sector << 9) & (granularity - 1); 1073 1074 return (granularity + lim->alignment_offset - alignment) 1075 & (granularity - 1); 1076 } 1077 1078 static inline int bdev_alignment_offset(struct block_device *bdev) 1079 { 1080 struct request_queue *q = bdev_get_queue(bdev); 1081 1082 if (q->limits.misaligned) 1083 return -1; 1084 1085 if (bdev != bdev->bd_contains) 1086 return bdev->bd_part->alignment_offset; 1087 1088 return q->limits.alignment_offset; 1089 } 1090 1091 static inline int queue_discard_alignment(struct request_queue *q) 1092 { 1093 if (q->limits.discard_misaligned) 1094 return -1; 1095 1096 return q->limits.discard_alignment; 1097 } 1098 1099 static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector) 1100 { 1101 unsigned int alignment = (sector << 9) & (lim->discard_granularity - 1); 1102 1103 if (!lim->max_discard_sectors) 1104 return 0; 1105 1106 return (lim->discard_granularity + lim->discard_alignment - alignment) 1107 & (lim->discard_granularity - 1); 1108 } 1109 1110 static inline unsigned int queue_discard_zeroes_data(struct request_queue *q) 1111 { 1112 if (q->limits.max_discard_sectors && q->limits.discard_zeroes_data == 1) 1113 return 1; 1114 1115 return 0; 1116 } 1117 1118 static inline unsigned int bdev_discard_zeroes_data(struct block_device *bdev) 1119 { 1120 return queue_discard_zeroes_data(bdev_get_queue(bdev)); 1121 } 1122 1123 static inline int queue_dma_alignment(struct request_queue *q) 1124 { 1125 return q ? q->dma_alignment : 511; 1126 } 1127 1128 static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr, 1129 unsigned int len) 1130 { 1131 unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask; 1132 return !(addr & alignment) && !(len & alignment); 1133 } 1134 1135 /* assumes size > 256 */ 1136 static inline unsigned int blksize_bits(unsigned int size) 1137 { 1138 unsigned int bits = 8; 1139 do { 1140 bits++; 1141 size >>= 1; 1142 } while (size > 256); 1143 return bits; 1144 } 1145 1146 static inline unsigned int block_size(struct block_device *bdev) 1147 { 1148 return bdev->bd_block_size; 1149 } 1150 1151 static inline bool queue_flush_queueable(struct request_queue *q) 1152 { 1153 return !q->flush_not_queueable; 1154 } 1155 1156 typedef struct {struct page *v;} Sector; 1157 1158 unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *); 1159 1160 static inline void put_dev_sector(Sector p) 1161 { 1162 page_cache_release(p.v); 1163 } 1164 1165 struct work_struct; 1166 int kblockd_schedule_work(struct request_queue *q, struct work_struct *work); 1167 1168 #ifdef CONFIG_BLK_CGROUP 1169 /* 1170 * This should not be using sched_clock(). A real patch is in progress 1171 * to fix this up, until that is in place we need to disable preemption 1172 * around sched_clock() in this function and set_io_start_time_ns(). 1173 */ 1174 static inline void set_start_time_ns(struct request *req) 1175 { 1176 preempt_disable(); 1177 req->start_time_ns = sched_clock(); 1178 preempt_enable(); 1179 } 1180 1181 static inline void set_io_start_time_ns(struct request *req) 1182 { 1183 preempt_disable(); 1184 req->io_start_time_ns = sched_clock(); 1185 preempt_enable(); 1186 } 1187 1188 static inline uint64_t rq_start_time_ns(struct request *req) 1189 { 1190 return req->start_time_ns; 1191 } 1192 1193 static inline uint64_t rq_io_start_time_ns(struct request *req) 1194 { 1195 return req->io_start_time_ns; 1196 } 1197 #else 1198 static inline void set_start_time_ns(struct request *req) {} 1199 static inline void set_io_start_time_ns(struct request *req) {} 1200 static inline uint64_t rq_start_time_ns(struct request *req) 1201 { 1202 return 0; 1203 } 1204 static inline uint64_t rq_io_start_time_ns(struct request *req) 1205 { 1206 return 0; 1207 } 1208 #endif 1209 1210 #define MODULE_ALIAS_BLOCKDEV(major,minor) \ 1211 MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor)) 1212 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \ 1213 MODULE_ALIAS("block-major-" __stringify(major) "-*") 1214 1215 #if defined(CONFIG_BLK_DEV_INTEGRITY) 1216 1217 #define INTEGRITY_FLAG_READ 2 /* verify data integrity on read */ 1218 #define INTEGRITY_FLAG_WRITE 4 /* generate data integrity on write */ 1219 1220 struct blk_integrity_exchg { 1221 void *prot_buf; 1222 void *data_buf; 1223 sector_t sector; 1224 unsigned int data_size; 1225 unsigned short sector_size; 1226 const char *disk_name; 1227 }; 1228 1229 typedef void (integrity_gen_fn) (struct blk_integrity_exchg *); 1230 typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *); 1231 typedef void (integrity_set_tag_fn) (void *, void *, unsigned int); 1232 typedef void (integrity_get_tag_fn) (void *, void *, unsigned int); 1233 1234 struct blk_integrity { 1235 integrity_gen_fn *generate_fn; 1236 integrity_vrfy_fn *verify_fn; 1237 integrity_set_tag_fn *set_tag_fn; 1238 integrity_get_tag_fn *get_tag_fn; 1239 1240 unsigned short flags; 1241 unsigned short tuple_size; 1242 unsigned short sector_size; 1243 unsigned short tag_size; 1244 1245 const char *name; 1246 1247 struct kobject kobj; 1248 }; 1249 1250 extern bool blk_integrity_is_initialized(struct gendisk *); 1251 extern int blk_integrity_register(struct gendisk *, struct blk_integrity *); 1252 extern void blk_integrity_unregister(struct gendisk *); 1253 extern int blk_integrity_compare(struct gendisk *, struct gendisk *); 1254 extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *, 1255 struct scatterlist *); 1256 extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *); 1257 extern int blk_integrity_merge_rq(struct request_queue *, struct request *, 1258 struct request *); 1259 extern int blk_integrity_merge_bio(struct request_queue *, struct request *, 1260 struct bio *); 1261 1262 static inline 1263 struct blk_integrity *bdev_get_integrity(struct block_device *bdev) 1264 { 1265 return bdev->bd_disk->integrity; 1266 } 1267 1268 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk) 1269 { 1270 return disk->integrity; 1271 } 1272 1273 static inline int blk_integrity_rq(struct request *rq) 1274 { 1275 if (rq->bio == NULL) 1276 return 0; 1277 1278 return bio_integrity(rq->bio); 1279 } 1280 1281 static inline void blk_queue_max_integrity_segments(struct request_queue *q, 1282 unsigned int segs) 1283 { 1284 q->limits.max_integrity_segments = segs; 1285 } 1286 1287 static inline unsigned short 1288 queue_max_integrity_segments(struct request_queue *q) 1289 { 1290 return q->limits.max_integrity_segments; 1291 } 1292 1293 #else /* CONFIG_BLK_DEV_INTEGRITY */ 1294 1295 struct bio; 1296 struct block_device; 1297 struct gendisk; 1298 struct blk_integrity; 1299 1300 static inline int blk_integrity_rq(struct request *rq) 1301 { 1302 return 0; 1303 } 1304 static inline int blk_rq_count_integrity_sg(struct request_queue *q, 1305 struct bio *b) 1306 { 1307 return 0; 1308 } 1309 static inline int blk_rq_map_integrity_sg(struct request_queue *q, 1310 struct bio *b, 1311 struct scatterlist *s) 1312 { 1313 return 0; 1314 } 1315 static inline struct blk_integrity *bdev_get_integrity(struct block_device *b) 1316 { 1317 return 0; 1318 } 1319 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk) 1320 { 1321 return NULL; 1322 } 1323 static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b) 1324 { 1325 return 0; 1326 } 1327 static inline int blk_integrity_register(struct gendisk *d, 1328 struct blk_integrity *b) 1329 { 1330 return 0; 1331 } 1332 static inline void blk_integrity_unregister(struct gendisk *d) 1333 { 1334 } 1335 static inline void blk_queue_max_integrity_segments(struct request_queue *q, 1336 unsigned int segs) 1337 { 1338 } 1339 static inline unsigned short queue_max_integrity_segments(struct request_queue *q) 1340 { 1341 return 0; 1342 } 1343 static inline int blk_integrity_merge_rq(struct request_queue *rq, 1344 struct request *r1, 1345 struct request *r2) 1346 { 1347 return 0; 1348 } 1349 static inline int blk_integrity_merge_bio(struct request_queue *rq, 1350 struct request *r, 1351 struct bio *b) 1352 { 1353 return 0; 1354 } 1355 static inline bool blk_integrity_is_initialized(struct gendisk *g) 1356 { 1357 return 0; 1358 } 1359 1360 #endif /* CONFIG_BLK_DEV_INTEGRITY */ 1361 1362 struct block_device_operations { 1363 int (*open) (struct block_device *, fmode_t); 1364 int (*release) (struct gendisk *, fmode_t); 1365 int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); 1366 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); 1367 int (*direct_access) (struct block_device *, sector_t, 1368 void **, unsigned long *); 1369 unsigned int (*check_events) (struct gendisk *disk, 1370 unsigned int clearing); 1371 /* ->media_changed() is DEPRECATED, use ->check_events() instead */ 1372 int (*media_changed) (struct gendisk *); 1373 void (*unlock_native_capacity) (struct gendisk *); 1374 int (*revalidate_disk) (struct gendisk *); 1375 int (*getgeo)(struct block_device *, struct hd_geometry *); 1376 /* this callback is with swap_lock and sometimes page table lock held */ 1377 void (*swap_slot_free_notify) (struct block_device *, unsigned long); 1378 struct module *owner; 1379 }; 1380 1381 extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int, 1382 unsigned long); 1383 #else /* CONFIG_BLOCK */ 1384 /* 1385 * stubs for when the block layer is configured out 1386 */ 1387 #define buffer_heads_over_limit 0 1388 1389 static inline long nr_blockdev_pages(void) 1390 { 1391 return 0; 1392 } 1393 1394 struct blk_plug { 1395 }; 1396 1397 static inline void blk_start_plug(struct blk_plug *plug) 1398 { 1399 } 1400 1401 static inline void blk_finish_plug(struct blk_plug *plug) 1402 { 1403 } 1404 1405 static inline void blk_flush_plug(struct task_struct *task) 1406 { 1407 } 1408 1409 static inline void blk_schedule_flush_plug(struct task_struct *task) 1410 { 1411 } 1412 1413 1414 static inline bool blk_needs_flush_plug(struct task_struct *tsk) 1415 { 1416 return false; 1417 } 1418 1419 #endif /* CONFIG_BLOCK */ 1420 1421 #endif 1422