include/linux/blkdev.h

   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/llist.h>
  12 #include <linux/timer.h>
  13 #include <linux/workqueue.h>
  14 #include <linux/pagemap.h>
  15 #include <linux/backing-dev-defs.h>
  16 #include <linux/wait.h>
  17 #include <linux/mempool.h>
  18 #include <linux/bio.h>
  19 #include <linux/stringify.h>
  20 #include <linux/gfp.h>
  21 #include <linux/bsg.h>
  22 #include <linux/smp.h>
  23 #include <linux/rcupdate.h>
  24 #include <linux/percpu-refcount.h>
  25 #include <linux/scatterlist.h>
  26
  27 struct module;
  28 struct scsi_ioctl_command;
  29
  30 struct request_queue;
  31 struct elevator_queue;
  32 struct blk_trace;
  33 struct request;
  34 struct sg_io_hdr;
  35 struct bsg_job;
  36 struct blkcg_gq;
  37 struct blk_flush_queue;
  38 struct pr_ops;
  39
  40 #define BLKDEV_MIN_RQ   4
  41 #define BLKDEV_MAX_RQ   128     /* Default maximum */
  42
  43 /*
  44  * Maximum number of blkcg policies allowed to be registered concurrently.
  45  * Defined here to simplify include dependency.
  46  */
  47 #define BLKCG_MAX_POLS          2
  48
  49 struct request;
  50 typedef void (rq_end_io_fn)(struct request *, int);
  51
  52 #define BLK_RL_SYNCFULL         (1U << 0)
  53 #define BLK_RL_ASYNCFULL        (1U << 1)
  54
  55 struct request_list {
  56         struct request_queue    *q;     /* the queue this rl belongs to */
  57 #ifdef CONFIG_BLK_CGROUP
  58         struct blkcg_gq         *blkg;  /* blkg this request pool belongs to */
  59 #endif
  60         /*
  61          * count[], starved[], and wait[] are indexed by
  62          * BLK_RW_SYNC/BLK_RW_ASYNC
  63          */
  64         int                     count[2];
  65         int                     starved[2];
  66         mempool_t               *rq_pool;
  67         wait_queue_head_t       wait[2];
  68         unsigned int            flags;
  69 };
  70
  71 /*
  72  * request command types
  73  */
  74 enum rq_cmd_type_bits {
  75         REQ_TYPE_FS             = 1,    /* fs request */
  76         REQ_TYPE_BLOCK_PC,              /* scsi command */
  77         REQ_TYPE_DRV_PRIV,              /* driver defined types from here */
  78 };
  79
  80 #define BLK_MAX_CDB     16
  81
  82 /*
  83  * Try to put the fields that are referenced together in the same cacheline.
  84  *
  85  * If you modify this structure, make sure to update blk_rq_init() and
  86  * especially blk_mq_rq_ctx_init() to take care of the added fields.
  87  */
  88 struct request {
  89         struct list_head queuelist;
  90         union {
  91                 struct call_single_data csd;
  92                 unsigned long fifo_time;
  93         };
  94
  95         struct request_queue *q;
  96         struct blk_mq_ctx *mq_ctx;
  97
  98         u64 cmd_flags;
  99         unsigned cmd_type;
 100         unsigned long atomic_flags;
 101
 102         int cpu;
 103
 104         /* the following two fields are internal, NEVER access directly */
 105         unsigned int __data_len;        /* total data len */
 106         sector_t __sector;              /* sector cursor */
 107
 108         struct bio *bio;
 109         struct bio *biotail;
 110
 111         /*
 112          * The hash is used inside the scheduler, and killed once the
 113          * request reaches the dispatch list. The ipi_list is only used
 114          * to queue the request for softirq completion, which is long
 115          * after the request has been unhashed (and even removed from
 116          * the dispatch list).
 117          */
 118         union {
 119                 struct hlist_node hash; /* merge hash */
 120                 struct list_head ipi_list;
 121         };
 122
 123         /*
 124          * The rb_node is only used inside the io scheduler, requests
 125          * are pruned when moved to the dispatch queue. So let the
 126          * completion_data share space with the rb_node.
 127          */
 128         union {
 129                 struct rb_node rb_node; /* sort/lookup */
 130                 void *completion_data;
 131         };
 132
 133         /*
 134          * Three pointers are available for the IO schedulers, if they need
 135          * more they have to dynamically allocate it.  Flush requests are
 136          * never put on the IO scheduler. So let the flush fields share
 137          * space with the elevator data.
 138          */
 139         union {
 140                 struct {
 141                         struct io_cq            *icq;
 142                         void                    *priv[2];
 143                 } elv;
 144
 145                 struct {
 146                         unsigned int            seq;
 147                         struct list_head        list;
 148                         rq_end_io_fn            *saved_end_io;
 149                 } flush;
 150         };
 151
 152         struct gendisk *rq_disk;
 153         struct hd_struct *part;
 154         unsigned long start_time;
 155 #ifdef CONFIG_BLK_CGROUP
 156         struct request_list *rl;                /* rl this rq is alloced from */
 157         unsigned long long start_time_ns;
 158         unsigned long long io_start_time_ns;    /* when passed to hardware */
 159 #endif
 160         /* Number of scatter-gather DMA addr+len pairs after
 161          * physical address coalescing is performed.
 162          */
 163         unsigned short nr_phys_segments;
 164 #if defined(CONFIG_BLK_DEV_INTEGRITY)
 165         unsigned short nr_integrity_segments;
 166 #endif
 167
 168         unsigned short ioprio;
 169
 170         void *special;          /* opaque pointer available for LLD use */
 171
 172         int tag;
 173         int errors;
 174
 175         /*
 176          * when request is used as a packet command carrier
 177          */
 178         unsigned char __cmd[BLK_MAX_CDB];
 179         unsigned char *cmd;
 180         unsigned short cmd_len;
 181
 182         unsigned int extra_len; /* length of alignment and padding */
 183         unsigned int sense_len;
 184         unsigned int resid_len; /* residual count */
 185         void *sense;
 186
 187         unsigned long deadline;
 188         struct list_head timeout_list;
 189         unsigned int timeout;
 190         int retries;
 191
 192         /*
 193          * completion callback.
 194          */
 195         rq_end_io_fn *end_io;
 196         void *end_io_data;
 197
 198         /* for bidi */
 199         struct request *next_rq;
 200
 201         ktime_t                 lat_hist_io_start;
 202         int                     lat_hist_enabled;
 203 };
 204
 205 static inline bool blk_rq_is_passthrough(struct request *rq)
 206 {
 207         return rq->cmd_type != REQ_TYPE_FS;
 208 }
 209
 210 static inline unsigned short req_get_ioprio(struct request *req)
 211 {
 212         return req->ioprio;
 213 }
 214
 215 #include <linux/elevator.h>
 216
 217 struct blk_queue_ctx;
 218
 219 typedef void (request_fn_proc) (struct request_queue *q);
 220 typedef blk_qc_t (make_request_fn) (struct request_queue *q, struct bio *bio);
 221 typedef int (prep_rq_fn) (struct request_queue *, struct request *);
 222 typedef void (unprep_rq_fn) (struct request_queue *, struct request *);
 223
 224 struct bio_vec;
 225 typedef void (softirq_done_fn)(struct request *);
 226 typedef int (dma_drain_needed_fn)(struct request *);
 227 typedef int (lld_busy_fn) (struct request_queue *q);
 228 typedef int (bsg_job_fn) (struct bsg_job *);
 229
 230 enum blk_eh_timer_return {
 231         BLK_EH_NOT_HANDLED,
 232         BLK_EH_HANDLED,
 233         BLK_EH_RESET_TIMER,
 234 };
 235
 236 typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *);
 237
 238 enum blk_queue_state {
 239         Queue_down,
 240         Queue_up,
 241 };
 242
 243 struct blk_queue_tag {
 244         struct request **tag_index;     /* map of busy tags */
 245         unsigned long *tag_map;         /* bit map of free/busy tags */
 246         int busy;                       /* current depth */
 247         int max_depth;                  /* what we will send to device */
 248         int real_max_depth;             /* what the array can hold */
 249         atomic_t refcnt;                /* map can be shared */
 250         int alloc_policy;               /* tag allocation policy */
 251         int next_tag;                   /* next tag */
 252 };
 253 #define BLK_TAG_ALLOC_FIFO 0 /* allocate starting from 0 */
 254 #define BLK_TAG_ALLOC_RR 1 /* allocate starting from last allocated tag */
 255
 256 #define BLK_SCSI_MAX_CMDS       (256)
 257 #define BLK_SCSI_CMD_PER_LONG   (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
 258
 259 struct queue_limits {
 260         unsigned long           bounce_pfn;
 261         unsigned long           seg_boundary_mask;
 262         unsigned long           virt_boundary_mask;
 263
 264         unsigned int            max_hw_sectors;
 265         unsigned int            max_dev_sectors;
 266         unsigned int            chunk_sectors;
 267         unsigned int            max_sectors;
 268         unsigned int            max_segment_size;
 269         unsigned int            physical_block_size;
 270         unsigned int            alignment_offset;
 271         unsigned int            io_min;
 272         unsigned int            io_opt;
 273         unsigned int            max_discard_sectors;
 274         unsigned int            max_hw_discard_sectors;
 275         unsigned int            max_write_same_sectors;
 276         unsigned int            discard_granularity;
 277         unsigned int            discard_alignment;
 278
 279         unsigned short          logical_block_size;
 280         unsigned short          max_segments;
 281         unsigned short          max_integrity_segments;
 282
 283         unsigned char           misaligned;
 284         unsigned char           discard_misaligned;
 285         unsigned char           cluster;
 286         unsigned char           discard_zeroes_data;
 287         unsigned char           raid_partial_stripes_expensive;
 288 };
 289
 290 struct request_queue {
 291         /*
 292          * Together with queue_head for cacheline sharing
 293          */
 294         struct list_head        queue_head;
 295         struct request          *last_merge;
 296         struct elevator_queue   *elevator;
 297         int                     nr_rqs[2];      /* # allocated [a]sync rqs */
 298         int                     nr_rqs_elvpriv; /* # allocated rqs w/ elvpriv */
 299
 300         /*
 301          * If blkcg is not used, @q->root_rl serves all requests.  If blkcg
 302          * is used, root blkg allocates from @q->root_rl and all other
 303          * blkgs from their own blkg->rl.  Which one to use should be
 304          * determined using bio_request_list().
 305          */
 306         struct request_list     root_rl;
 307
 308         request_fn_proc         *request_fn;
 309         make_request_fn         *make_request_fn;
 310         prep_rq_fn              *prep_rq_fn;
 311         unprep_rq_fn            *unprep_rq_fn;
 312         softirq_done_fn         *softirq_done_fn;
 313         rq_timed_out_fn         *rq_timed_out_fn;
 314         dma_drain_needed_fn     *dma_drain_needed;
 315         lld_busy_fn             *lld_busy_fn;
 316
 317         struct blk_mq_ops       *mq_ops;
 318
 319         unsigned int            *mq_map;
 320
 321         /* sw queues */
 322         struct blk_mq_ctx __percpu      *queue_ctx;
 323         unsigned int            nr_queues;
 324
 325         /* hw dispatch queues */
 326         struct blk_mq_hw_ctx    **queue_hw_ctx;
 327         unsigned int            nr_hw_queues;
 328
 329         /*
 330          * Dispatch queue sorting
 331          */
 332         sector_t                end_sector;
 333         struct request          *boundary_rq;
 334
 335         /*
 336          * Delayed queue handling
 337          */
 338         struct delayed_work     delay_work;
 339
 340         struct backing_dev_info *backing_dev_info;
 341
 342         /*
 343          * The queue owner gets to use this for whatever they like.
 344          * ll_rw_blk doesn't touch it.
 345          */
 346         void                    *queuedata;
 347
 348         /*
 349          * various queue flags, see QUEUE_* below
 350          */
 351         unsigned long           queue_flags;
 352
 353         /*
 354          * ida allocated id for this queue.  Used to index queues from
 355          * ioctx.
 356          */
 357         int                     id;
 358
 359         /*
 360          * queue needs bounce pages for pages above this limit
 361          */
 362         gfp_t                   bounce_gfp;
 363
 364         /*
 365          * protects queue structures from reentrancy. ->__queue_lock should
 366          * _never_ be used directly, it is queue private. always use
 367          * ->queue_lock.
 368          */
 369         spinlock_t              __queue_lock;
 370         spinlock_t              *queue_lock;
 371
 372         /*
 373          * queue kobject
 374          */
 375         struct kobject kobj;
 376
 377         /*
 378          * mq queue kobject
 379          */
 380         struct kobject mq_kobj;
 381
 382 #ifdef  CONFIG_BLK_DEV_INTEGRITY
 383         struct blk_integrity integrity;
 384 #endif  /* CONFIG_BLK_DEV_INTEGRITY */
 385
 386 #ifdef CONFIG_PM
 387         struct device           *dev;
 388         int                     rpm_status;
 389         unsigned int            nr_pending;
 390 #endif
 391
 392         /*
 393          * queue settings
 394          */
 395         unsigned long           nr_requests;    /* Max # of requests */
 396         unsigned int            nr_congestion_on;
 397         unsigned int            nr_congestion_off;
 398         unsigned int            nr_batching;
 399
 400         unsigned int            dma_drain_size;
 401         void                    *dma_drain_buffer;
 402         unsigned int            dma_pad_mask;
 403         unsigned int            dma_alignment;
 404
 405         struct blk_queue_tag    *queue_tags;
 406         struct list_head        tag_busy_list;
 407
 408         unsigned int            nr_sorted;
 409         unsigned int            in_flight[2];
 410         /*
 411          * Number of active block driver functions for which blk_drain_queue()
 412          * must wait. Must be incremented around functions that unlock the
 413          * queue_lock internally, e.g. scsi_request_fn().
 414          */
 415         unsigned int            request_fn_active;
 416
 417         unsigned int            rq_timeout;
 418         struct timer_list       timeout;
 419         struct list_head        timeout_list;
 420
 421         struct list_head        icq_list;
 422 #ifdef CONFIG_BLK_CGROUP
 423         DECLARE_BITMAP          (blkcg_pols, BLKCG_MAX_POLS);
 424         struct blkcg_gq         *root_blkg;
 425         struct list_head        blkg_list;
 426 #endif
 427
 428         struct queue_limits     limits;
 429
 430         /*
 431          * sg stuff
 432          */
 433         unsigned int            sg_timeout;
 434         unsigned int            sg_reserved_size;
 435         int                     node;
 436 #ifdef CONFIG_BLK_DEV_IO_TRACE
 437         struct blk_trace        *blk_trace;
 438 #endif
 439         /*
 440          * for flush operations
 441          */
 442         unsigned int            flush_flags;
 443         unsigned int            flush_not_queueable:1;
 444         struct blk_flush_queue  *fq;
 445
 446         struct list_head        requeue_list;
 447         spinlock_t              requeue_lock;
 448         struct work_struct      requeue_work;
 449
 450         struct mutex            sysfs_lock;
 451
 452         int                     bypass_depth;
 453         atomic_t                mq_freeze_depth;
 454
 455 #if defined(CONFIG_BLK_DEV_BSG)
 456         bsg_job_fn              *bsg_job_fn;
 457         int                     bsg_job_size;
 458         struct bsg_class_device bsg_dev;
 459 #endif
 460
 461 #ifdef CONFIG_BLK_DEV_THROTTLING
 462         /* Throttle data */
 463         struct throtl_data *td;
 464 #endif
 465         struct rcu_head         rcu_head;
 466         wait_queue_head_t       mq_freeze_wq;
 467         struct percpu_ref       q_usage_counter;
 468         struct list_head        all_q_node;
 469
 470         struct blk_mq_tag_set   *tag_set;
 471         struct list_head        tag_set_list;
 472         struct bio_set          *bio_split;
 473
 474         bool                    mq_sysfs_init_done;
 475 };
 476
 477 #define QUEUE_FLAG_QUEUED       1       /* uses generic tag queueing */
 478 #define QUEUE_FLAG_STOPPED      2       /* queue is stopped */
 479 #define QUEUE_FLAG_SYNCFULL     3       /* read queue has been filled */
 480 #define QUEUE_FLAG_ASYNCFULL    4       /* write queue has been filled */
 481 #define QUEUE_FLAG_DYING        5       /* queue being torn down */
 482 #define QUEUE_FLAG_BYPASS       6       /* act as dumb FIFO queue */
 483 #define QUEUE_FLAG_BIDI         7       /* queue supports bidi requests */
 484 #define QUEUE_FLAG_NOMERGES     8       /* disable merge attempts */
 485 #define QUEUE_FLAG_SAME_COMP    9       /* complete on same CPU-group */
 486 #define QUEUE_FLAG_FAIL_IO     10       /* fake timeout */
 487 #define QUEUE_FLAG_STACKABLE   11       /* supports request stacking */
 488 #define QUEUE_FLAG_NONROT      12       /* non-rotational device (SSD) */
 489 #define QUEUE_FLAG_VIRT        QUEUE_FLAG_NONROT /* paravirt device */
 490 #define QUEUE_FLAG_IO_STAT     13       /* do IO stats */
 491 #define QUEUE_FLAG_DISCARD     14       /* supports DISCARD */
 492 #define QUEUE_FLAG_NOXMERGES   15       /* No extended merges */
 493 #define QUEUE_FLAG_ADD_RANDOM  16       /* Contributes to random pool */
 494 #define QUEUE_FLAG_SECDISCARD  17       /* supports SECDISCARD */
 495 #define QUEUE_FLAG_SAME_FORCE  18       /* force complete on same CPU */
 496 #define QUEUE_FLAG_DEAD        19       /* queue tear-down finished */
 497 #define QUEUE_FLAG_INIT_DONE   20       /* queue is initialized */
 498 #define QUEUE_FLAG_NO_SG_MERGE 21       /* don't attempt to merge SG segments*/
 499 #define QUEUE_FLAG_POLL        22       /* IO polling enabled if set */
 500 #define QUEUE_FLAG_FAST        23       /* fast block device (e.g. ram based) */
 501
 502 #define QUEUE_FLAG_DEFAULT      ((1 << QUEUE_FLAG_IO_STAT) |            \
 503                                  (1 << QUEUE_FLAG_STACKABLE)    |       \
 504                                  (1 << QUEUE_FLAG_SAME_COMP)    |       \
 505                                  (1 << QUEUE_FLAG_ADD_RANDOM))
 506
 507 #define QUEUE_FLAG_MQ_DEFAULT   ((1 << QUEUE_FLAG_IO_STAT) |            \
 508                                  (1 << QUEUE_FLAG_STACKABLE)    |       \
 509                                  (1 << QUEUE_FLAG_SAME_COMP))
 510
 511 static inline void queue_lockdep_assert_held(struct request_queue *q)
 512 {
 513         if (q->queue_lock)
 514                 lockdep_assert_held(q->queue_lock);
 515 }
 516
 517 static inline void queue_flag_set_unlocked(unsigned int flag,
 518                                            struct request_queue *q)
 519 {
 520         __set_bit(flag, &q->queue_flags);
 521 }
 522
 523 static inline int queue_flag_test_and_clear(unsigned int flag,
 524                                             struct request_queue *q)
 525 {
 526         queue_lockdep_assert_held(q);
 527
 528         if (test_bit(flag, &q->queue_flags)) {
 529                 __clear_bit(flag, &q->queue_flags);
 530                 return 1;
 531         }
 532
 533         return 0;
 534 }
 535
 536 static inline int queue_flag_test_and_set(unsigned int flag,
 537                                           struct request_queue *q)
 538 {
 539         queue_lockdep_assert_held(q);
 540
 541         if (!test_bit(flag, &q->queue_flags)) {
 542                 __set_bit(flag, &q->queue_flags);
 543                 return 0;
 544         }
 545
 546         return 1;
 547 }
 548
 549 static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
 550 {
 551         queue_lockdep_assert_held(q);
 552         __set_bit(flag, &q->queue_flags);
 553 }
 554
 555 static inline void queue_flag_clear_unlocked(unsigned int flag,
 556                                              struct request_queue *q)
 557 {
 558         __clear_bit(flag, &q->queue_flags);
 559 }
 560
 561 static inline int queue_in_flight(struct request_queue *q)
 562 {
 563         return q->in_flight[0] + q->in_flight[1];
 564 }
 565
 566 static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
 567 {
 568         queue_lockdep_assert_held(q);
 569         __clear_bit(flag, &q->queue_flags);
 570 }
 571
 572 #define blk_queue_tagged(q)     test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
 573 #define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
 574 #define blk_queue_dying(q)      test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags)
 575 #define blk_queue_dead(q)       test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags)
 576 #define blk_queue_bypass(q)     test_bit(QUEUE_FLAG_BYPASS, &(q)->queue_flags)
 577 #define blk_queue_init_done(q)  test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags)
 578 #define blk_queue_nomerges(q)   test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
 579 #define blk_queue_noxmerges(q)  \
 580         test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
 581 #define blk_queue_nonrot(q)     test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
 582 #define blk_queue_io_stat(q)    test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
 583 #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
 584 #define blk_queue_stackable(q)  \
 585         test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
 586 #define blk_queue_discard(q)    test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
 587 #define blk_queue_secdiscard(q) (blk_queue_discard(q) && \
 588         test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
 589 #define blk_queue_fast(q)       test_bit(QUEUE_FLAG_FAST, &(q)->queue_flags)
 590
 591 #define blk_noretry_request(rq) \
 592         ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
 593                              REQ_FAILFAST_DRIVER))
 594
 595 static inline bool blk_account_rq(struct request *rq)
 596 {
 597         return (rq->cmd_flags & REQ_STARTED) && !blk_rq_is_passthrough(rq);
 598 }
 599
 600 #define blk_rq_cpu_valid(rq)    ((rq)->cpu != -1)
 601 #define blk_bidi_rq(rq)         ((rq)->next_rq != NULL)
 602 /* rq->queuelist of dequeued request must be list_empty() */
 603 #define blk_queued_rq(rq)       (!list_empty(&(rq)->queuelist))
 604
 605 #define list_entry_rq(ptr)      list_entry((ptr), struct request, queuelist)
 606
 607 #define rq_data_dir(rq)         ((int)((rq)->cmd_flags & 1))
 608
 609 /*
 610  * Driver can handle struct request, if it either has an old style
 611  * request_fn defined, or is blk-mq based.
 612  */
 613 static inline bool queue_is_rq_based(struct request_queue *q)
 614 {
 615         return q->request_fn || q->mq_ops;
 616 }
 617
 618 static inline unsigned int blk_queue_cluster(struct request_queue *q)
 619 {
 620         return q->limits.cluster;
 621 }
 622
 623 /*
 624  * We regard a request as sync, if either a read or a sync write
 625  */
 626 static inline bool rw_is_sync(unsigned int rw_flags)
 627 {
 628         return !(rw_flags & REQ_WRITE) || (rw_flags & REQ_SYNC);
 629 }
 630
 631 static inline bool rq_is_sync(struct request *rq)
 632 {
 633         return rw_is_sync(rq->cmd_flags);
 634 }
 635
 636 static inline bool blk_rl_full(struct request_list *rl, bool sync)
 637 {
 638         unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
 639
 640         return rl->flags & flag;
 641 }
 642
 643 static inline void blk_set_rl_full(struct request_list *rl, bool sync)
 644 {
 645         unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
 646
 647         rl->flags |= flag;
 648 }
 649
 650 static inline void blk_clear_rl_full(struct request_list *rl, bool sync)
 651 {
 652         unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
 653
 654         rl->flags &= ~flag;
 655 }
 656
 657 static inline bool rq_mergeable(struct request *rq)
 658 {
 659         if (blk_rq_is_passthrough(rq))
 660                 return false;
 661
 662         if (rq->cmd_flags & REQ_NOMERGE_FLAGS)
 663                 return false;
 664
 665         return true;
 666 }
 667
 668 static inline bool blk_check_merge_flags(unsigned int flags1,
 669                                          unsigned int flags2)
 670 {
 671         if ((flags1 & REQ_DISCARD) != (flags2 & REQ_DISCARD))
 672                 return false;
 673
 674         if ((flags1 & REQ_SECURE) != (flags2 & REQ_SECURE))
 675                 return false;
 676
 677         if ((flags1 & REQ_WRITE_SAME) != (flags2 & REQ_WRITE_SAME))
 678                 return false;
 679
 680         return true;
 681 }
 682
 683 static inline bool blk_write_same_mergeable(struct bio *a, struct bio *b)
 684 {
 685         if (bio_data(a) == bio_data(b))
 686                 return true;
 687
 688         return false;
 689 }
 690
 691 /*
 692  * q->prep_rq_fn return values
 693  */
 694 #define BLKPREP_OK              0       /* serve it */
 695 #define BLKPREP_KILL            1       /* fatal error, kill */
 696 #define BLKPREP_DEFER           2       /* leave on queue */
 697
 698 extern unsigned long blk_max_low_pfn, blk_max_pfn;
 699
 700 /*
 701  * standard bounce addresses:
 702  *
 703  * BLK_BOUNCE_HIGH      : bounce all highmem pages
 704  * BLK_BOUNCE_ANY       : don't bounce anything
 705  * BLK_BOUNCE_ISA       : bounce pages above ISA DMA boundary
 706  */
 707
 708 #if BITS_PER_LONG == 32
 709 #define BLK_BOUNCE_HIGH         ((u64)blk_max_low_pfn << PAGE_SHIFT)
 710 #else
 711 #define BLK_BOUNCE_HIGH         -1ULL
 712 #endif
 713 #define BLK_BOUNCE_ANY          (-1ULL)
 714 #define BLK_BOUNCE_ISA          (DMA_BIT_MASK(24))
 715
 716 /*
 717  * default timeout for SG_IO if none specified
 718  */
 719 #define BLK_DEFAULT_SG_TIMEOUT  (60 * HZ)
 720 #define BLK_MIN_SG_TIMEOUT      (7 * HZ)
 721
 722 #ifdef CONFIG_BOUNCE
 723 extern int init_emergency_isa_pool(void);
 724 extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
 725 #else
 726 static inline int init_emergency_isa_pool(void)
 727 {
 728         return 0;
 729 }
 730 static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
 731 {
 732 }
 733 #endif /* CONFIG_MMU */
 734
 735 struct rq_map_data {
 736         struct page **pages;
 737         int page_order;
 738         int nr_entries;
 739         unsigned long offset;
 740         int null_mapped;
 741         int from_user;
 742 };
 743
 744 struct req_iterator {
 745         struct bvec_iter iter;
 746         struct bio *bio;
 747 };
 748
 749 /* This should not be used directly - use rq_for_each_segment */
 750 #define for_each_bio(_bio)              \
 751         for (; _bio; _bio = _bio->bi_next)
 752 #define __rq_for_each_bio(_bio, rq)     \
 753         if ((rq->bio))                  \
 754                 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
 755
 756 #define rq_for_each_segment(bvl, _rq, _iter)                    \
 757         __rq_for_each_bio(_iter.bio, _rq)                       \
 758                 bio_for_each_segment(bvl, _iter.bio, _iter.iter)
 759
 760 #define rq_iter_last(bvec, _iter)                               \
 761                 (_iter.bio->bi_next == NULL &&                  \
 762                  bio_iter_last(bvec, _iter.iter))
 763
 764 #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
 765 # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
 766 #endif
 767 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
 768 extern void rq_flush_dcache_pages(struct request *rq);
 769 #else
 770 static inline void rq_flush_dcache_pages(struct request *rq)
 771 {
 772 }
 773 #endif
 774
 775 extern int blk_register_queue(struct gendisk *disk);
 776 extern void blk_unregister_queue(struct gendisk *disk);
 777 extern blk_qc_t generic_make_request(struct bio *bio);
 778 extern void blk_rq_init(struct request_queue *q, struct request *rq);
 779 extern void blk_put_request(struct request *);
 780 extern void __blk_put_request(struct request_queue *, struct request *);
 781 extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
 782 extern struct request *blk_make_request(struct request_queue *, struct bio *,
 783                                         gfp_t);
 784 extern void blk_rq_set_block_pc(struct request *);
 785 extern void blk_requeue_request(struct request_queue *, struct request *);
 786 extern void blk_add_request_payload(struct request *rq, struct page *page,
 787                 unsigned int len);
 788 extern int blk_lld_busy(struct request_queue *q);
 789 extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
 790                              struct bio_set *bs, gfp_t gfp_mask,
 791                              int (*bio_ctr)(struct bio *, struct bio *, void *),
 792                              void *data);
 793 extern void blk_rq_unprep_clone(struct request *rq);
 794 extern int blk_insert_cloned_request(struct request_queue *q,
 795                                      struct request *rq);
 796 extern void blk_delay_queue(struct request_queue *, unsigned long);
 797 extern void blk_queue_split(struct request_queue *, struct bio **,
 798                             struct bio_set *);
 799 extern void blk_recount_segments(struct request_queue *, struct bio *);
 800 extern int scsi_verify_blk_ioctl(struct block_device *, unsigned int);
 801 extern int scsi_cmd_blk_ioctl(struct block_device *, fmode_t,
 802                               unsigned int, void __user *);
 803 extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
 804                           unsigned int, void __user *);
 805 extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
 806                          struct scsi_ioctl_command __user *);
 807
 808 extern void blk_recalc_rq_segments(struct request *rq);
 809 extern int blk_queue_enter(struct request_queue *q, gfp_t gfp);
 810 extern void blk_queue_exit(struct request_queue *q);
 811 extern void blk_start_queue(struct request_queue *q);
 812 extern void blk_start_queue_async(struct request_queue *q);
 813 extern void blk_stop_queue(struct request_queue *q);
 814 extern void blk_sync_queue(struct request_queue *q);
 815 extern void __blk_stop_queue(struct request_queue *q);
 816 extern void __blk_run_queue(struct request_queue *q);
 817 extern void __blk_run_queue_uncond(struct request_queue *q);
 818 extern void blk_run_queue(struct request_queue *);
 819 extern void blk_run_queue_async(struct request_queue *q);
 820 extern int blk_rq_map_user(struct request_queue *, struct request *,
 821                            struct rq_map_data *, void __user *, unsigned long,
 822                            gfp_t);
 823 extern int blk_rq_unmap_user(struct bio *);
 824 extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
 825 extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
 826                                struct rq_map_data *, const struct iov_iter *,
 827                                gfp_t);
 828 extern int blk_execute_rq(struct request_queue *, struct gendisk *,
 829                           struct request *, int);
 830 extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
 831                                   struct request *, int, rq_end_io_fn *);
 832
 833 bool blk_poll(struct request_queue *q, blk_qc_t cookie);
 834
 835 static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
 836 {
 837         return bdev->bd_disk->queue;    /* this is never NULL */
 838 }
 839
 840 /*
 841  * blk_rq_pos()                 : the current sector
 842  * blk_rq_bytes()               : bytes left in the entire request
 843  * blk_rq_cur_bytes()           : bytes left in the current segment
 844  * blk_rq_err_bytes()           : bytes left till the next error boundary
 845  * blk_rq_sectors()             : sectors left in the entire request
 846  * blk_rq_cur_sectors()         : sectors left in the current segment
 847  */
 848 static inline sector_t blk_rq_pos(const struct request *rq)
 849 {
 850         return rq->__sector;
 851 }
 852
 853 static inline unsigned int blk_rq_bytes(const struct request *rq)
 854 {
 855         return rq->__data_len;
 856 }
 857
 858 static inline int blk_rq_cur_bytes(const struct request *rq)
 859 {
 860         return rq->bio ? bio_cur_bytes(rq->bio) : 0;
 861 }
 862
 863 extern unsigned int blk_rq_err_bytes(const struct request *rq);
 864
 865 static inline unsigned int blk_rq_sectors(const struct request *rq)
 866 {
 867         return blk_rq_bytes(rq) >> 9;
 868 }
 869
 870 static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
 871 {
 872         return blk_rq_cur_bytes(rq) >> 9;
 873 }
 874
 875 static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
 876                                                      unsigned int cmd_flags)
 877 {
 878         if (unlikely(cmd_flags & REQ_DISCARD))
 879                 return min(q->limits.max_discard_sectors, UINT_MAX >> 9);
 880
 881         if (unlikely(cmd_flags & REQ_WRITE_SAME))
 882                 return q->limits.max_write_same_sectors;
 883
 884         return q->limits.max_sectors;
 885 }
 886
 887 /*
 888  * Return maximum size of a request at given offset. Only valid for
 889  * file system requests.
 890  */
 891 static inline unsigned int blk_max_size_offset(struct request_queue *q,
 892                                                sector_t offset)
 893 {
 894         if (!q->limits.chunk_sectors)
 895                 return q->limits.max_sectors;
 896
 897         return min(q->limits.max_sectors, (unsigned int)(q->limits.chunk_sectors -
 898                         (offset & (q->limits.chunk_sectors - 1))));
 899 }
 900
 901 static inline unsigned int blk_rq_get_max_sectors(struct request *rq)
 902 {
 903         struct request_queue *q = rq->q;
 904
 905         if (blk_rq_is_passthrough(rq))
 906                 return q->limits.max_hw_sectors;
 907
 908         if (!q->limits.chunk_sectors || (rq->cmd_flags & REQ_DISCARD))
 909                 return blk_queue_get_max_sectors(q, rq->cmd_flags);
 910
 911         return min(blk_max_size_offset(q, blk_rq_pos(rq)),
 912                         blk_queue_get_max_sectors(q, rq->cmd_flags));
 913 }
 914
 915 static inline unsigned int blk_rq_count_bios(struct request *rq)
 916 {
 917         unsigned int nr_bios = 0;
 918         struct bio *bio;
 919
 920         __rq_for_each_bio(bio, rq)
 921                 nr_bios++;
 922
 923         return nr_bios;
 924 }
 925
 926 /*
 927  * Request issue related functions.
 928  */
 929 extern struct request *blk_peek_request(struct request_queue *q);
 930 extern void blk_start_request(struct request *rq);
 931 extern struct request *blk_fetch_request(struct request_queue *q);
 932
 933 /*
 934  * Request completion related functions.
 935  *
 936  * blk_update_request() completes given number of bytes and updates
 937  * the request without completing it.
 938  *
 939  * blk_end_request() and friends.  __blk_end_request() must be called
 940  * with the request queue spinlock acquired.
 941  *
 942  * Several drivers define their own end_request and call
 943  * blk_end_request() for parts of the original function.
 944  * This prevents code duplication in drivers.
 945  */
 946 extern bool blk_update_request(struct request *rq, int error,
 947                                unsigned int nr_bytes);
 948 extern void blk_finish_request(struct request *rq, int error);
 949 extern bool blk_end_request(struct request *rq, int error,
 950                             unsigned int nr_bytes);
 951 extern void blk_end_request_all(struct request *rq, int error);
 952 extern bool blk_end_request_cur(struct request *rq, int error);
 953 extern bool blk_end_request_err(struct request *rq, int error);
 954 extern bool __blk_end_request(struct request *rq, int error,
 955                               unsigned int nr_bytes);
 956 extern void __blk_end_request_all(struct request *rq, int error);
 957 extern bool __blk_end_request_cur(struct request *rq, int error);
 958 extern bool __blk_end_request_err(struct request *rq, int error);
 959
 960 extern void blk_complete_request(struct request *);
 961 extern void __blk_complete_request(struct request *);
 962 extern void blk_abort_request(struct request *);
 963 extern void blk_unprep_request(struct request *);
 964
 965 /*
 966  * Access functions for manipulating queue properties
 967  */
 968 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
 969                                         spinlock_t *lock, int node_id);
 970 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
 971 extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
 972                                                       request_fn_proc *, spinlock_t *);
 973 extern void blk_cleanup_queue(struct request_queue *);
 974 extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 975 extern void blk_queue_bounce_limit(struct request_queue *, u64);
 976 extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
 977 extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
 978 extern void blk_queue_max_segments(struct request_queue *, unsigned short);
 979 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
 980 extern void blk_queue_max_discard_sectors(struct request_queue *q,
 981                 unsigned int max_discard_sectors);
 982 extern void blk_queue_max_write_same_sectors(struct request_queue *q,
 983                 unsigned int max_write_same_sectors);
 984 extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
 985 extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
 986 extern void blk_queue_alignment_offset(struct request_queue *q,
 987                                        unsigned int alignment);
 988 extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
 989 extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
 990 extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
 991 extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
 992 extern void blk_set_default_limits(struct queue_limits *lim);
 993 extern void blk_set_stacking_limits(struct queue_limits *lim);
 994 extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
 995                             sector_t offset);
 996 extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
 997                             sector_t offset);
 998 extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
 999                               sector_t offset);
