home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / blkdev.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  33.5 KB  |  1,090 lines
  1. #ifndef _LINUX_BLKDEV_H
  2. #define _LINUX_BLKDEV_H
  3.  
  4. #ifdef CONFIG_BLOCK
  5.  
  6. #include <linux/sched.h>
  7. #include <linux/major.h>
  8. #include <linux/genhd.h>
  9. #include <linux/list.h>
  10. #include <linux/timer.h>
  11. #include <linux/workqueue.h>
  12. #include <linux/pagemap.h>
  13. #include <linux/backing-dev.h>
  14. #include <linux/wait.h>
  15. #include <linux/mempool.h>
  16. #include <linux/bio.h>
  17. #include <linux/module.h>
  18. #include <linux/stringify.h>
  19. #include <linux/gfp.h>
  20. #include <linux/bsg.h>
  21. #include <linux/smp.h>
  22.  
  23. #include <asm/scatterlist.h>
  24.  
  25. struct scsi_ioctl_command;
  26.  
  27. struct request_queue;
  28. struct elevator_queue;
  29. typedef struct elevator_queue elevator_t;
  30. struct request_pm_state;
  31. struct blk_trace;
  32. struct request;
  33. struct sg_io_hdr;
  34.  
  35. #define BLKDEV_MIN_RQ    4
  36. #define BLKDEV_MAX_RQ    128    /* Default maximum */
  37.  
  38. struct request;
  39. typedef void (rq_end_io_fn)(struct request *, int);
  40.  
  41. struct request_list {
  42.     int count[2];
  43.     int starved[2];
  44.     int elvpriv;
  45.     mempool_t *rq_pool;
  46.     wait_queue_head_t wait[2];
  47. };
  48.  
  49. /*
  50.  * request command types
  51.  */
  52. enum rq_cmd_type_bits {
  53.     REQ_TYPE_FS        = 1,    /* fs request */
  54.     REQ_TYPE_BLOCK_PC,        /* scsi command */
  55.     REQ_TYPE_SENSE,            /* sense request */
  56.     REQ_TYPE_PM_SUSPEND,        /* suspend request */
  57.     REQ_TYPE_PM_RESUME,        /* resume request */
  58.     REQ_TYPE_PM_SHUTDOWN,        /* shutdown request */
  59.     REQ_TYPE_SPECIAL,        /* driver defined type */
  60.     REQ_TYPE_LINUX_BLOCK,        /* generic block layer message */
  61.     /*
  62.      * for ATA/ATAPI devices. this really doesn't belong here, ide should
  63.      * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
  64.      * private REQ_LB opcodes to differentiate what type of request this is
  65.      */
  66.     REQ_TYPE_ATA_TASKFILE,
  67.     REQ_TYPE_ATA_PC,
  68. };
  69.  
  70. /*
  71.  * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
  72.  * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
  73.  * SCSI cdb.
  74.  *
  75.  * 0x00 -> 0x3f are driver private, to be used for whatever purpose they need,
  76.  * typically to differentiate REQ_TYPE_SPECIAL requests.
  77.  *
  78.  */
  79. enum {
  80.     REQ_LB_OP_EJECT    = 0x40,        /* eject request */
  81.     REQ_LB_OP_FLUSH = 0x41,        /* flush request */
  82.     REQ_LB_OP_DISCARD = 0x42,    /* discard sectors */
  83. };
  84.  
  85. /*
  86.  * request type modified bits. first two bits match BIO_RW* bits, important
  87.  */
  88. enum rq_flag_bits {
  89.     __REQ_RW,        /* not set, read. set, write */
  90.     __REQ_FAILFAST_DEV,    /* no driver retries of device errors */
  91.     __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */
  92.     __REQ_FAILFAST_DRIVER,    /* no driver retries of driver errors */
  93.     __REQ_DISCARD,        /* request to discard sectors */
  94.     __REQ_SORTED,        /* elevator knows about this request */
  95.     __REQ_SOFTBARRIER,    /* may not be passed by ioscheduler */
  96.     __REQ_HARDBARRIER,    /* may not be passed by drive either */
  97.     __REQ_FUA,        /* forced unit access */
  98.     __REQ_NOMERGE,        /* don't touch this for merging */
  99.     __REQ_STARTED,        /* drive already may have started this one */
  100.     __REQ_DONTPREP,        /* don't call prep for this one */
  101.     __REQ_QUEUED,        /* uses queueing */
  102.     __REQ_ELVPRIV,        /* elevator private data attached */
  103.     __REQ_FAILED,        /* set if the request failed */
  104.     __REQ_QUIET,        /* don't worry about errors */
  105.     __REQ_PREEMPT,        /* set for "ide_preempt" requests */
  106.     __REQ_ORDERED_COLOR,    /* is before or after barrier */
  107.     __REQ_RW_SYNC,        /* request is sync (O_DIRECT) */
  108.     __REQ_ALLOCED,        /* request came from our alloc pool */
  109.     __REQ_RW_META,        /* metadata io request */
  110.     __REQ_COPY_USER,    /* contains copies of user pages */
  111.     __REQ_INTEGRITY,    /* integrity metadata has been remapped */
  112.     __REQ_NR_BITS,        /* stops here */
  113. };
  114.  
  115. #define REQ_RW        (1 << __REQ_RW)
  116. #define REQ_FAILFAST_DEV    (1 << __REQ_FAILFAST_DEV)
  117. #define REQ_FAILFAST_TRANSPORT    (1 << __REQ_FAILFAST_TRANSPORT)
  118. #define REQ_FAILFAST_DRIVER    (1 << __REQ_FAILFAST_DRIVER)
  119. #define REQ_DISCARD    (1 << __REQ_DISCARD)
  120. #define REQ_SORTED    (1 << __REQ_SORTED)
  121. #define REQ_SOFTBARRIER    (1 << __REQ_SOFTBARRIER)
  122. #define REQ_HARDBARRIER    (1 << __REQ_HARDBARRIER)
  123. #define REQ_FUA        (1 << __REQ_FUA)
  124. #define REQ_NOMERGE    (1 << __REQ_NOMERGE)
  125. #define REQ_STARTED    (1 << __REQ_STARTED)
  126. #define REQ_DONTPREP    (1 << __REQ_DONTPREP)
  127. #define REQ_QUEUED    (1 << __REQ_QUEUED)
  128. #define REQ_ELVPRIV    (1 << __REQ_ELVPRIV)
  129. #define REQ_FAILED    (1 << __REQ_FAILED)
  130. #define REQ_QUIET    (1 << __REQ_QUIET)
  131. #define REQ_PREEMPT    (1 << __REQ_PREEMPT)
  132. #define REQ_ORDERED_COLOR    (1 << __REQ_ORDERED_COLOR)
  133. #define REQ_RW_SYNC    (1 << __REQ_RW_SYNC)
  134. #define REQ_ALLOCED    (1 << __REQ_ALLOCED)
  135. #define REQ_RW_META    (1 << __REQ_RW_META)
  136. #define REQ_COPY_USER    (1 << __REQ_COPY_USER)
  137. #define REQ_INTEGRITY    (1 << __REQ_INTEGRITY)
  138.  
  139. #define BLK_MAX_CDB    16
  140.  
  141. /*
  142.  * try to put the fields that are referenced together in the same cacheline.
  143.  * if you modify this structure, be sure to check block/blk-core.c:rq_init()
  144.  * as well!
  145.  */
  146. struct request {
  147.     struct list_head queuelist;
  148.     struct call_single_data csd;
  149.     int cpu;
  150.  
  151.     struct request_queue *q;
  152.  
  153.     unsigned int cmd_flags;
  154.     enum rq_cmd_type_bits cmd_type;
  155.     unsigned long atomic_flags;
  156.  
  157.     /* Maintain bio traversal state for part by part I/O submission.
  158.      * hard_* are block layer internals, no driver should touch them!
  159.      */
  160.  
  161.     sector_t sector;        /* next sector to submit */
  162.     sector_t hard_sector;        /* next sector to complete */
  163.     unsigned long nr_sectors;    /* no. of sectors left to submit */
  164.     unsigned long hard_nr_sectors;    /* no. of sectors left to complete */
  165.     /* no. of sectors left to submit in the current segment */
  166.     unsigned int current_nr_sectors;
  167.  
  168.     /* no. of sectors left to complete in the current segment */
  169.     unsigned int hard_cur_sectors;
  170.  
  171.     struct bio *bio;
  172.     struct bio *biotail;
  173.  
  174.     struct hlist_node hash;    /* merge hash */
  175.     /*
  176.      * The rb_node is only used inside the io scheduler, requests
  177.      * are pruned when moved to the dispatch queue. So let the
  178.      * completion_data share space with the rb_node.
  179.      */
  180.     union {
  181.         struct rb_node rb_node;    /* sort/lookup */
  182.         void *completion_data;
  183.     };
  184.  
  185.     /*
  186.      * two pointers are available for the IO schedulers, if they need
  187.      * more they have to dynamically allocate it.
  188.      */
  189.     void *elevator_private;
  190.     void *elevator_private2;
  191.  
  192.     struct gendisk *rq_disk;
  193.     unsigned long start_time;
  194.  
  195.     /* Number of scatter-gather DMA addr+len pairs after
  196.      * physical address coalescing is performed.
  197.      */
  198.     unsigned short nr_phys_segments;
  199.  
  200.     unsigned short ioprio;
  201.  
  202.     void *special;
  203.     char *buffer;
  204.  
  205.     int tag;
  206.     int errors;
  207.  
  208.     int ref_count;
  209.  
  210.     /*
  211.      * when request is used as a packet command carrier
  212.      */
  213.     unsigned short cmd_len;
  214.     unsigned char __cmd[BLK_MAX_CDB];
  215.     unsigned char *cmd;
  216.  
  217.     unsigned int data_len;
  218.     unsigned int extra_len;    /* length of alignment and padding */
  219.     unsigned int sense_len;
  220.     void *data;
  221.     void *sense;
  222.  
  223.     unsigned long deadline;
  224.     struct list_head timeout_list;
  225.     unsigned int timeout;
  226.     int retries;
  227.  
  228.     /*
  229.      * completion callback.
  230.      */
  231.     rq_end_io_fn *end_io;
  232.     void *end_io_data;
  233.  
  234.     /* for bidi */
  235.     struct request *next_rq;
  236. };
  237.  
  238. static inline unsigned short req_get_ioprio(struct request *req)
  239. {
  240.     return req->ioprio;
  241. }
  242.  
  243. /*
  244.  * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME
  245.  * requests. Some step values could eventually be made generic.
  246.  */
  247. struct request_pm_state
  248. {
  249.     /* PM state machine step value, currently driver specific */
  250.     int    pm_step;
  251.     /* requested PM state value (S1, S2, S3, S4, ...) */
  252.     u32    pm_state;
  253.     void*    data;        /* for driver use */
  254. };
  255.  
  256. #include <linux/elevator.h>
  257.  
  258. typedef void (request_fn_proc) (struct request_queue *q);
  259. typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
  260. typedef int (prep_rq_fn) (struct request_queue *, struct request *);
  261. typedef void (unplug_fn) (struct request_queue *);
  262. typedef int (prepare_discard_fn) (struct request_queue *, struct request *);
  263.  
  264. struct bio_vec;
  265. struct bvec_merge_data {
  266.     struct block_device *bi_bdev;
  267.     sector_t bi_sector;
  268.     unsigned bi_size;
  269.     unsigned long bi_rw;
  270. };
  271. typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
  272.                  struct bio_vec *);
  273. typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
  274. typedef void (softirq_done_fn)(struct request *);
  275. typedef int (dma_drain_needed_fn)(struct request *);
  276. typedef int (lld_busy_fn) (struct request_queue *q);
  277.  
  278. enum blk_eh_timer_return {
  279.     BLK_EH_NOT_HANDLED,
  280.     BLK_EH_HANDLED,
  281.     BLK_EH_RESET_TIMER,
  282. };
  283.  
  284. typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *);
  285.  
  286. enum blk_queue_state {
  287.     Queue_down,
  288.     Queue_up,
  289. };
  290.  
  291. struct blk_queue_tag {
  292.     struct request **tag_index;    /* map of busy tags */
  293.     unsigned long *tag_map;        /* bit map of free/busy tags */
  294.     int busy;            /* current depth */
  295.     int max_depth;            /* what we will send to device */
  296.     int real_max_depth;        /* what the array can hold */
  297.     atomic_t refcnt;        /* map can be shared */
  298. };
  299.  
  300. #define BLK_SCSI_MAX_CMDS    (256)
  301. #define BLK_SCSI_CMD_PER_LONG    (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
  302.  
  303. struct blk_cmd_filter {
  304.     unsigned long read_ok[BLK_SCSI_CMD_PER_LONG];
  305.     unsigned long write_ok[BLK_SCSI_CMD_PER_LONG];
  306.     struct kobject kobj;
  307. };
  308.  
  309. struct request_queue
  310. {
  311.     /*
  312.      * Together with queue_head for cacheline sharing
  313.      */
  314.     struct list_head    queue_head;
  315.     struct request        *last_merge;
  316.     elevator_t        *elevator;
  317.  
  318.     /*
  319.      * the queue request freelist, one for reads and one for writes
  320.      */
  321.     struct request_list    rq;
  322.  
  323.     request_fn_proc        *request_fn;
  324.     make_request_fn        *make_request_fn;
  325.     prep_rq_fn        *prep_rq_fn;
  326.     unplug_fn        *unplug_fn;
  327.     prepare_discard_fn    *prepare_discard_fn;
  328.     merge_bvec_fn        *merge_bvec_fn;
  329.     prepare_flush_fn    *prepare_flush_fn;
  330.     softirq_done_fn        *softirq_done_fn;
  331.     rq_timed_out_fn        *rq_timed_out_fn;
  332.     dma_drain_needed_fn    *dma_drain_needed;
  333.     lld_busy_fn        *lld_busy_fn;
  334.  
  335.     /*
  336.      * Dispatch queue sorting
  337.      */
  338.     sector_t        end_sector;
  339.     struct request        *boundary_rq;
  340.  
  341.     /*
  342.      * Auto-unplugging state
  343.      */
  344.     struct timer_list    unplug_timer;
  345.     int            unplug_thresh;    /* After this many requests */
  346.     unsigned long        unplug_delay;    /* After this many jiffies */
  347.     struct work_struct    unplug_work;
  348.  
  349.     struct backing_dev_info    backing_dev_info;
  350.  
  351.     /*
  352.      * The queue owner gets to use this for whatever they like.
  353.      * ll_rw_blk doesn't touch it.
  354.      */
  355.     void            *queuedata;
  356.  
  357.     /*
  358.      * queue needs bounce pages for pages above this limit
  359.      */
  360.     unsigned long        bounce_pfn;
  361.     gfp_t            bounce_gfp;
  362.  
  363.     /*
  364.      * various queue flags, see QUEUE_* below
  365.      */
  366.     unsigned long        queue_flags;
  367.  
  368.     /*
  369.      * protects queue structures from reentrancy. ->__queue_lock should
  370.      * _never_ be used directly, it is queue private. always use
  371.      * ->queue_lock.
  372.      */
  373.     spinlock_t        __queue_lock;
  374.     spinlock_t        *queue_lock;
  375.  
  376.     /*
  377.      * queue kobject
  378.      */
  379.     struct kobject kobj;
  380.  
  381.     /*
  382.      * queue settings
  383.      */
  384.     unsigned long        nr_requests;    /* Max # of requests */
  385.     unsigned int        nr_congestion_on;
  386.     unsigned int        nr_congestion_off;
  387.     unsigned int        nr_batching;
  388.  
  389.     unsigned int        max_sectors;
  390.     unsigned int        max_hw_sectors;
  391.     unsigned short        max_phys_segments;
  392.     unsigned short        max_hw_segments;
  393.     unsigned short        hardsect_size;
  394.     unsigned int        max_segment_size;
  395.  
  396.     unsigned long        seg_boundary_mask;
  397.     void            *dma_drain_buffer;
  398.     unsigned int        dma_drain_size;
  399.     unsigned int        dma_pad_mask;
  400.     unsigned int        dma_alignment;
  401.  
  402.     struct blk_queue_tag    *queue_tags;
  403.     struct list_head    tag_busy_list;
  404.  
  405.     unsigned int        nr_sorted;
  406.     unsigned int        in_flight;
  407.  
  408.     unsigned int        rq_timeout;
  409.     struct timer_list    timeout;
  410.     struct list_head    timeout_list;
  411.  
  412.     /*
  413.      * sg stuff
  414.      */
  415.     unsigned int        sg_timeout;
  416.     unsigned int        sg_reserved_size;
  417.     int            node;
  418. #ifdef CONFIG_BLK_DEV_IO_TRACE
  419.     struct blk_trace    *blk_trace;
  420. #endif
  421.     /*
  422.      * reserved for flush operations
  423.      */
  424.     unsigned int        ordered, next_ordered, ordseq;
  425.     int            orderr, ordcolor;
  426.     struct request        pre_flush_rq, bar_rq, post_flush_rq;
  427.     struct request        *orig_bar_rq;
  428.  
  429.     struct mutex        sysfs_lock;
  430.  
  431. #if defined(CONFIG_BLK_DEV_BSG)
  432.     struct bsg_class_device bsg_dev;
  433. #endif
  434.     struct blk_cmd_filter cmd_filter;
  435. };
  436.  
  437. #define QUEUE_FLAG_CLUSTER    0    /* cluster several segments into 1 */
  438. #define QUEUE_FLAG_QUEUED    1    /* uses generic tag queueing */
  439. #define QUEUE_FLAG_STOPPED    2    /* queue is stopped */
  440. #define    QUEUE_FLAG_READFULL    3    /* read queue has been filled */
  441. #define QUEUE_FLAG_WRITEFULL    4    /* write queue has been filled */
  442. #define QUEUE_FLAG_DEAD        5    /* queue being torn down */
  443. #define QUEUE_FLAG_REENTER    6    /* Re-entrancy avoidance */
  444. #define QUEUE_FLAG_PLUGGED    7    /* queue is plugged */
  445. #define QUEUE_FLAG_ELVSWITCH    8    /* don't use elevator, just do FIFO */
  446. #define QUEUE_FLAG_BIDI        9    /* queue supports bidi requests */
  447. #define QUEUE_FLAG_NOMERGES    10    /* disable merge attempts */
  448. #define QUEUE_FLAG_SAME_COMP   11    /* force complete on same CPU */
  449. #define QUEUE_FLAG_FAIL_IO     12    /* fake timeout */
  450. #define QUEUE_FLAG_STACKABLE   13    /* supports request stacking */
  451. #define QUEUE_FLAG_NONROT      14    /* non-rotational device (SSD) */
  452.  
  453. static inline int queue_is_locked(struct request_queue *q)
  454. {
  455. #ifdef CONFIG_SMP
  456.     spinlock_t *lock = q->queue_lock;
  457.     return lock && spin_is_locked(lock);
  458. #else
  459.     return 1;
  460. #endif
  461. }
  462.  
  463. static inline void queue_flag_set_unlocked(unsigned int flag,
  464.                        struct request_queue *q)
  465. {
  466.     __set_bit(flag, &q->queue_flags);
  467. }
  468.  
  469. static inline int queue_flag_test_and_clear(unsigned int flag,
  470.                         struct request_queue *q)
  471. {
  472.     WARN_ON_ONCE(!queue_is_locked(q));
  473.  
  474.     if (test_bit(flag, &q->queue_flags)) {
  475.         __clear_bit(flag, &q->queue_flags);
  476.         return 1;
  477.     }
  478.  
  479.     return 0;
  480. }
  481.  
  482. static inline int queue_flag_test_and_set(unsigned int flag,
  483.                       struct request_queue *q)
  484. {
  485.     WARN_ON_ONCE(!queue_is_locked(q));
  486.  
  487.     if (!test_bit(flag, &q->queue_flags)) {
  488.         __set_bit(flag, &q->queue_flags);
  489.         return 0;
  490.     }
  491.  
  492.     return 1;
  493. }
  494.  
  495. static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
  496. {
  497.     WARN_ON_ONCE(!queue_is_locked(q));
  498.     __set_bit(flag, &q->queue_flags);
  499. }
  500.  
  501. static inline void queue_flag_clear_unlocked(unsigned int flag,
  502.                          struct request_queue *q)
  503. {
  504.     __clear_bit(flag, &q->queue_flags);
  505. }
  506.  
  507. static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
  508. {
  509.     WARN_ON_ONCE(!queue_is_locked(q));
  510.     __clear_bit(flag, &q->queue_flags);
  511. }
  512.  
  513. enum {
  514.     /*
  515.      * Hardbarrier is supported with one of the following methods.
  516.      *
  517.      * NONE        : hardbarrier unsupported
  518.      * DRAIN    : ordering by draining is enough
  519.      * DRAIN_FLUSH    : ordering by draining w/ pre and post flushes
  520.      * DRAIN_FUA    : ordering by draining w/ pre flush and FUA write
  521.      * TAG        : ordering by tag is enough
  522.      * TAG_FLUSH    : ordering by tag w/ pre and post flushes
  523.      * TAG_FUA    : ordering by tag w/ pre flush and FUA write
  524.      */
  525.     QUEUE_ORDERED_NONE    = 0x00,
  526.     QUEUE_ORDERED_DRAIN    = 0x01,
  527.     QUEUE_ORDERED_TAG    = 0x02,
  528.  
  529.     QUEUE_ORDERED_PREFLUSH    = 0x10,
  530.     QUEUE_ORDERED_POSTFLUSH    = 0x20,
  531.     QUEUE_ORDERED_FUA    = 0x40,
  532.  
  533.     QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN |
  534.             QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
  535.     QUEUE_ORDERED_DRAIN_FUA    = QUEUE_ORDERED_DRAIN |
  536.             QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
  537.     QUEUE_ORDERED_TAG_FLUSH    = QUEUE_ORDERED_TAG |
  538.             QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
  539.     QUEUE_ORDERED_TAG_FUA    = QUEUE_ORDERED_TAG |
  540.             QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
  541.  
  542.     /*
  543.      * Ordered operation sequence
  544.      */
  545.     QUEUE_ORDSEQ_STARTED    = 0x01,    /* flushing in progress */
  546.     QUEUE_ORDSEQ_DRAIN    = 0x02,    /* waiting for the queue to be drained */
  547.     QUEUE_ORDSEQ_PREFLUSH    = 0x04,    /* pre-flushing in progress */
  548.     QUEUE_ORDSEQ_BAR    = 0x08,    /* original barrier req in progress */
  549.     QUEUE_ORDSEQ_POSTFLUSH    = 0x10,    /* post-flushing in progress */
  550.     QUEUE_ORDSEQ_DONE    = 0x20,
  551. };
  552.  
  553. #define blk_queue_plugged(q)    test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
  554. #define blk_queue_tagged(q)    test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
  555. #define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
  556. #define blk_queue_nomerges(q)    test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
  557. #define blk_queue_nonrot(q)    test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
  558. #define blk_queue_flushing(q)    ((q)->ordseq)
  559. #define blk_queue_stackable(q)    \
  560.     test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
  561.  
  562. #define blk_fs_request(rq)    ((rq)->cmd_type == REQ_TYPE_FS)
  563. #define blk_pc_request(rq)    ((rq)->cmd_type == REQ_TYPE_BLOCK_PC)
  564. #define blk_special_request(rq)    ((rq)->cmd_type == REQ_TYPE_SPECIAL)
  565. #define blk_sense_request(rq)    ((rq)->cmd_type == REQ_TYPE_SENSE)
  566.  
  567. #define blk_failfast_dev(rq)    ((rq)->cmd_flags & REQ_FAILFAST_DEV)
  568. #define blk_failfast_transport(rq) ((rq)->cmd_flags & REQ_FAILFAST_TRANSPORT)
  569. #define blk_failfast_driver(rq)    ((rq)->cmd_flags & REQ_FAILFAST_DRIVER)
  570. #define blk_noretry_request(rq)    (blk_failfast_dev(rq) ||    \
  571.                  blk_failfast_transport(rq) ||    \
  572.                  blk_failfast_driver(rq))
  573. #define blk_rq_started(rq)    ((rq)->cmd_flags & REQ_STARTED)
  574.  
  575. #define blk_account_rq(rq)    (blk_rq_started(rq) && (blk_fs_request(rq) || blk_discard_rq(rq))) 
  576.  
  577. #define blk_pm_suspend_request(rq)    ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND)
  578. #define blk_pm_resume_request(rq)    ((rq)->cmd_type == REQ_TYPE_PM_RESUME)
  579. #define blk_pm_request(rq)    \
  580.     (blk_pm_suspend_request(rq) || blk_pm_resume_request(rq))
  581.  
  582. #define blk_rq_cpu_valid(rq)    ((rq)->cpu != -1)
  583. #define blk_sorted_rq(rq)    ((rq)->cmd_flags & REQ_SORTED)
  584. #define blk_barrier_rq(rq)    ((rq)->cmd_flags & REQ_HARDBARRIER)
  585. #define blk_fua_rq(rq)        ((rq)->cmd_flags & REQ_FUA)
  586. #define blk_discard_rq(rq)    ((rq)->cmd_flags & REQ_DISCARD)
  587. #define blk_bidi_rq(rq)        ((rq)->next_rq != NULL)
  588. #define blk_empty_barrier(rq)    (blk_barrier_rq(rq) && blk_fs_request(rq) && !(rq)->hard_nr_sectors)
  589. /* rq->queuelist of dequeued request must be list_empty() */
  590. #define blk_queued_rq(rq)    (!list_empty(&(rq)->queuelist))
  591.  
  592. #define list_entry_rq(ptr)    list_entry((ptr), struct request, queuelist)
  593.  
  594. #define rq_data_dir(rq)        ((rq)->cmd_flags & 1)
  595.  
  596. /*
  597.  * We regard a request as sync, if it's a READ or a SYNC write.
  598.  */
  599. #define rq_is_sync(rq)        (rq_data_dir((rq)) == READ || (rq)->cmd_flags & REQ_RW_SYNC)
  600. #define rq_is_meta(rq)        ((rq)->cmd_flags & REQ_RW_META)
  601.  
  602. static inline int blk_queue_full(struct request_queue *q, int rw)
  603. {
  604.     if (rw == READ)
  605.         return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
  606.     return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
  607. }
  608.  
  609. static inline void blk_set_queue_full(struct request_queue *q, int rw)
  610. {
  611.     if (rw == READ)
  612.         queue_flag_set(QUEUE_FLAG_READFULL, q);
  613.     else
  614.         queue_flag_set(QUEUE_FLAG_WRITEFULL, q);
  615. }
  616.  
  617. static inline void blk_clear_queue_full(struct request_queue *q, int rw)
  618. {
  619.     if (rw == READ)
  620.         queue_flag_clear(QUEUE_FLAG_READFULL, q);
  621.     else
  622.         queue_flag_clear(QUEUE_FLAG_WRITEFULL, q);
  623. }
  624.  
  625.  
  626. /*
  627.  * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may
  628.  * it already be started by driver.
  629.  */
  630. #define RQ_NOMERGE_FLAGS    \
  631.     (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
  632. #define rq_mergeable(rq)    \
  633.     (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && \
  634.      (blk_discard_rq(rq) || blk_fs_request((rq))))
  635.  
  636. /*
  637.  * q->prep_rq_fn return values
  638.  */
  639. #define BLKPREP_OK        0    /* serve it */
  640. #define BLKPREP_KILL        1    /* fatal error, kill */
  641. #define BLKPREP_DEFER        2    /* leave on queue */
  642.  
  643. extern unsigned long blk_max_low_pfn, blk_max_pfn;
  644.  
  645. /*
  646.  * standard bounce addresses:
  647.  *
  648.  * BLK_BOUNCE_HIGH    : bounce all highmem pages
  649.  * BLK_BOUNCE_ANY    : don't bounce anything
  650.  * BLK_BOUNCE_ISA    : bounce pages above ISA DMA boundary
  651.  */
  652.  
  653. #if BITS_PER_LONG == 32
  654. #define BLK_BOUNCE_HIGH        ((u64)blk_max_low_pfn << PAGE_SHIFT)
  655. #else
  656. #define BLK_BOUNCE_HIGH        -1ULL
  657. #endif
  658. #define BLK_BOUNCE_ANY        (-1ULL)
  659. #define BLK_BOUNCE_ISA        (ISA_DMA_THRESHOLD)
  660.  
  661. /*
  662.  * default timeout for SG_IO if none specified
  663.  */
  664. #define BLK_DEFAULT_SG_TIMEOUT    (60 * HZ)
  665. #define BLK_MIN_SG_TIMEOUT    (7 * HZ)
  666.  
  667. #ifdef CONFIG_BOUNCE
  668. extern int init_emergency_isa_pool(void);
  669. extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
  670. #else
  671. static inline int init_emergency_isa_pool(void)
  672. {
  673.     return 0;
  674. }
  675. static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
  676. {
  677. }
  678. #endif /* CONFIG_MMU */
  679.  
  680. struct rq_map_data {
  681.     struct page **pages;
  682.     int page_order;
  683.     int nr_entries;
  684. };
  685.  
  686. struct req_iterator {
  687.     int i;
  688.     struct bio *bio;
  689. };
  690.  
  691. /* This should not be used directly - use rq_for_each_segment */
  692. #define __rq_for_each_bio(_bio, rq)    \
  693.     if ((rq->bio))            \
  694.         for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
  695.  
  696. #define rq_for_each_segment(bvl, _rq, _iter)            \
  697.     __rq_for_each_bio(_iter.bio, _rq)            \
  698.         bio_for_each_segment(bvl, _iter.bio, _iter.i)
  699.  
  700. #define rq_iter_last(rq, _iter)                    \
  701.         (_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1)
  702.  
  703. extern int blk_register_queue(struct gendisk *disk);
  704. extern void blk_unregister_queue(struct gendisk *disk);
  705. extern void register_disk(struct gendisk *dev);
  706. extern void generic_make_request(struct bio *bio);
  707. extern void blk_rq_init(struct request_queue *q, struct request *rq);
  708. extern void blk_put_request(struct request *);
  709. extern void __blk_put_request(struct request_queue *, struct request *);
  710. extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
  711. extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
  712. extern void blk_requeue_request(struct request_queue *, struct request *);
  713. extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
  714. extern int blk_lld_busy(struct request_queue *q);
  715. extern int blk_insert_cloned_request(struct request_queue *q,
  716.                      struct request *rq);
  717. extern void blk_plug_device(struct request_queue *);
  718. extern void blk_plug_device_unlocked(struct request_queue *);
  719. extern int blk_remove_plug(struct request_queue *);
  720. extern void blk_recount_segments(struct request_queue *, struct bio *);
  721. extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
  722.               unsigned int, void __user *);
  723. extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
  724.              struct scsi_ioctl_command __user *);
  725.  
  726. /*
  727.  * Temporary export, until SCSI gets fixed up.
  728.  */
  729. extern int blk_rq_append_bio(struct request_queue *q, struct request *rq,
  730.                  struct bio *bio);
  731.  
  732. /*
  733.  * A queue has just exitted congestion.  Note this in the global counter of
  734.  * congested queues, and wake up anyone who was waiting for requests to be
  735.  * put back.
  736.  */
  737. static inline void blk_clear_queue_congested(struct request_queue *q, int rw)
  738. {
  739.     clear_bdi_congested(&q->backing_dev_info, rw);
  740. }
  741.  
  742. /*
  743.  * A queue has just entered congestion.  Flag that in the queue's VM-visible
  744.  * state flags and increment the global gounter of congested queues.
  745.  */
  746. static inline void blk_set_queue_congested(struct request_queue *q, int rw)
  747. {
  748.     set_bdi_congested(&q->backing_dev_info, rw);
  749. }
  750.  
  751. extern void blk_start_queue(struct request_queue *q);
  752. extern void blk_stop_queue(struct request_queue *q);
  753. extern void blk_sync_queue(struct request_queue *q);
  754. extern void __blk_stop_queue(struct request_queue *q);
  755. extern void __blk_run_queue(struct request_queue *);
  756. extern void blk_run_queue(struct request_queue *);
  757. extern void blk_start_queueing(struct request_queue *);
  758. extern int blk_rq_map_user(struct request_queue *, struct request *,
  759.                struct rq_map_data *, void __user *, unsigned long,
  760.                gfp_t);
  761. extern int blk_rq_unmap_user(struct bio *);
  762. extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
  763. extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
  764.                    struct rq_map_data *, struct sg_iovec *, int,
  765.                    unsigned int, gfp_t);
  766. extern int blk_execute_rq(struct request_queue *, struct gendisk *,
  767.               struct request *, int);
  768. extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
  769.                   struct request *, int, rq_end_io_fn *);
  770. extern void blk_unplug(struct request_queue *q);
  771.  
  772. static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
  773. {
  774.     return bdev->bd_disk->queue;
  775. }
  776.  
  777. static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
  778.                        struct page *page)
  779. {
  780.     if (bdi && bdi->unplug_io_fn)
  781.         bdi->unplug_io_fn(bdi, page);
  782. }
  783.  
  784. static inline void blk_run_address_space(struct address_space *mapping)
  785. {
  786.     if (mapping)
  787.         blk_run_backing_dev(mapping->backing_dev_info, NULL);
  788. }
  789.  
  790. extern void blkdev_dequeue_request(struct request *req);
  791.  
  792. /*
  793.  * blk_end_request() and friends.
  794.  * __blk_end_request() and end_request() must be called with
  795.  * the request queue spinlock acquired.
  796.  *
  797.  * Several drivers define their own end_request and call
  798.  * blk_end_request() for parts of the original function.
  799.  * This prevents code duplication in drivers.
  800.  */
  801. extern int blk_end_request(struct request *rq, int error,
  802.                 unsigned int nr_bytes);
  803. extern int __blk_end_request(struct request *rq, int error,
  804.                 unsigned int nr_bytes);
  805. extern int blk_end_bidi_request(struct request *rq, int error,
  806.                 unsigned int nr_bytes, unsigned int bidi_bytes);
  807. extern void end_request(struct request *, int);
  808. extern int blk_end_request_callback(struct request *rq, int error,
  809.                 unsigned int nr_bytes,
  810.                 int (drv_callback)(struct request *));
  811. extern void blk_complete_request(struct request *);
  812. extern void __blk_complete_request(struct request *);
  813. extern void blk_abort_request(struct request *);
  814. extern void blk_abort_queue(struct request_queue *);
  815. extern void blk_update_request(struct request *rq, int error,
  816.                    unsigned int nr_bytes);
  817.  
  818. /*
  819.  * blk_end_request() takes bytes instead of sectors as a complete size.
  820.  * blk_rq_bytes() returns bytes left to complete in the entire request.
  821.  * blk_rq_cur_bytes() returns bytes left to complete in the current segment.
  822.  */
  823. extern unsigned int blk_rq_bytes(struct request *rq);
  824. extern unsigned int blk_rq_cur_bytes(struct request *rq);
  825.  
  826. /*
  827.  * Access functions for manipulating queue properties
  828.  */
  829. extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
  830.                     spinlock_t *lock, int node_id);
  831. extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
  832. extern void blk_cleanup_queue(struct request_queue *);
  833. extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
  834. extern void blk_queue_bounce_limit(struct request_queue *, u64);
  835. extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
  836. extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
  837. extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
  838. extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
  839. extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
  840. extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
  841. extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
  842. extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
  843. extern int blk_queue_dma_drain(struct request_queue *q,
  844.                    dma_drain_needed_fn *dma_drain_needed,
  845.                    void *buf, unsigned int size);
  846. extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
  847. extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
  848. extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
  849. extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
  850. extern void blk_queue_dma_alignment(struct request_queue *, int);
  851. extern void blk_queue_update_dma_alignment(struct request_queue *, int);
  852. extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
  853. extern void blk_queue_set_discard(struct request_queue *, prepare_discard_fn *);
  854. extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
  855. extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
  856. extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
  857. extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
  858. extern int blk_do_ordered(struct request_queue *, struct request **);
  859. extern unsigned blk_ordered_cur_seq(struct request_queue *);
  860. extern unsigned blk_ordered_req_seq(struct request *);
  861. extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int);
  862.  
  863. extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
  864. extern void blk_dump_rq_flags(struct request *, char *);
  865. extern void generic_unplug_device(struct request_queue *);
  866. extern long nr_blockdev_pages(void);
  867.  
  868. int blk_get_queue(struct request_queue *);
  869. struct request_queue *blk_alloc_queue(gfp_t);
  870. struct request_queue *blk_alloc_queue_node(gfp_t, int);
  871. extern void blk_put_queue(struct request_queue *);
  872.  
  873. /*
  874.  * tag stuff
  875.  */
  876. #define blk_rq_tagged(rq)        ((rq)->cmd_flags & REQ_QUEUED)
  877. extern int blk_queue_start_tag(struct request_queue *, struct request *);
  878. extern struct request *blk_queue_find_tag(struct request_queue *, int);
  879. extern void blk_queue_end_tag(struct request_queue *, struct request *);
  880. extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
  881. extern void blk_queue_free_tags(struct request_queue *);
  882. extern int blk_queue_resize_tags(struct request_queue *, int);
  883. extern void blk_queue_invalidate_tags(struct request_queue *);
  884. extern struct blk_queue_tag *blk_init_tags(int);
  885. extern void blk_free_tags(struct blk_queue_tag *);
  886.  
  887. static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
  888.                         int tag)
  889. {
  890.     if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
  891.         return NULL;
  892.     return bqt->tag_index[tag];
  893. }
  894.  
  895. extern int blkdev_issue_flush(struct block_device *, sector_t *);
  896. extern int blkdev_issue_discard(struct block_device *,
  897.                 sector_t sector, sector_t nr_sects, gfp_t);
  898.  
  899. static inline int sb_issue_discard(struct super_block *sb,
  900.                    sector_t block, sector_t nr_blocks)
  901. {
  902.     block <<= (sb->s_blocksize_bits - 9);
  903.     nr_blocks <<= (sb->s_blocksize_bits - 9);
  904.     return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL);
  905. }
  906.  
  907. /*
  908. * command filter functions
  909. */
  910. extern int blk_verify_command(struct blk_cmd_filter *filter,
  911.                   unsigned char *cmd, fmode_t has_write_perm);
  912. extern void blk_unregister_filter(struct gendisk *disk);
  913. extern void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter);
  914.  
  915. #define MAX_PHYS_SEGMENTS 128
  916. #define MAX_HW_SEGMENTS 128
  917. #define SAFE_MAX_SECTORS 255
  918. #define BLK_DEF_MAX_SECTORS 1024
  919.  
  920. #define MAX_SEGMENT_SIZE    65536
  921.  
  922. #define BLK_SEG_BOUNDARY_MASK    0xFFFFFFFFUL
  923.  
  924. #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
  925.  
  926. static inline int queue_hardsect_size(struct request_queue *q)
  927. {
  928.     int retval = 512;
  929.  
  930.     if (q && q->hardsect_size)
  931.         retval = q->hardsect_size;
  932.  
  933.     return retval;
  934. }
  935.  
  936. static inline int bdev_hardsect_size(struct block_device *bdev)
  937. {
  938.     return queue_hardsect_size(bdev_get_queue(bdev));
  939. }
  940.  
  941. static inline int queue_dma_alignment(struct request_queue *q)
  942. {
  943.     return q ? q->dma_alignment : 511;
  944. }
  945.  
  946. static inline int blk_rq_aligned(struct request_queue *q, void *addr,
  947.                  unsigned int len)
  948. {
  949.     unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
  950.     return !((unsigned long)addr & alignment) && !(len & alignment);
  951. }
  952.  
  953. /* assumes size > 256 */
  954. static inline unsigned int blksize_bits(unsigned int size)
  955. {
  956.     unsigned int bits = 8;
  957.     do {
  958.         bits++;
  959.         size >>= 1;
  960.     } while (size > 256);
  961.     return bits;
  962. }
  963.  
  964. static inline unsigned int block_size(struct block_device *bdev)
  965. {
  966.     return bdev->bd_block_size;
  967. }
  968.  
  969. typedef struct {struct page *v;} Sector;
  970.  
  971. unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
  972.  
  973. static inline void put_dev_sector(Sector p)
  974. {
  975.     page_cache_release(p.v);
  976. }
  977.  
  978. struct work_struct;
  979. int kblockd_schedule_work(struct request_queue *q, struct work_struct *work);
  980. void kblockd_flush_work(struct work_struct *work);
  981.  
  982. #define MODULE_ALIAS_BLOCKDEV(major,minor) \
  983.     MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
  984. #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
  985.     MODULE_ALIAS("block-major-" __stringify(major) "-*")
  986.  
  987. #if defined(CONFIG_BLK_DEV_INTEGRITY)
  988.  
  989. #define INTEGRITY_FLAG_READ    2    /* verify data integrity on read */
  990. #define INTEGRITY_FLAG_WRITE    4    /* generate data integrity on write */
  991.  
  992. struct blk_integrity_exchg {
  993.     void            *prot_buf;
  994.     void            *data_buf;
  995.     sector_t        sector;
  996.     unsigned int        data_size;
  997.     unsigned short        sector_size;
  998.     const char        *disk_name;
  999. };
  1000.  
  1001. typedef void (integrity_gen_fn) (struct blk_integrity_exchg *);
  1002. typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *);
  1003. typedef void (integrity_set_tag_fn) (void *, void *, unsigned int);
  1004. typedef void (integrity_get_tag_fn) (void *, void *, unsigned int);
  1005.  
  1006. struct blk_integrity {
  1007.     integrity_gen_fn    *generate_fn;
  1008.     integrity_vrfy_fn    *verify_fn;
  1009.     integrity_set_tag_fn    *set_tag_fn;
  1010.     integrity_get_tag_fn    *get_tag_fn;
  1011.  
  1012.     unsigned short        flags;
  1013.     unsigned short        tuple_size;
  1014.     unsigned short        sector_size;
  1015.     unsigned short        tag_size;
  1016.  
  1017.     const char        *name;
  1018.  
  1019.     struct kobject        kobj;
  1020. };
  1021.  
  1022. extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
  1023. extern void blk_integrity_unregister(struct gendisk *);
  1024. extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
  1025. extern int blk_rq_map_integrity_sg(struct request *, struct scatterlist *);
  1026. extern int blk_rq_count_integrity_sg(struct request *);
  1027.  
  1028. static inline
  1029. struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
  1030. {
  1031.     return bdev->bd_disk->integrity;
  1032. }
  1033.  
  1034. static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
  1035. {
  1036.     return disk->integrity;
  1037. }
  1038.  
  1039. static inline int blk_integrity_rq(struct request *rq)
  1040. {
  1041.     if (rq->bio == NULL)
  1042.         return 0;
  1043.  
  1044.     return bio_integrity(rq->bio);
  1045. }
  1046.  
  1047. #else /* CONFIG_BLK_DEV_INTEGRITY */
  1048.  
  1049. #define blk_integrity_rq(rq)            (0)
  1050. #define blk_rq_count_integrity_sg(a)        (0)
  1051. #define blk_rq_map_integrity_sg(a, b)        (0)
  1052. #define bdev_get_integrity(a)            (0)
  1053. #define blk_get_integrity(a)            (0)
  1054. #define blk_integrity_compare(a, b)        (0)
  1055. #define blk_integrity_register(a, b)        (0)
  1056. #define blk_integrity_unregister(a)        do { } while (0);
  1057.  
  1058. #endif /* CONFIG_BLK_DEV_INTEGRITY */
  1059.  
  1060. struct block_device_operations {
  1061.     int (*open) (struct block_device *, fmode_t);
  1062.     int (*release) (struct gendisk *, fmode_t);
  1063.     int (*locked_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
  1064.     int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
  1065.     int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
  1066.     int (*direct_access) (struct block_device *, sector_t,
  1067.                         void **, unsigned long *);
  1068.     int (*media_changed) (struct gendisk *);
  1069.     int (*revalidate_disk) (struct gendisk *);
  1070.     int (*getgeo)(struct block_device *, struct hd_geometry *);
  1071.     struct module *owner;
  1072. };
  1073.  
  1074. extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
  1075.                  unsigned long);
  1076. #else /* CONFIG_BLOCK */
  1077. /*
  1078.  * stubs for when the block layer is configured out
  1079.  */
  1080. #define buffer_heads_over_limit 0
  1081.  
  1082. static inline long nr_blockdev_pages(void)
  1083. {
  1084.     return 0;
  1085. }
  1086.  
  1087. #endif /* CONFIG_BLOCK */
  1088.  
  1089. #endif
  1090.