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