1000 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
1001 extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
1002 extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
1003 extern int blk_queue_dma_drain(struct request_queue *q,
1004                                dma_drain_needed_fn *dma_drain_needed,
1005                                void *buf, unsigned int size);
1006 extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
1007 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
1008 extern void blk_queue_virt_boundary(struct request_queue *, unsigned long);
1009 extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
1010 extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn);
1011 extern void blk_queue_dma_alignment(struct request_queue *, int);
1012 extern void blk_queue_update_dma_alignment(struct request_queue *, int);
1013 extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
1014 extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
1015 extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
1016 extern void blk_queue_flush(struct request_queue *q, unsigned int flush);
1017 extern void blk_queue_flush_queueable(struct request_queue *q, bool queueable);
1018 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
1019
1020 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
1021 extern int blk_rq_map_sg_no_cluster
1022         (struct request_queue *, struct request *, struct scatterlist *);
1023 extern void blk_dump_rq_flags(struct request *, char *);
1024 extern long nr_blockdev_pages(void);
1025
1026 bool __must_check blk_get_queue(struct request_queue *);
1027 struct request_queue *blk_alloc_queue(gfp_t);
1028 struct request_queue *blk_alloc_queue_node(gfp_t, int);
1029 extern void blk_put_queue(struct request_queue *);
1030 extern void blk_set_queue_dying(struct request_queue *);
1031
1032 /*
1033  * block layer runtime pm functions
1034  */
1035 #ifdef CONFIG_PM
1036 extern void blk_pm_runtime_init(struct request_queue *q, struct device *dev);
1037 extern int blk_pre_runtime_suspend(struct request_queue *q);
1038 extern void blk_post_runtime_suspend(struct request_queue *q, int err);
1039 extern void blk_pre_runtime_resume(struct request_queue *q);
1040 extern void blk_post_runtime_resume(struct request_queue *q, int err);
1041 #else
1042 static inline void blk_pm_runtime_init(struct request_queue *q,
1043         struct device *dev) {}
1044 static inline int blk_pre_runtime_suspend(struct request_queue *q)
1045 {
1046         return -ENOSYS;
1047 }
1048 static inline void blk_post_runtime_suspend(struct request_queue *q, int err) {}
1049 static inline void blk_pre_runtime_resume(struct request_queue *q) {}
1050 static inline void blk_post_runtime_resume(struct request_queue *q, int err) {}
1051 #endif
1052
1053 /*
1054  * blk_plug permits building a queue of related requests by holding the I/O
1055  * fragments for a short period. This allows merging of sequential requests
1056  * into single larger request. As the requests are moved from a per-task list to
1057  * the device's request_queue in a batch, this results in improved scalability
1058  * as the lock contention for request_queue lock is reduced.
1059  *
1060  * It is ok not to disable preemption when adding the request to the plug list
1061  * or when attempting a merge, because blk_schedule_flush_list() will only flush
1062  * the plug list when the task sleeps by itself. For details, please see
1063  * schedule() where blk_schedule_flush_plug() is called.
1064  */
1065 struct blk_plug {
1066         struct list_head list; /* requests */
1067         struct list_head mq_list; /* blk-mq requests */
1068         struct list_head cb_list; /* md requires an unplug callback */
1069 };
1070 #define BLK_MAX_REQUEST_COUNT 16
1071
1072 struct blk_plug_cb;
1073 typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool);
1074 struct blk_plug_cb {
1075         struct list_head list;
1076         blk_plug_cb_fn callback;
1077         void *data;
1078 };
1079 extern struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug,
1080                                              void *data, int size);
1081 extern void blk_start_plug(struct blk_plug *);
1082 extern void blk_finish_plug(struct blk_plug *);
1083 extern void blk_flush_plug_list(struct blk_plug *, bool);
1084
1085 static inline void blk_flush_plug(struct task_struct *tsk)
1086 {
1087         struct blk_plug *plug = tsk->plug;
1088
1089         if (plug)
1090                 blk_flush_plug_list(plug, false);
1091 }
1092
1093 static inline void blk_schedule_flush_plug(struct task_struct *tsk)
1094 {
1095         struct blk_plug *plug = tsk->plug;
1096
1097         if (plug)
1098                 blk_flush_plug_list(plug, true);
1099 }
1100
1101 static inline bool blk_needs_flush_plug(struct task_struct *tsk)
1102 {
1103         struct blk_plug *plug = tsk->plug;
1104
1105         return plug &&
1106                 (!list_empty(&plug->list) ||
1107                  !list_empty(&plug->mq_list) ||
1108                  !list_empty(&plug->cb_list));
1109 }
1110
1111 /*
1112  * tag stuff
1113  */
1114 extern int blk_queue_start_tag(struct request_queue *, struct request *);
1115 extern struct request *blk_queue_find_tag(struct request_queue *, int);
1116 extern void blk_queue_end_tag(struct request_queue *, struct request *);
1117 extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *, int);
1118 extern void blk_queue_free_tags(struct request_queue *);
1119 extern int blk_queue_resize_tags(struct request_queue *, int);
1120 extern void blk_queue_invalidate_tags(struct request_queue *);
1121 extern struct blk_queue_tag *blk_init_tags(int, int);
1122 extern void blk_free_tags(struct blk_queue_tag *);
1123
1124 static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
1125                                                 int tag)
1126 {
1127         if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
1128                 return NULL;
1129         return bqt->tag_index[tag];
1130 }
1131
1132 #define BLKDEV_DISCARD_SECURE  0x01    /* secure discard */
1133
1134 extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
1135 extern int blkdev_issue_barrier(struct block_device *, gfp_t, sector_t *);
1136 extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
1137                 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
1138 extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
1139                 sector_t nr_sects, gfp_t gfp_mask, struct page *page);
1140 extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
1141                 sector_t nr_sects, gfp_t gfp_mask, bool discard);
1142 static inline int sb_issue_discard(struct super_block *sb, sector_t block,
1143                 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
1144 {
1145         return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),
1146                                     nr_blocks << (sb->s_blocksize_bits - 9),
1147                                     gfp_mask, flags);
1148 }
1149 static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
1150                 sector_t nr_blocks, gfp_t gfp_mask)
1151 {
1152         return blkdev_issue_zeroout(sb->s_bdev,
1153                                     block << (sb->s_blocksize_bits - 9),
1154                                     nr_blocks << (sb->s_blocksize_bits - 9),
1155                                     gfp_mask, true);
1156 }
1157
1158 extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
1159
1160 enum blk_default_limits {
1161         BLK_MAX_SEGMENTS        = 128,
1162         BLK_SAFE_MAX_SECTORS    = 255,
1163         BLK_DEF_MAX_SECTORS     = 2560,
1164         BLK_MAX_SEGMENT_SIZE    = 65536,
1165         BLK_SEG_BOUNDARY_MASK   = 0xFFFFFFFFUL,
1166 };
1167
1168 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
1169
1170 static inline unsigned long queue_bounce_pfn(struct request_queue *q)
1171 {
1172         return q->limits.bounce_pfn;
1173 }
1174
1175 static inline unsigned long queue_segment_boundary(struct request_queue *q)
1176 {
1177         return q->limits.seg_boundary_mask;
1178 }
1179
1180 static inline unsigned long queue_virt_boundary(struct request_queue *q)
1181 {
1182         return q->limits.virt_boundary_mask;
1183 }
1184
1185 static inline unsigned int queue_max_sectors(struct request_queue *q)
1186 {
1187         return q->limits.max_sectors;
1188 }
1189
1190 static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
1191 {
1192         return q->limits.max_hw_sectors;
1193 }
1194
1195 static inline unsigned short queue_max_segments(struct request_queue *q)
1196 {
1197         return q->limits.max_segments;
1198 }
1199
1200 static inline unsigned int queue_max_segment_size(struct request_queue *q)
1201 {
1202         return q->limits.max_segment_size;
1203 }
1204
1205 static inline unsigned short queue_logical_block_size(struct request_queue *q)
1206 {
1207         int retval = 512;
1208
1209         if (q && q->limits.logical_block_size)
1210                 retval = q->limits.logical_block_size;
1211
1212         return retval;
1213 }
1214
1215 static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
1216 {
1217         return queue_logical_block_size(bdev_get_queue(bdev));
1218 }
1219
1220 static inline unsigned int queue_physical_block_size(struct request_queue *q)
1221 {
1222         return q->limits.physical_block_size;
1223 }
1224
1225 static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
1226 {
1227         return queue_physical_block_size(bdev_get_queue(bdev));
1228 }
1229
1230 static inline unsigned int queue_io_min(struct request_queue *q)
1231 {
1232         return q->limits.io_min;
1233 }
1234
1235 static inline int bdev_io_min(struct block_device *bdev)
1236 {
1237         return queue_io_min(bdev_get_queue(bdev));
1238 }
1239
1240 static inline unsigned int queue_io_opt(struct request_queue *q)
1241 {
1242         return q->limits.io_opt;
1243 }
1244
1245 static inline int bdev_io_opt(struct block_device *bdev)
1246 {
1247         return queue_io_opt(bdev_get_queue(bdev));
1248 }
1249
1250 static inline int queue_alignment_offset(struct request_queue *q)
1251 {
1252         if (q->limits.misaligned)
1253                 return -1;
1254
1255         return q->limits.alignment_offset;
1256 }
1257
1258 static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
1259 {
1260         unsigned int granularity = max(lim->physical_block_size, lim->io_min);
1261         unsigned int alignment = sector_div(sector, granularity >> 9) << 9;
1262
1263         return (granularity + lim->alignment_offset - alignment) % granularity;
1264 }
1265
1266 static inline int bdev_alignment_offset(struct block_device *bdev)
1267 {
1268         struct request_queue *q = bdev_get_queue(bdev);
1269
1270         if (q->limits.misaligned)
1271                 return -1;
1272
1273         if (bdev != bdev->bd_contains)
1274                 return bdev->bd_part->alignment_offset;
1275
1276         return q->limits.alignment_offset;
1277 }
1278
1279 static inline int queue_discard_alignment(struct request_queue *q)
1280 {
1281         if (q->limits.discard_misaligned)
1282                 return -1;
1283
1284         return q->limits.discard_alignment;
1285 }
1286
1287 static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
1288 {
1289         unsigned int alignment, granularity, offset;
1290
1291         if (!lim->max_discard_sectors)
1292                 return 0;
1293
1294         /* Why are these in bytes, not sectors? */
1295         alignment = lim->discard_alignment >> 9;
1296         granularity = lim->discard_granularity >> 9;
1297         if (!granularity)
1298                 return 0;
1299
1300         /* Offset of the partition start in 'granularity' sectors */
1301         offset = sector_div(sector, granularity);
1302
1303         /* And why do we do this modulus *again* in blkdev_issue_discard()? */
1304         offset = (granularity + alignment - offset) % granularity;
1305
1306         /* Turn it back into bytes, gaah */
1307         return offset << 9;
1308 }
1309
1310 static inline int bdev_discard_alignment(struct block_device *bdev)
1311 {
1312         struct request_queue *q = bdev_get_queue(bdev);
1313
1314         if (bdev != bdev->bd_contains)
1315                 return bdev->bd_part->discard_alignment;
1316
1317         return q->limits.discard_alignment;
1318 }
1319
1320 static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
1321 {
1322         if (q->limits.max_discard_sectors && q->limits.discard_zeroes_data == 1)
1323                 return 1;
1324
1325         return 0;
1326 }
1327
1328 static inline unsigned int bdev_discard_zeroes_data(struct block_device *bdev)
1329 {
1330         return queue_discard_zeroes_data(bdev_get_queue(bdev));
1331 }
1332
1333 static inline unsigned int bdev_write_same(struct block_device *bdev)
1334 {
1335         struct request_queue *q = bdev_get_queue(bdev);
1336
1337         if (q)
1338                 return q->limits.max_write_same_sectors;
1339
1340         return 0;
1341 }
1342
1343 static inline int queue_dma_alignment(struct request_queue *q)
1344 {
1345         return q ? q->dma_alignment : 511;
1346 }
1347
1348 static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
1349                                  unsigned int len)
1350 {
1351         unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1352         return !(addr & alignment) && !(len & alignment);
1353 }
1354
1355 /* assumes size > 256 */
1356 static inline unsigned int blksize_bits(unsigned int size)
1357 {
1358         unsigned int bits = 8;
1359         do {
1360                 bits++;
1361                 size >>= 1;
1362         } while (size > 256);
1363         return bits;
1364 }
1365
1366 static inline unsigned int block_size(struct block_device *bdev)
1367 {
1368         return bdev->bd_block_size;
1369 }
1370
1371 static inline bool queue_flush_queueable(struct request_queue *q)
1372 {
1373         return !q->flush_not_queueable;
1374 }
1375
1376 typedef struct {struct page *v;} Sector;
1377
1378 unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
1379
1380 static inline void put_dev_sector(Sector p)
1381 {
1382         page_cache_release(p.v);
1383 }
1384
1385 static inline bool __bvec_gap_to_prev(struct request_queue *q,
1386                                 struct bio_vec *bprv, unsigned int offset)
1387 {
1388         return offset ||
1389                 ((bprv->bv_offset + bprv->bv_len) & queue_virt_boundary(q));
1390 }
1391
1392 /*
1393  * Check if adding a bio_vec after bprv with offset would create a gap in
1394  * the SG list. Most drivers don't care about this, but some do.
1395  */
1396 static inline bool bvec_gap_to_prev(struct request_queue *q,
1397                                 struct bio_vec *bprv, unsigned int offset)
1398 {
1399         if (!queue_virt_boundary(q))
1400                 return false;
1401         return __bvec_gap_to_prev(q, bprv, offset);
1402 }
1403
1404 static inline bool bio_will_gap(struct request_queue *q, struct bio *prev,
1405                          struct bio *next)
1406 {
1407         if (bio_has_data(prev) && queue_virt_boundary(q)) {
1408                 struct bio_vec pb, nb;
1409
1410                 bio_get_last_bvec(prev, &pb);
1411                 bio_get_first_bvec(next, &nb);
1412
1413                 return __bvec_gap_to_prev(q, &pb, nb.bv_offset);
1414         }
1415
1416         return false;
1417 }
1418
1419 static inline bool req_gap_back_merge(struct request *req, struct bio *bio)
1420 {
1421         return bio_will_gap(req->q, req->biotail, bio);
1422 }
1423
1424 static inline bool req_gap_front_merge(struct request *req, struct bio *bio)
1425 {
1426         return bio_will_gap(req->q, bio, req->bio);
1427 }
1428
1429 struct work_struct;
1430 int kblockd_schedule_work(struct work_struct *work);
1431 int kblockd_schedule_delayed_work(struct delayed_work *dwork, unsigned long delay);
1432 int kblockd_schedule_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
1433
1434 #ifdef CONFIG_BLK_CGROUP
1435 /*
1436  * This should not be using sched_clock(). A real patch is in progress
1437  * to fix this up, until that is in place we need to disable preemption
1438  * around sched_clock() in this function and set_io_start_time_ns().
1439  */
1440 static inline void set_start_time_ns(struct request *req)
1441 {
1442         preempt_disable();
1443         req->start_time_ns = sched_clock();
1444         preempt_enable();
1445 }
1446
1447 static inline void set_io_start_time_ns(struct request *req)
1448 {
1449         preempt_disable();
1450         req->io_start_time_ns = sched_clock();
1451         preempt_enable();
1452 }
1453
1454 static inline uint64_t rq_start_time_ns(struct request *req)
1455 {
1456         return req->start_time_ns;
1457 }
1458
1459 static inline uint64_t rq_io_start_time_ns(struct request *req)
1460 {
1461         return req->io_start_time_ns;
1462 }
1463 #else
1464 static inline void set_start_time_ns(struct request *req) {}
1465 static inline void set_io_start_time_ns(struct request *req) {}
1466 static inline uint64_t rq_start_time_ns(struct request *req)
1467 {
1468         return 0;
1469 }
1470 static inline uint64_t rq_io_start_time_ns(struct request *req)
1471 {
1472         return 0;
1473 }
1474 #endif
1475
1476 #define MODULE_ALIAS_BLOCKDEV(major,minor) \
1477         MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
1478 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
1479         MODULE_ALIAS("block-major-" __stringify(major) "-*")
1480
1481 #if defined(CONFIG_BLK_DEV_INTEGRITY)
1482
1483 enum blk_integrity_flags {
1484         BLK_INTEGRITY_VERIFY            = 1 << 0,
1485         BLK_INTEGRITY_GENERATE          = 1 << 1,
1486         BLK_INTEGRITY_DEVICE_CAPABLE    = 1 << 2,
1487         BLK_INTEGRITY_IP_CHECKSUM       = 1 << 3,
1488 };
1489
1490 struct blk_integrity_iter {
1491         void                    *prot_buf;
1492         void                    *data_buf;
1493         sector_t                seed;
1494         unsigned int            data_size;
1495         unsigned short          interval;
1496         const char              *disk_name;
1497 };
1498
1499 typedef int (integrity_processing_fn) (struct blk_integrity_iter *);
1500
1501 struct blk_integrity_profile {
1502         integrity_processing_fn         *generate_fn;
1503         integrity_processing_fn         *verify_fn;
1504         const char                      *name;
1505 };
1506
1507 extern void blk_integrity_register(struct gendisk *, struct blk_integrity *);
1508 extern void blk_integrity_unregister(struct gendisk *);
1509 extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
1510 extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
1511                                    struct scatterlist *);
1512 extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
1513 extern bool blk_integrity_merge_rq(struct request_queue *, struct request *,
1514                                    struct request *);
1515 extern bool blk_integrity_merge_bio(struct request_queue *, struct request *,
1516                                     struct bio *);
1517
1518 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
1519 {
1520         struct blk_integrity *bi = &disk->queue->integrity;
1521
1522         if (!bi->profile)
1523                 return NULL;
1524
1525         return bi;
1526 }
1527
1528 static inline
1529 struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
1530 {
1531         return blk_get_integrity(bdev->bd_disk);
1532 }
1533
1534 static inline bool blk_integrity_rq(struct request *rq)
1535 {
1536         return rq->cmd_flags & REQ_INTEGRITY;
1537 }
1538
1539 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
1540                                                     unsigned int segs)
1541 {
1542         q->limits.max_integrity_segments = segs;
1543 }
1544
1545 static inline unsigned short
1546 queue_max_integrity_segments(struct request_queue *q)
1547 {
1548         return q->limits.max_integrity_segments;
1549 }
1550
1551 static inline bool integrity_req_gap_back_merge(struct request *req,
1552                                                 struct bio *next)
1553 {
1554         struct bio_integrity_payload *bip = bio_integrity(req->bio);
1555         struct bio_integrity_payload *bip_next = bio_integrity(next);
1556
1557         return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
1558                                 bip_next->bip_vec[0].bv_offset);
1559 }
1560
1561 static inline bool integrity_req_gap_front_merge(struct request *req,
1562                                                  struct bio *bio)
1563 {
1564         struct bio_integrity_payload *bip = bio_integrity(bio);
1565         struct bio_integrity_payload *bip_next = bio_integrity(req->bio);
1566
1567         return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
1568                                 bip_next->bip_vec[0].bv_offset);
1569 }
1570
1571 #else /* CONFIG_BLK_DEV_INTEGRITY */
1572
1573 struct bio;
1574 struct block_device;
1575 struct gendisk;
1576 struct blk_integrity;
1577
1578 static inline int blk_integrity_rq(struct request *rq)
1579 {
1580         return 0;
1581 }
1582 static inline int blk_rq_count_integrity_sg(struct request_queue *q,
1583                                             struct bio *b)
1584 {
1585         return 0;
1586 }
1587 static inline int blk_rq_map_integrity_sg(struct request_queue *q,
1588                                           struct bio *b,
1589                                           struct scatterlist *s)
1590 {
1591         return 0;
1592 }
1593 static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
1594 {
1595         return NULL;
1596 }
1597 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
1598 {
1599         return NULL;
1600 }
1601 static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
1602 {
1603         return 0;
1604 }
1605 static inline void blk_integrity_register(struct gendisk *d,
1606                                          struct blk_integrity *b)
1607 {
1608 }
1609 static inline void blk_integrity_unregister(struct gendisk *d)
1610 {
1611 }
1612 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
1613                                                     unsigned int segs)
1614 {
1615 }
1616 static inline unsigned short queue_max_integrity_segments(struct request_queue *q)
1617 {
1618         return 0;
1619 }
1620 static inline bool blk_integrity_merge_rq(struct request_queue *rq,
1621                                           struct request *r1,
1622                                           struct request *r2)
1623 {
1624         return true;
1625 }
1626 static inline bool blk_integrity_merge_bio(struct request_queue *rq,
1627                                            struct request *r,
1628                                            struct bio *b)
1629 {
1630         return true;
1631 }
1632
1633 static inline bool integrity_req_gap_back_merge(struct request *req,
1634                                                 struct bio *next)
1635 {
1636         return false;
1637 }
1638 static inline bool integrity_req_gap_front_merge(struct request *req,
1639                                                  struct bio *bio)
1640 {
1641         return false;
1642 }
1643
1644 #endif /* CONFIG_BLK_DEV_INTEGRITY */
1645
1646 struct block_device_operations {
1647         int (*open) (struct block_device *, fmode_t);
1648         void (*release) (struct gendisk *, fmode_t);
1649         int (*rw_page)(struct block_device *, sector_t, struct page *, int rw);
1650         int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1651         int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1652         long (*direct_access)(struct block_device *, sector_t, void __pmem **,
1653                         unsigned long *pfn);
1654         unsigned int (*check_events) (struct gendisk *disk,
1655                                       unsigned int clearing);
1656         /* ->media_changed() is DEPRECATED, use ->check_events() instead */
1657         int (*media_changed) (struct gendisk *);
1658         void (*unlock_native_capacity) (struct gendisk *);
1659         int (*revalidate_disk) (struct gendisk *);
1660         int (*getgeo)(struct block_device *, struct hd_geometry *);
1661         /* this callback is with swap_lock and sometimes page table lock held */
1662         void (*swap_slot_free_notify) (struct block_device *, unsigned long);
1663         struct module *owner;
1664         const struct pr_ops *pr_ops;
1665 };
1666
1667 extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
1668                                  unsigned long);
1669 extern int bdev_read_page(struct block_device *, sector_t, struct page *);
1670 extern int bdev_write_page(struct block_device *, sector_t, struct page *,
1671                                                 struct writeback_control *);
1672 extern long bdev_direct_access(struct block_device *, sector_t,
1673                 void __pmem **addr, unsigned long *pfn, long size);
1674
1675 /*
1676  * X-axis for IO latency histogram support.
1677  */
1678 static const u_int64_t latency_x_axis_us[] = {
1679         100,
1680         200,
1681         300,
1682         400,
1683         500,
1684         600,
1685         700,
1686         800,
1687         900,
1688         1000,
1689         1200,
1690         1400,
1691         1600,
1692         1800,
1693         2000,
1694         2500,
1695         3000,
1696         4000,
1697         5000,
1698         6000,
1699         7000,
1700         9000,
1701         10000
1702 };
1703
1704 #define BLK_IO_LAT_HIST_DISABLE         0
1705 #define BLK_IO_LAT_HIST_ENABLE          1
1706 #define BLK_IO_LAT_HIST_ZERO            2
1707
1708 struct io_latency_state {
1709         u_int64_t       latency_y_axis[ARRAY_SIZE(latency_x_axis_us) + 1];
1710         u_int64_t       latency_elems;
1711         u_int64_t       latency_sum;
1712 };
1713
1714 static inline void
1715 blk_update_latency_hist(struct io_latency_state *s, u_int64_t delta_us)
1716 {
1717         int i;
1718
1719         for (i = 0; i < ARRAY_SIZE(latency_x_axis_us); i++)
1720                 if (delta_us < (u_int64_t)latency_x_axis_us[i])
1721                         break;
1722         s->latency_y_axis[i]++;
1723         s->latency_elems++;
1724         s->latency_sum += delta_us;
1725 }
1726
1727 ssize_t blk_latency_hist_show(char* name, struct io_latency_state *s,
1728                 char *buf, int buf_size);
1729
1730 #else /* CONFIG_BLOCK */
1731
1732 struct block_device;
1733
1734 /*
1735  * stubs for when the block layer is configured out
1736  */
1737 #define buffer_heads_over_limit 0
1738
1739 static inline long nr_blockdev_pages(void)
1740 {
1741         return 0;
1742 }
1743
1744 struct blk_plug {
1745 };
1746
1747 static inline void blk_start_plug(struct blk_plug *plug)
1748 {
1749 }
1750
1751 static inline void blk_finish_plug(struct blk_plug *plug)
1752 {
1753 }
1754
1755 static inline void blk_flush_plug(struct task_struct *task)
1756 {
1757 }
1758
1759 static inline void blk_schedule_flush_plug(struct task_struct *task)
1760 {
1761 }
1762
1763
1764 static inline bool blk_needs_flush_plug(struct task_struct *tsk)
1765 {
1766         return false;
1767 }
1768
1769 static inline int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
1770                                      sector_t *error_sector)
1771 {
1772         return 0;
1773 }
1774
1775 #endif /* CONFIG_BLOCK */
1776
1777 #endif