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_STACKABLE)    |       \
 503                                  (1 << QUEUE_FLAG_SAME_COMP))
 504
 505 #define QUEUE_FLAG_MQ_DEFAULT   ((1 << QUEUE_FLAG_STACKABLE)    |       \
 506                                  (1 << QUEUE_FLAG_SAME_COMP))
 507
 508 static inline void queue_lockdep_assert_held(struct request_queue *q)
 509 {
 510         if (q->queue_lock)
 511                 lockdep_assert_held(q->queue_lock);
 512 }
 513
 514 static inline void queue_flag_set_unlocked(unsigned int flag,
 515                                            struct request_queue *q)
 516 {
 517         __set_bit(flag, &q->queue_flags);
 518 }
 519
 520 static inline int queue_flag_test_and_clear(unsigned int flag,
 521                                             struct request_queue *q)
 522 {
 523         queue_lockdep_assert_held(q);
 524
 525         if (test_bit(flag, &q->queue_flags)) {
 526                 __clear_bit(flag, &q->queue_flags);
 527                 return 1;
 528         }
 529
 530         return 0;
 531 }
 532
 533 static inline int queue_flag_test_and_set(unsigned int flag,
 534                                           struct request_queue *q)
 535 {
 536         queue_lockdep_assert_held(q);
 537
 538         if (!test_bit(flag, &q->queue_flags)) {
 539                 __set_bit(flag, &q->queue_flags);
 540                 return 0;
 541         }
 542
 543         return 1;
 544 }
 545
 546 static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
 547 {
 548         queue_lockdep_assert_held(q);
 549         __set_bit(flag, &q->queue_flags);
 550 }
 551
 552 static inline void queue_flag_clear_unlocked(unsigned int flag,
 553                                              struct request_queue *q)
 554 {
 555         __clear_bit(flag, &q->queue_flags);
 556 }
 557
 558 static inline int queue_in_flight(struct request_queue *q)
 559 {
 560         return q->in_flight[0] + q->in_flight[1];
 561 }
 562
 563 static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
 564 {
 565         queue_lockdep_assert_held(q);
 566         __clear_bit(flag, &q->queue_flags);
 567 }
 568
 569 #define blk_queue_tagged(q)     test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
 570 #define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
 571 #define blk_queue_dying(q)      test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags)
 572 #define blk_queue_dead(q)       test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags)
 573 #define blk_queue_bypass(q)     test_bit(QUEUE_FLAG_BYPASS, &(q)->queue_flags)
 574 #define blk_queue_init_done(q)  test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags)
 575 #define blk_queue_nomerges(q)   test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
 576 #define blk_queue_noxmerges(q)  \
 577         test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
 578 #define blk_queue_nonrot(q)     test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
 579 #define blk_queue_io_stat(q)    test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
 580 #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
 581 #define blk_queue_stackable(q)  \
 582         test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
 583 #define blk_queue_discard(q)    test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
 584 #define blk_queue_secdiscard(q) (blk_queue_discard(q) && \
 585         test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
 586 #define blk_queue_fast(q)       test_bit(QUEUE_FLAG_FAST, &(q)->queue_flags)
 587
 588 #define blk_noretry_request(rq) \
 589         ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
 590                              REQ_FAILFAST_DRIVER))
 591
 592 static inline bool blk_account_rq(struct request *rq)
 593 {
 594         return (rq->cmd_flags & REQ_STARTED) && !blk_rq_is_passthrough(rq);
 595 }
 596
 597 #define blk_rq_cpu_valid(rq)    ((rq)->cpu != -1)
 598 #define blk_bidi_rq(rq)         ((rq)->next_rq != NULL)
 599 /* rq->queuelist of dequeued request must be list_empty() */
 600 #define blk_queued_rq(rq)       (!list_empty(&(rq)->queuelist))
 601
 602 #define list_entry_rq(ptr)      list_entry((ptr), struct request, queuelist)
 603
 604 #define rq_data_dir(rq)         ((int)((rq)->cmd_flags & 1))
 605
 606 /*
 607  * Driver can handle struct request, if it either has an old style
 608  * request_fn defined, or is blk-mq based.
 609  */
 610 static inline bool queue_is_rq_based(struct request_queue *q)
 611 {
 612         return q->request_fn || q->mq_ops;
 613 }
 614
 615 static inline unsigned int blk_queue_cluster(struct request_queue *q)
 616 {
 617         return q->limits.cluster;
 618 }
 619
 620 /*
 621  * We regard a request as sync, if either a read or a sync write
 622  */
 623 static inline bool rw_is_sync(unsigned int rw_flags)
 624 {
 625         return !(rw_flags & REQ_WRITE) || (rw_flags & REQ_SYNC);
 626 }
 627
 628 static inline bool rq_is_sync(struct request *rq)
 629 {
 630         return rw_is_sync(rq->cmd_flags);
 631 }
 632
 633 static inline bool blk_rl_full(struct request_list *rl, bool sync)
 634 {
 635         unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
 636
 637         return rl->flags & flag;
 638 }
 639
 640 static inline void blk_set_rl_full(struct request_list *rl, bool sync)
 641 {
 642         unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
 643
 644         rl->flags |= flag;
 645 }
 646
 647 static inline void blk_clear_rl_full(struct request_list *rl, bool sync)
 648 {
 649         unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
 650
 651         rl->flags &= ~flag;
 652 }
 653
 654 static inline bool rq_mergeable(struct request *rq)
 655 {
 656         if (blk_rq_is_passthrough(rq))
 657                 return false;
 658
 659         if (rq->cmd_flags & REQ_NOMERGE_FLAGS)
 660                 return false;
 661
 662         return true;
 663 }
 664
 665 static inline bool blk_check_merge_flags(unsigned int flags1,
 666                                          unsigned int flags2)
 667 {
 668         if ((flags1 & REQ_DISCARD) != (flags2 & REQ_DISCARD))
 669                 return false;
 670
 671         if ((flags1 & REQ_SECURE) != (flags2 & REQ_SECURE))
 672                 return false;
 673
 674         if ((flags1 & REQ_WRITE_SAME) != (flags2 & REQ_WRITE_SAME))
 675                 return false;
 676
 677         return true;
 678 }
 679
 680 static inline bool blk_write_same_mergeable(struct bio *a, struct bio *b)
 681 {
 682         if (bio_data(a) == bio_data(b))
 683                 return true;
 684
 685         return false;
 686 }
 687
 688 /*
 689  * q->prep_rq_fn return values
 690  */
 691 #define BLKPREP_OK              0       /* serve it */
 692 #define BLKPREP_KILL            1       /* fatal error, kill */
 693 #define BLKPREP_DEFER           2       /* leave on queue */
 694
 695 extern unsigned long blk_max_low_pfn, blk_max_pfn;
 696
 697 /*
 698  * standard bounce addresses:
 699  *
 700  * BLK_BOUNCE_HIGH      : bounce all highmem pages
 701  * BLK_BOUNCE_ANY       : don't bounce anything
 702  * BLK_BOUNCE_ISA       : bounce pages above ISA DMA boundary
 703  */
 704
 705 #if BITS_PER_LONG == 32
 706 #define BLK_BOUNCE_HIGH         ((u64)blk_max_low_pfn << PAGE_SHIFT)
 707 #else
 708 #define BLK_BOUNCE_HIGH         -1ULL
 709 #endif
 710 #define BLK_BOUNCE_ANY          (-1ULL)
 711 #define BLK_BOUNCE_ISA          (DMA_BIT_MASK(24))
 712
 713 /*
 714  * default timeout for SG_IO if none specified
 715  */
 716 #define BLK_DEFAULT_SG_TIMEOUT  (60 * HZ)
 717 #define BLK_MIN_SG_TIMEOUT      (7 * HZ)
 718
 719 #ifdef CONFIG_BOUNCE
 720 extern int init_emergency_isa_pool(void);
 721 extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
 722 #else
 723 static inline int init_emergency_isa_pool(void)
 724 {
 725         return 0;
 726 }
 727 static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
 728 {
 729 }
 730 #endif /* CONFIG_MMU */
 731
 732 struct rq_map_data {
 733         struct page **pages;
 734         int page_order;
 735         int nr_entries;
 736         unsigned long offset;
 737         int null_mapped;
 738         int from_user;
 739 };
 740
 741 struct req_iterator {
 742         struct bvec_iter iter;
 743         struct bio *bio;
 744 };
 745
 746 /* This should not be used directly - use rq_for_each_segment */
 747 #define for_each_bio(_bio)              \
 748         for (; _bio; _bio = _bio->bi_next)
 749 #define __rq_for_each_bio(_bio, rq)     \
 750         if ((rq->bio))                  \
 751                 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
 752
 753 #define rq_for_each_segment(bvl, _rq, _iter)                    \
 754         __rq_for_each_bio(_iter.bio, _rq)                       \
 755                 bio_for_each_segment(bvl, _iter.bio, _iter.iter)
 756
 757 #define rq_iter_last(bvec, _iter)                               \
 758                 (_iter.bio->bi_next == NULL &&                  \
 759                  bio_iter_last(bvec, _iter.iter))
 760
 761 #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
 762 # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
 763 #endif
 764 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
 765 extern void rq_flush_dcache_pages(struct request *rq);
 766 #else
 767 static inline void rq_flush_dcache_pages(struct request *rq)
 768 {
 769 }
 770 #endif
 771
 772 extern int blk_register_queue(struct gendisk *disk);
 773 extern void blk_unregister_queue(struct gendisk *disk);
 774 extern blk_qc_t generic_make_request(struct bio *bio);
 775 extern void blk_rq_init(struct request_queue *q, struct request *rq);
 776 extern void blk_put_request(struct request *);
 777 extern void __blk_put_request(struct request_queue *, struct request *);
 778 extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
 779 extern struct request *blk_make_request(struct request_queue *, struct bio *,
 780                                         gfp_t);
 781 extern void blk_rq_set_block_pc(struct request *);
 782 extern void blk_requeue_request(struct request_queue *, struct request *);
 783 extern void blk_add_request_payload(struct request *rq, struct page *page,
 784                 unsigned int len);
 785 extern int blk_lld_busy(struct request_queue *q);
 786 extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
 787                              struct bio_set *bs, gfp_t gfp_mask,
 788                              int (*bio_ctr)(struct bio *, struct bio *, void *),
 789                              void *data);
 790 extern void blk_rq_unprep_clone(struct request *rq);
 791 extern int blk_insert_cloned_request(struct request_queue *q,
 792                                      struct request *rq);
 793 extern void blk_delay_queue(struct request_queue *, unsigned long);
 794 extern void blk_queue_split(struct request_queue *, struct bio **,
 795                             struct bio_set *);
 796 extern void blk_recount_segments(struct request_queue *, struct bio *);
 797 extern int scsi_verify_blk_ioctl(struct block_device *, unsigned int);
 798 extern int scsi_cmd_blk_ioctl(struct block_device *, fmode_t,
 799                               unsigned int, void __user *);
 800 extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
 801                           unsigned int, void __user *);
 802 extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
 803                          struct scsi_ioctl_command __user *);
 804
 805 extern void blk_recalc_rq_segments(struct request *rq);
 806 extern int blk_queue_enter(struct request_queue *q, gfp_t gfp);
 807 extern void blk_queue_exit(struct request_queue *q);
 808 extern void blk_start_queue(struct request_queue *q);
 809 extern void blk_start_queue_async(struct request_queue *q);
 810 extern void blk_stop_queue(struct request_queue *q);
 811 extern void blk_sync_queue(struct request_queue *q);
 812 extern void __blk_stop_queue(struct request_queue *q);
 813 extern void __blk_run_queue(struct request_queue *q);
 814 extern void __blk_run_queue_uncond(struct request_queue *q);
 815 extern void blk_run_queue(struct request_queue *);
 816 extern void blk_run_queue_async(struct request_queue *q);
 817 extern int blk_rq_map_user(struct request_queue *, struct request *,
 818                            struct rq_map_data *, void __user *, unsigned long,
 819                            gfp_t);
 820 extern int blk_rq_unmap_user(struct bio *);
 821 extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
 822 extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
 823                                struct rq_map_data *, const struct iov_iter *,
 824                                gfp_t);
 825 extern int blk_execute_rq(struct request_queue *, struct gendisk *,
 826                           struct request *, int);
 827 extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
 828                                   struct request *, int, rq_end_io_fn *);
 829
 830 bool blk_poll(struct request_queue *q, blk_qc_t cookie);
 831
 832 static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
 833 {
 834         return bdev->bd_disk->queue;    /* this is never NULL */
 835 }
 836
 837 /*
 838  * blk_rq_pos()                 : the current sector
 839  * blk_rq_bytes()               : bytes left in the entire request
 840  * blk_rq_cur_bytes()           : bytes left in the current segment
 841  * blk_rq_err_bytes()           : bytes left till the next error boundary
 842  * blk_rq_sectors()             : sectors left in the entire request
 843  * blk_rq_cur_sectors()         : sectors left in the current segment
 844  */
 845 static inline sector_t blk_rq_pos(const struct request *rq)
 846 {
 847         return rq->__sector;
 848 }
 849
 850 static inline unsigned int blk_rq_bytes(const struct request *rq)
 851 {
 852         return rq->__data_len;
 853 }
 854
 855 static inline int blk_rq_cur_bytes(const struct request *rq)
 856 {
 857         return rq->bio ? bio_cur_bytes(rq->bio) : 0;
 858 }
 859
 860 extern unsigned int blk_rq_err_bytes(const struct request *rq);
 861
 862 static inline unsigned int blk_rq_sectors(const struct request *rq)
 863 {
 864         return blk_rq_bytes(rq) >> 9;
 865 }
 866
 867 static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
 868 {
 869         return blk_rq_cur_bytes(rq) >> 9;
 870 }
 871
 872 static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
 873                                                      unsigned int cmd_flags)
 874 {
 875         if (unlikely(cmd_flags & REQ_DISCARD))
 876                 return min(q->limits.max_discard_sectors, UINT_MAX >> 9);
 877
 878         if (unlikely(cmd_flags & REQ_WRITE_SAME))
 879                 return q->limits.max_write_same_sectors;
 880
 881         return q->limits.max_sectors;
 882 }
 883
 884 /*
 885  * Return maximum size of a request at given offset. Only valid for
 886  * file system requests.
 887  */
 888 static inline unsigned int blk_max_size_offset(struct request_queue *q,
 889                                                sector_t offset)
 890 {
 891         if (!q->limits.chunk_sectors)
 892                 return q->limits.max_sectors;
 893
 894         return min(q->limits.max_sectors, (unsigned int)(q->limits.chunk_sectors -
 895                         (offset & (q->limits.chunk_sectors - 1))));
 896 }
 897
 898 static inline unsigned int blk_rq_get_max_sectors(struct request *rq)
 899 {
 900         struct request_queue *q = rq->q;
 901
 902         if (blk_rq_is_passthrough(rq))
 903                 return q->limits.max_hw_sectors;
 904
 905         if (!q->limits.chunk_sectors || (rq->cmd_flags & REQ_DISCARD))
 906                 return blk_queue_get_max_sectors(q, rq->cmd_flags);
 907
 908         return min(blk_max_size_offset(q, blk_rq_pos(rq)),
 909                         blk_queue_get_max_sectors(q, rq->cmd_flags));
 910 }
 911
 912 static inline unsigned int blk_rq_count_bios(struct request *rq)
 913 {
 914         unsigned int nr_bios = 0;
 915         struct bio *bio;
 916
 917         __rq_for_each_bio(bio, rq)
 918                 nr_bios++;
 919
 920         return nr_bios;
 921 }
 922
 923 /*
 924  * Request issue related functions.
 925  */
 926 extern struct request *blk_peek_request(struct request_queue *q);
 927 extern void blk_start_request(struct request *rq);
 928 extern struct request *blk_fetch_request(struct request_queue *q);
 929
 930 /*
 931  * Request completion related functions.
 932  *
 933  * blk_update_request() completes given number of bytes and updates
 934  * the request without completing it.
 935  *
 936  * blk_end_request() and friends.  __blk_end_request() must be called
 937  * with the request queue spinlock acquired.
 938  *
 939  * Several drivers define their own end_request and call
 940  * blk_end_request() for parts of the original function.
 941  * This prevents code duplication in drivers.
 942  */
 943 extern bool blk_update_request(struct request *rq, int error,
 944                                unsigned int nr_bytes);
 945 extern void blk_finish_request(struct request *rq, int error);
 946 extern bool blk_end_request(struct request *rq, int error,
 947                             unsigned int nr_bytes);
 948 extern void blk_end_request_all(struct request *rq, int error);
 949 extern bool blk_end_request_cur(struct request *rq, int error);
 950 extern bool blk_end_request_err(struct request *rq, int error);
 951 extern bool __blk_end_request(struct request *rq, int error,
 952                               unsigned int nr_bytes);
 953 extern void __blk_end_request_all(struct request *rq, int error);
 954 extern bool __blk_end_request_cur(struct request *rq, int error);
 955 extern bool __blk_end_request_err(struct request *rq, int error);
 956
 957 extern void blk_complete_request(struct request *);
 958 extern void __blk_complete_request(struct request *);
 959 extern void blk_abort_request(struct request *);
 960 extern void blk_unprep_request(struct request *);
 961
 962 /*
 963  * Access functions for manipulating queue properties
 964  */
 965 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
 966                                         spinlock_t *lock, int node_id);
 967 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
 968 extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
 969                                                       request_fn_proc *, spinlock_t *);
 970 extern void blk_cleanup_queue(struct request_queue *);
 971 extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 972 extern void blk_queue_bounce_limit(struct request_queue *, u64);
 973 extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
 974 extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
 975 extern void blk_queue_max_segments(struct request_queue *, unsigned short);
 976 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
 977 extern void blk_queue_max_discard_sectors(struct request_queue *q,
 978                 unsigned int max_discard_sectors);
 979 extern void blk_queue_max_write_same_sectors(struct request_queue *q,
 980                 unsigned int max_write_same_sectors);
 981 extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
 982 extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
 983 extern void blk_queue_alignment_offset(struct request_queue *q,
 984                                        unsigned int alignment);
 985 extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
 986 extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
 987 extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
 988 extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
 989 extern void blk_set_default_limits(struct queue_limits *lim);
 990 extern void blk_set_stacking_limits(struct queue_limits *lim);
 991 extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
 992                             sector_t offset);
 993 extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
 994                             sector_t offset);
 995 extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
 996                               sector_t offset);
 997 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
 998 extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
 999 extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
