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