1000 extern int blk_queue_dma_drain(struct request_queue *q,
1001                                dma_drain_needed_fn *dma_drain_needed,
1002                                void *buf, unsigned int size);
1003 extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
1004 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
1005 extern void blk_queue_virt_boundary(struct request_queue *, unsigned long);
1006 extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
1007 extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn);
1008 extern void blk_queue_dma_alignment(struct request_queue *, int);
1009 extern void blk_queue_update_dma_alignment(struct request_queue *, int);
1010 extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
1011 extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
1012 extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
1013 extern void blk_queue_flush(struct request_queue *q, unsigned int flush);
1014 extern void blk_queue_flush_queueable(struct request_queue *q, bool queueable);
1015 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
1016
1017 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
1018 extern int blk_rq_map_sg_no_cluster
1019         (struct request_queue *, struct request *, struct scatterlist *);
1020 extern void blk_dump_rq_flags(struct request *, char *);
1021 extern long nr_blockdev_pages(void);
1022
1023 bool __must_check blk_get_queue(struct request_queue *);
1024 struct request_queue *blk_alloc_queue(gfp_t);
1025 struct request_queue *blk_alloc_queue_node(gfp_t, int);
1026 extern void blk_put_queue(struct request_queue *);
1027 extern void blk_set_queue_dying(struct request_queue *);
1028
1029 /*
1030  * block layer runtime pm functions
1031  */
1032 #ifdef CONFIG_PM
1033 extern void blk_pm_runtime_init(struct request_queue *q, struct device *dev);
1034 extern int blk_pre_runtime_suspend(struct request_queue *q);
1035 extern void blk_post_runtime_suspend(struct request_queue *q, int err);
1036 extern void blk_pre_runtime_resume(struct request_queue *q);
1037 extern void blk_post_runtime_resume(struct request_queue *q, int err);
1038 #else
1039 static inline void blk_pm_runtime_init(struct request_queue *q,
1040         struct device *dev) {}
1041 static inline int blk_pre_runtime_suspend(struct request_queue *q)
1042 {
1043         return -ENOSYS;
1044 }
1045 static inline void blk_post_runtime_suspend(struct request_queue *q, int err) {}
1046 static inline void blk_pre_runtime_resume(struct request_queue *q) {}
1047 static inline void blk_post_runtime_resume(struct request_queue *q, int err) {}
1048 #endif
1049
1050 /*
1051  * blk_plug permits building a queue of related requests by holding the I/O
1052  * fragments for a short period. This allows merging of sequential requests
1053  * into single larger request. As the requests are moved from a per-task list to
1054  * the device's request_queue in a batch, this results in improved scalability
1055  * as the lock contention for request_queue lock is reduced.
1056  *
1057  * It is ok not to disable preemption when adding the request to the plug list
1058  * or when attempting a merge, because blk_schedule_flush_list() will only flush
1059  * the plug list when the task sleeps by itself. For details, please see
1060  * schedule() where blk_schedule_flush_plug() is called.
1061  */
1062 struct blk_plug {
1063         struct list_head list; /* requests */
1064         struct list_head mq_list; /* blk-mq requests */
1065         struct list_head cb_list; /* md requires an unplug callback */
1066 };
1067 #define BLK_MAX_REQUEST_COUNT 16
1068
1069 struct blk_plug_cb;
1070 typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool);
1071 struct blk_plug_cb {
1072         struct list_head list;
1073         blk_plug_cb_fn callback;
1074         void *data;
1075 };
1076 extern struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug,
1077                                              void *data, int size);
1078 extern void blk_start_plug(struct blk_plug *);
1079 extern void blk_finish_plug(struct blk_plug *);
1080 extern void blk_flush_plug_list(struct blk_plug *, bool);
1081
1082 static inline void blk_flush_plug(struct task_struct *tsk)
1083 {
1084         struct blk_plug *plug = tsk->plug;
1085
1086         if (plug)
1087                 blk_flush_plug_list(plug, false);
1088 }
1089
1090 static inline void blk_schedule_flush_plug(struct task_struct *tsk)
1091 {
1092         struct blk_plug *plug = tsk->plug;
1093
1094         if (plug)
1095                 blk_flush_plug_list(plug, true);
1096 }
1097
1098 static inline bool blk_needs_flush_plug(struct task_struct *tsk)
1099 {
1100         struct blk_plug *plug = tsk->plug;
1101
1102         return plug &&
1103                 (!list_empty(&plug->list) ||
1104                  !list_empty(&plug->mq_list) ||
1105                  !list_empty(&plug->cb_list));
1106 }
1107
1108 /*
1109  * tag stuff
1110  */
1111 extern int blk_queue_start_tag(struct request_queue *, struct request *);
1112 extern struct request *blk_queue_find_tag(struct request_queue *, int);
1113 extern void blk_queue_end_tag(struct request_queue *, struct request *);
1114 extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *, int);
1115 extern void blk_queue_free_tags(struct request_queue *);
1116 extern int blk_queue_resize_tags(struct request_queue *, int);
1117 extern void blk_queue_invalidate_tags(struct request_queue *);
1118 extern struct blk_queue_tag *blk_init_tags(int, int);
1119 extern void blk_free_tags(struct blk_queue_tag *);
1120
1121 static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
1122                                                 int tag)
1123 {
1124         if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
1125                 return NULL;
1126         return bqt->tag_index[tag];
1127 }
1128
1129 #define BLKDEV_DISCARD_SECURE  0x01    /* secure discard */
1130
1131 extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
1132 extern int blkdev_issue_barrier(struct block_device *, gfp_t, sector_t *);
1133 extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
1134                 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
1135 extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
1136                 sector_t nr_sects, gfp_t gfp_mask, struct page *page);
1137 extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
1138                 sector_t nr_sects, gfp_t gfp_mask, bool discard);
1139 static inline int sb_issue_discard(struct super_block *sb, sector_t block,
1140                 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
1141 {
1142         return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),
1143                                     nr_blocks << (sb->s_blocksize_bits - 9),
1144                                     gfp_mask, flags);
1145 }
1146 static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
1147                 sector_t nr_blocks, gfp_t gfp_mask)
1148 {
1149         return blkdev_issue_zeroout(sb->s_bdev,
1150                                     block << (sb->s_blocksize_bits - 9),
1151                                     nr_blocks << (sb->s_blocksize_bits - 9),
1152                                     gfp_mask, true);
1153 }
1154
1155 extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
1156
1157 enum blk_default_limits {
1158         BLK_MAX_SEGMENTS        = 128,
1159         BLK_SAFE_MAX_SECTORS    = 255,
1160         BLK_DEF_MAX_SECTORS     = 2560,
1161         BLK_MAX_SEGMENT_SIZE    = 65536,
1162         BLK_SEG_BOUNDARY_MASK   = 0xFFFFFFFFUL,
1163 };
1164
1165 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
1166
1167 static inline unsigned long queue_bounce_pfn(struct request_queue *q)
1168 {
1169         return q->limits.bounce_pfn;
1170 }
1171
1172 static inline unsigned long queue_segment_boundary(struct request_queue *q)
1173 {
1174         return q->limits.seg_boundary_mask;
1175 }
1176
1177 static inline unsigned long queue_virt_boundary(struct request_queue *q)
1178 {
1179         return q->limits.virt_boundary_mask;
1180 }
1181
1182 static inline unsigned int queue_max_sectors(struct request_queue *q)
1183 {
1184         return q->limits.max_sectors;
1185 }
1186
1187 static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
1188 {
1189         return q->limits.max_hw_sectors;
1190 }
1191
1192 static inline unsigned short queue_max_segments(struct request_queue *q)
1193 {
1194         return q->limits.max_segments;
1195 }
1196
1197 static inline unsigned int queue_max_segment_size(struct request_queue *q)
1198 {
1199         return q->limits.max_segment_size;
1200 }
1201
1202 static inline unsigned short queue_logical_block_size(struct request_queue *q)
1203 {
1204         int retval = 512;
1205
1206         if (q && q->limits.logical_block_size)
1207                 retval = q->limits.logical_block_size;
1208
1209         return retval;
1210 }
1211
1212 static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
1213 {
1214         return queue_logical_block_size(bdev_get_queue(bdev));
1215 }
1216
1217 static inline unsigned int queue_physical_block_size(struct request_queue *q)
1218 {
1219         return q->limits.physical_block_size;
1220 }
1221
1222 static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
1223 {
1224         return queue_physical_block_size(bdev_get_queue(bdev));
1225 }
1226
1227 static inline unsigned int queue_io_min(struct request_queue *q)
1228 {
1229         return q->limits.io_min;
1230 }
1231
1232 static inline int bdev_io_min(struct block_device *bdev)
1233 {
1234         return queue_io_min(bdev_get_queue(bdev));
1235 }
1236
1237 static inline unsigned int queue_io_opt(struct request_queue *q)
1238 {
1239         return q->limits.io_opt;
1240 }
1241
1242 static inline int bdev_io_opt(struct block_device *bdev)
1243 {
1244         return queue_io_opt(bdev_get_queue(bdev));
1245 }
1246
1247 static inline int queue_alignment_offset(struct request_queue *q)
1248 {
1249         if (q->limits.misaligned)
1250                 return -1;
1251
1252         return q->limits.alignment_offset;
1253 }
1254
1255 static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
1256 {
1257         unsigned int granularity = max(lim->physical_block_size, lim->io_min);
1258         unsigned int alignment = sector_div(sector, granularity >> 9) << 9;
1259
1260         return (granularity + lim->alignment_offset - alignment) % granularity;
1261 }
1262
1263 static inline int bdev_alignment_offset(struct block_device *bdev)
1264 {
1265         struct request_queue *q = bdev_get_queue(bdev);
1266
1267         if (q->limits.misaligned)
1268                 return -1;
1269
1270         if (bdev != bdev->bd_contains)
1271                 return bdev->bd_part->alignment_offset;
1272
1273         return q->limits.alignment_offset;
1274 }
1275
1276 static inline int queue_discard_alignment(struct request_queue *q)
1277 {
1278         if (q->limits.discard_misaligned)
1279                 return -1;
1280
1281         return q->limits.discard_alignment;
1282 }
1283
1284 static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
1285 {
1286         unsigned int alignment, granularity, offset;
1287
1288         if (!lim->max_discard_sectors)
1289                 return 0;
1290
1291         /* Why are these in bytes, not sectors? */
1292         alignment = lim->discard_alignment >> 9;
1293         granularity = lim->discard_granularity >> 9;
1294         if (!granularity)
1295                 return 0;
1296
1297         /* Offset of the partition start in 'granularity' sectors */
1298         offset = sector_div(sector, granularity);
1299
1300         /* And why do we do this modulus *again* in blkdev_issue_discard()? */
1301         offset = (granularity + alignment - offset) % granularity;
1302
1303         /* Turn it back into bytes, gaah */
1304         return offset << 9;
1305 }
1306
1307 static inline int bdev_discard_alignment(struct block_device *bdev)
1308 {
1309         struct request_queue *q = bdev_get_queue(bdev);
1310
1311         if (bdev != bdev->bd_contains)
1312                 return bdev->bd_part->discard_alignment;
1313
1314         return q->limits.discard_alignment;
1315 }
1316
1317 static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
1318 {
1319         if (q->limits.max_discard_sectors && q->limits.discard_zeroes_data == 1)
1320                 return 1;
1321
1322         return 0;
1323 }
1324
1325 static inline unsigned int bdev_discard_zeroes_data(struct block_device *bdev)
1326 {
1327         return queue_discard_zeroes_data(bdev_get_queue(bdev));
1328 }
1329
1330 static inline unsigned int bdev_write_same(struct block_device *bdev)
1331 {
1332         struct request_queue *q = bdev_get_queue(bdev);
1333
1334         if (q)
1335                 return q->limits.max_write_same_sectors;
1336
1337         return 0;
1338 }
1339
1340 static inline int queue_dma_alignment(struct request_queue *q)
1341 {
1342         return q ? q->dma_alignment : 511;
1343 }
1344
1345 static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
1346                                  unsigned int len)
1347 {
1348         unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1349         return !(addr & alignment) && !(len & alignment);
1350 }
1351
1352 /* assumes size > 256 */
1353 static inline unsigned int blksize_bits(unsigned int size)
1354 {
1355         unsigned int bits = 8;
1356         do {
1357                 bits++;
1358                 size >>= 1;
1359         } while (size > 256);
1360         return bits;
1361 }
1362
1363 static inline unsigned int block_size(struct block_device *bdev)
1364 {
1365         return bdev->bd_block_size;
1366 }
1367
1368 static inline bool queue_flush_queueable(struct request_queue *q)
1369 {
1370         return !q->flush_not_queueable;
1371 }
1372
1373 typedef struct {struct page *v;} Sector;
1374
1375 unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
1376
1377 static inline void put_dev_sector(Sector p)
1378 {
1379         page_cache_release(p.v);
1380 }
1381
1382 static inline bool __bvec_gap_to_prev(struct request_queue *q,
1383                                 struct bio_vec *bprv, unsigned int offset)
1384 {
1385         return offset ||
1386                 ((bprv->bv_offset + bprv->bv_len) & queue_virt_boundary(q));
1387 }
1388
1389 /*
1390  * Check if adding a bio_vec after bprv with offset would create a gap in
1391  * the SG list. Most drivers don't care about this, but some do.
1392  */
1393 static inline bool bvec_gap_to_prev(struct request_queue *q,
1394                                 struct bio_vec *bprv, unsigned int offset)
1395 {
1396         if (!queue_virt_boundary(q))
1397                 return false;
1398         return __bvec_gap_to_prev(q, bprv, offset);
1399 }
1400
1401 static inline bool bio_will_gap(struct request_queue *q, struct bio *prev,
1402                          struct bio *next)
1403 {
1404         if (bio_has_data(prev) && queue_virt_boundary(q)) {
1405                 struct bio_vec pb, nb;
1406
1407                 bio_get_last_bvec(prev, &pb);
1408                 bio_get_first_bvec(next, &nb);
1409
1410                 return __bvec_gap_to_prev(q, &pb, nb.bv_offset);
1411         }
1412
1413         return false;
1414 }
1415
1416 static inline bool req_gap_back_merge(struct request *req, struct bio *bio)
1417 {
1418         return bio_will_gap(req->q, req->biotail, bio);
1419 }
1420
1421 static inline bool req_gap_front_merge(struct request *req, struct bio *bio)
1422 {
1423         return bio_will_gap(req->q, bio, req->bio);
1424 }
1425
1426 struct work_struct;
1427 int kblockd_schedule_work(struct work_struct *work);
1428 int kblockd_schedule_delayed_work(struct delayed_work *dwork, unsigned long delay);
1429 int kblockd_schedule_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
1430
1431 #ifdef CONFIG_BLK_CGROUP
1432 /*
1433  * This should not be using sched_clock(). A real patch is in progress
1434  * to fix this up, until that is in place we need to disable preemption
1435  * around sched_clock() in this function and set_io_start_time_ns().
1436  */
1437 static inline void set_start_time_ns(struct request *req)
1438 {
1439         preempt_disable();
1440         req->start_time_ns = sched_clock();
1441         preempt_enable();
1442 }
1443
1444 static inline void set_io_start_time_ns(struct request *req)
1445 {
1446         preempt_disable();
1447         req->io_start_time_ns = sched_clock();
1448         preempt_enable();
1449 }
1450
1451 static inline uint64_t rq_start_time_ns(struct request *req)
1452 {
1453         return req->start_time_ns;
1454 }
1455
1456 static inline uint64_t rq_io_start_time_ns(struct request *req)
1457 {
1458         return req->io_start_time_ns;
1459 }
1460 #else
1461 static inline void set_start_time_ns(struct request *req) {}
1462 static inline void set_io_start_time_ns(struct request *req) {}
1463 static inline uint64_t rq_start_time_ns(struct request *req)
1464 {
1465         return 0;
1466 }
1467 static inline uint64_t rq_io_start_time_ns(struct request *req)
1468 {
1469         return 0;
1470 }
1471 #endif
1472
1473 #define MODULE_ALIAS_BLOCKDEV(major,minor) \
1474         MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
1475 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
1476         MODULE_ALIAS("block-major-" __stringify(major) "-*")
1477
1478 #if defined(CONFIG_BLK_DEV_INTEGRITY)
1479
1480 enum blk_integrity_flags {
1481         BLK_INTEGRITY_VERIFY            = 1 << 0,
1482         BLK_INTEGRITY_GENERATE          = 1 << 1,
1483         BLK_INTEGRITY_DEVICE_CAPABLE    = 1 << 2,
1484         BLK_INTEGRITY_IP_CHECKSUM       = 1 << 3,
1485 };
1486
1487 struct blk_integrity_iter {
1488         void                    *prot_buf;
1489         void                    *data_buf;
1490         sector_t                seed;
1491         unsigned int            data_size;
1492         unsigned short          interval;
1493         const char              *disk_name;
1494 };
1495
1496 typedef int (integrity_processing_fn) (struct blk_integrity_iter *);
1497
1498 struct blk_integrity_profile {
1499         integrity_processing_fn         *generate_fn;
1500         integrity_processing_fn         *verify_fn;
1501         const char                      *name;
1502 };
1503
1504 extern void blk_integrity_register(struct gendisk *, struct blk_integrity *);
1505 extern void blk_integrity_unregister(struct gendisk *);
1506 extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
1507 extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
1508                                    struct scatterlist *);
1509 extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
1510 extern bool blk_integrity_merge_rq(struct request_queue *, struct request *,
1511                                    struct request *);
1512 extern bool blk_integrity_merge_bio(struct request_queue *, struct request *,
1513                                     struct bio *);
1514
1515 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
1516 {
1517         struct blk_integrity *bi = &disk->queue->integrity;
1518
1519         if (!bi->profile)
1520                 return NULL;
1521
1522         return bi;
1523 }
1524
1525 static inline
1526 struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
1527 {
1528         return blk_get_integrity(bdev->bd_disk);
1529 }
1530
1531 static inline bool blk_integrity_rq(struct request *rq)
1532 {
1533         return rq->cmd_flags & REQ_INTEGRITY;
1534 }
1535
1536 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
1537                                                     unsigned int segs)
1538 {
1539         q->limits.max_integrity_segments = segs;
1540 }
1541
1542 static inline unsigned short
1543 queue_max_integrity_segments(struct request_queue *q)
1544 {
1545         return q->limits.max_integrity_segments;
1546 }
1547
1548 static inline bool integrity_req_gap_back_merge(struct request *req,
1549                                                 struct bio *next)
1550 {
1551         struct bio_integrity_payload *bip = bio_integrity(req->bio);
1552         struct bio_integrity_payload *bip_next = bio_integrity(next);
1553
1554         return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
1555                                 bip_next->bip_vec[0].bv_offset);
1556 }
1557
1558 static inline bool integrity_req_gap_front_merge(struct request *req,
1559                                                  struct bio *bio)
1560 {
1561         struct bio_integrity_payload *bip = bio_integrity(bio);
1562         struct bio_integrity_payload *bip_next = bio_integrity(req->bio);
1563
1564         return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
1565                                 bip_next->bip_vec[0].bv_offset);
1566 }
1567
1568 #else /* CONFIG_BLK_DEV_INTEGRITY */
1569
1570 struct bio;
1571 struct block_device;
1572 struct gendisk;
1573 struct blk_integrity;
1574
1575 static inline int blk_integrity_rq(struct request *rq)
1576 {
1577         return 0;
1578 }
1579 static inline int blk_rq_count_integrity_sg(struct request_queue *q,
1580                                             struct bio *b)
1581 {
1582         return 0;
1583 }
1584 static inline int blk_rq_map_integrity_sg(struct request_queue *q,
1585                                           struct bio *b,
1586                                           struct scatterlist *s)
1587 {
1588         return 0;
1589 }
1590 static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
1591 {
1592         return NULL;
1593 }
1594 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
1595 {
1596         return NULL;
1597 }
1598 static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
1599 {
1600         return 0;
1601 }
1602 static inline void blk_integrity_register(struct gendisk *d,
1603                                          struct blk_integrity *b)
1604 {
1605 }
1606 static inline void blk_integrity_unregister(struct gendisk *d)
1607 {
1608 }
1609 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
1610                                                     unsigned int segs)
1611 {
1612 }
1613 static inline unsigned short queue_max_integrity_segments(struct request_queue *q)
1614 {
1615         return 0;
1616 }
1617 static inline bool blk_integrity_merge_rq(struct request_queue *rq,
1618                                           struct request *r1,
1619                                           struct request *r2)
1620 {
1621         return true;
1622 }
1623 static inline bool blk_integrity_merge_bio(struct request_queue *rq,
1624                                            struct request *r,
1625                                            struct bio *b)
1626 {
1627         return true;
1628 }
1629
1630 static inline bool integrity_req_gap_back_merge(struct request *req,
1631                                                 struct bio *next)
1632 {
1633         return false;
1634 }
1635 static inline bool integrity_req_gap_front_merge(struct request *req,
1636                                                  struct bio *bio)
1637 {
1638         return false;
1639 }
1640
1641 #endif /* CONFIG_BLK_DEV_INTEGRITY */
1642
1643 struct block_device_operations {
1644         int (*open) (struct block_device *, fmode_t);
1645         void (*release) (struct gendisk *, fmode_t);
1646         int (*rw_page)(struct block_device *, sector_t, struct page *, int rw);
1647         int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1648         int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1649         long (*direct_access)(struct block_device *, sector_t, void __pmem **,
1650                         unsigned long *pfn);
1651         unsigned int (*check_events) (struct gendisk *disk,
1652                                       unsigned int clearing);
1653         /* ->media_changed() is DEPRECATED, use ->check_events() instead */
1654         int (*media_changed) (struct gendisk *);
1655         void (*unlock_native_capacity) (struct gendisk *);
1656         int (*revalidate_disk) (struct gendisk *);
1657         int (*getgeo)(struct block_device *, struct hd_geometry *);
1658         /* this callback is with swap_lock and sometimes page table lock held */
1659         void (*swap_slot_free_notify) (struct block_device *, unsigned long);
1660         struct module *owner;
1661         const struct pr_ops *pr_ops;
1662 };
1663
1664 extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
1665                                  unsigned long);
1666 extern int bdev_read_page(struct block_device *, sector_t, struct page *);
1667 extern int bdev_write_page(struct block_device *, sector_t, struct page *,
1668                                                 struct writeback_control *);
1669 extern long bdev_direct_access(struct block_device *, sector_t,
1670                 void __pmem **addr, unsigned long *pfn, long size);
1671
1672 /*
1673  * X-axis for IO latency histogram support.
1674  */
1675 static const u_int64_t latency_x_axis_us[] = {
1676         100,
1677         200,
1678         300,
1679         400,
1680         500,
1681         600,
1682         700,
1683         800,
1684         900,
1685         1000,
1686         1200,
1687         1400,
1688         1600,
1689         1800,
1690         2000,
1691         2500,
1692         3000,
1693         4000,
1694         5000,
1695         6000,
1696         7000,
1697         9000,
1698         10000
1699 };
1700
1701 #define BLK_IO_LAT_HIST_DISABLE         0
1702 #define BLK_IO_LAT_HIST_ENABLE          1
1703 #define BLK_IO_LAT_HIST_ZERO            2
1704
1705 struct io_latency_state {
1706         u_int64_t       latency_y_axis[ARRAY_SIZE(latency_x_axis_us) + 1];
1707         u_int64_t       latency_elems;
1708         u_int64_t       latency_sum;
1709 };
1710
1711 static inline void
1712 blk_update_latency_hist(struct io_latency_state *s, u_int64_t delta_us)
1713 {
1714         int i;
1715
1716         for (i = 0; i < ARRAY_SIZE(latency_x_axis_us); i++)
1717                 if (delta_us < (u_int64_t)latency_x_axis_us[i])
1718                         break;
1719         s->latency_y_axis[i]++;
1720         s->latency_elems++;
1721         s->latency_sum += delta_us;
1722 }
1723
1724 ssize_t blk_latency_hist_show(char* name, struct io_latency_state *s,
1725                 char *buf, int buf_size);
1726
1727 #else /* CONFIG_BLOCK */
1728
1729 struct block_device;
1730
1731 /*
1732  * stubs for when the block layer is configured out
1733  */
1734 #define buffer_heads_over_limit 0
1735
1736 static inline long nr_blockdev_pages(void)
1737 {
1738         return 0;
1739 }
1740
1741 struct blk_plug {
1742 };
1743
1744 static inline void blk_start_plug(struct blk_plug *plug)
1745 {
1746 }
1747
1748 static inline void blk_finish_plug(struct blk_plug *plug)
1749 {
1750 }
1751
1752 static inline void blk_flush_plug(struct task_struct *task)
1753 {
1754 }
1755
1756 static inline void blk_schedule_flush_plug(struct task_struct *task)
1757 {
1758 }
1759
1760
1761 static inline bool blk_needs_flush_plug(struct task_struct *tsk)
1762 {
1763         return false;
1764 }
1765
1766 static inline int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
1767                                      sector_t *error_sector)
1768 {
1769         return 0;
1770 }
1771
1772 #endif /* CONFIG_BLOCK */
1773
1774 #endif