1 files changed, 197 insertions, 126 deletions

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 2c54906f678f..1a23722e8878 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -108,13 +108,20 @@ struct request {
 
         /*
          * Three pointers are available for the IO schedulers, if they need
-         * more they have to dynamically allocate it.
+         * more they have to dynamically allocate it.  Flush requests are
+         * never put on the IO scheduler. So let the flush fields share
+         * space with the three elevator_private pointers.
          */
-        void *elevator_private;
-        void *elevator_private2;
-        void *elevator_private3;
+        union {
+                void *elevator_private[3];
+                struct {
+                        unsigned int            seq;
+                        struct list_head        list;
+                } flush;
+        };
 
         struct gendisk *rq_disk;
+        struct hd_struct *part;
         unsigned long start_time;
 #ifdef CONFIG_BLK_CGROUP
         unsigned long long start_time_ns;
@@ -124,6 +131,9 @@ struct request {
          * physical address coalescing is performed.
          */
         unsigned short nr_phys_segments;
+#if defined(CONFIG_BLK_DEV_INTEGRITY)
+        unsigned short nr_integrity_segments;
+#endif
 
         unsigned short ioprio;
 
@@ -186,7 +196,6 @@ typedef void (request_fn_proc) (struct request_queue *q);
 typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
 typedef int (prep_rq_fn) (struct request_queue *, struct request *);
 typedef void (unprep_rq_fn) (struct request_queue *, struct request *);
-typedef void (unplug_fn) (struct request_queue *);
 
 struct bio_vec;
 struct bvec_merge_data {
@@ -243,11 +252,12 @@ struct queue_limits {
 
         unsigned short          logical_block_size;
         unsigned short          max_segments;
+        unsigned short          max_integrity_segments;
 
         unsigned char           misaligned;
         unsigned char           discard_misaligned;
-        unsigned char           no_cluster;
-        signed char             discard_zeroes_data;
+        unsigned char           cluster;
+        unsigned char           discard_zeroes_data;
 };
 
 struct request_queue
@@ -268,7 +278,6 @@ struct request_queue
         make_request_fn         *make_request_fn;
         prep_rq_fn              *prep_rq_fn;
         unprep_rq_fn            *unprep_rq_fn;
-        unplug_fn               *unplug_fn;
         merge_bvec_fn           *merge_bvec_fn;
         softirq_done_fn         *softirq_done_fn;
         rq_timed_out_fn         *rq_timed_out_fn;
@@ -282,12 +291,9 @@ struct request_queue
         struct request          *boundary_rq;
 
         /*
-         * Auto-unplugging state
+         * Delayed queue handling
          */
-        struct timer_list       unplug_timer;
-        int                     unplug_thresh;  /* After this many requests */
-        unsigned long           unplug_delay;   /* After this many jiffies */
-        struct work_struct      unplug_work;
+        struct delayed_work     delay_work;
 
         struct backing_dev_info backing_dev_info;
 
@@ -355,44 +361,50 @@ struct request_queue
         struct blk_trace        *blk_trace;
 #endif
         /*
-         * reserved for flush operations
+         * for flush operations
          */
-        unsigned int            ordered, next_ordered, ordseq;
-        int                     orderr, ordcolor;
-        struct request          pre_flush_rq, bar_rq, post_flush_rq;
-        struct request          *orig_bar_rq;
+        unsigned int            flush_flags;
+        unsigned int            flush_not_queueable:1;
+        unsigned int            flush_queue_delayed:1;
+        unsigned int            flush_pending_idx:1;
+        unsigned int            flush_running_idx:1;
+        unsigned long           flush_pending_since;
+        struct list_head        flush_queue[2];
+        struct list_head        flush_data_in_flight;
+        struct request          flush_rq;
 
         struct mutex            sysfs_lock;
 
 #if defined(CONFIG_BLK_DEV_BSG)
         struct bsg_class_device bsg_dev;
 #endif
+
+#ifdef CONFIG_BLK_DEV_THROTTLING
+        /* Throttle data */
+        struct throtl_data *td;
+#endif
 };
 
-#define QUEUE_FLAG_CLUSTER      0       /* cluster several segments into 1 */
 #define QUEUE_FLAG_QUEUED       1       /* uses generic tag queueing */
 #define QUEUE_FLAG_STOPPED      2       /* queue is stopped */
 #define QUEUE_FLAG_SYNCFULL     3       /* read queue has been filled */
 #define QUEUE_FLAG_ASYNCFULL    4       /* write queue has been filled */
 #define QUEUE_FLAG_DEAD         5       /* queue being torn down */
-#define QUEUE_FLAG_REENTER      6       /* Re-entrancy avoidance */
-#define QUEUE_FLAG_PLUGGED      7       /* queue is plugged */
-#define QUEUE_FLAG_ELVSWITCH    8       /* don't use elevator, just do FIFO */
-#define QUEUE_FLAG_BIDI         9       /* queue supports bidi requests */
-#define QUEUE_FLAG_NOMERGES    10       /* disable merge attempts */
-#define QUEUE_FLAG_SAME_COMP   11       /* force complete on same CPU */
-#define QUEUE_FLAG_FAIL_IO     12       /* fake timeout */
-#define QUEUE_FLAG_STACKABLE   13       /* supports request stacking */
-#define QUEUE_FLAG_NONROT      14       /* non-rotational device (SSD) */
+#define QUEUE_FLAG_ELVSWITCH    6       /* don't use elevator, just do FIFO */
+#define QUEUE_FLAG_BIDI         7       /* queue supports bidi requests */
+#define QUEUE_FLAG_NOMERGES     8       /* disable merge attempts */
+#define QUEUE_FLAG_SAME_COMP    9       /* force complete on same CPU */
+#define QUEUE_FLAG_FAIL_IO     10       /* fake timeout */
+#define QUEUE_FLAG_STACKABLE   11       /* supports request stacking */
+#define QUEUE_FLAG_NONROT      12       /* non-rotational device (SSD) */
 #define QUEUE_FLAG_VIRT        QUEUE_FLAG_NONROT /* paravirt device */
-#define QUEUE_FLAG_IO_STAT     15       /* do IO stats */
-#define QUEUE_FLAG_DISCARD     16       /* supports DISCARD */
-#define QUEUE_FLAG_NOXMERGES   17       /* No extended merges */
-#define QUEUE_FLAG_ADD_RANDOM  18       /* Contributes to random pool */
-#define QUEUE_FLAG_SECDISCARD  19       /* supports SECDISCARD */
+#define QUEUE_FLAG_IO_STAT     13       /* do IO stats */
+#define QUEUE_FLAG_DISCARD     14       /* supports DISCARD */
+#define QUEUE_FLAG_NOXMERGES   15       /* No extended merges */
+#define QUEUE_FLAG_ADD_RANDOM  16       /* Contributes to random pool */
+#define QUEUE_FLAG_SECDISCARD  17       /* supports SECDISCARD */
 
 #define QUEUE_FLAG_DEFAULT      ((1 << QUEUE_FLAG_IO_STAT) |            \
-                                 (1 << QUEUE_FLAG_CLUSTER) |            \
                                  (1 << QUEUE_FLAG_STACKABLE)    |       \
                                  (1 << QUEUE_FLAG_SAME_COMP)    |       \
                                  (1 << QUEUE_FLAG_ADD_RANDOM))
@@ -462,57 +474,6 @@ static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
         __clear_bit(flag, &q->queue_flags);
 }
 
-enum {
-        /*
-         * Hardbarrier is supported with one of the following methods.
-         *
-         * NONE         : hardbarrier unsupported
-         * DRAIN        : ordering by draining is enough
-         * DRAIN_FLUSH  : ordering by draining w/ pre and post flushes
-         * DRAIN_FUA    : ordering by draining w/ pre flush and FUA write
-         * TAG          : ordering by tag is enough
-         * TAG_FLUSH    : ordering by tag w/ pre and post flushes
-         * TAG_FUA      : ordering by tag w/ pre flush and FUA write
-         */
-        QUEUE_ORDERED_BY_DRAIN          = 0x01,
-        QUEUE_ORDERED_BY_TAG            = 0x02,
-        QUEUE_ORDERED_DO_PREFLUSH       = 0x10,
-        QUEUE_ORDERED_DO_BAR            = 0x20,
-        QUEUE_ORDERED_DO_POSTFLUSH      = 0x40,
-        QUEUE_ORDERED_DO_FUA            = 0x80,
-
-        QUEUE_ORDERED_NONE              = 0x00,
-
-        QUEUE_ORDERED_DRAIN             = QUEUE_ORDERED_BY_DRAIN |
-                                          QUEUE_ORDERED_DO_BAR,
-        QUEUE_ORDERED_DRAIN_FLUSH       = QUEUE_ORDERED_DRAIN |
-                                          QUEUE_ORDERED_DO_PREFLUSH |
-                                          QUEUE_ORDERED_DO_POSTFLUSH,
-        QUEUE_ORDERED_DRAIN_FUA         = QUEUE_ORDERED_DRAIN |
-                                          QUEUE_ORDERED_DO_PREFLUSH |
-                                          QUEUE_ORDERED_DO_FUA,
-
-        QUEUE_ORDERED_TAG               = QUEUE_ORDERED_BY_TAG |
-                                          QUEUE_ORDERED_DO_BAR,
-        QUEUE_ORDERED_TAG_FLUSH         = QUEUE_ORDERED_TAG |
-                                          QUEUE_ORDERED_DO_PREFLUSH |
-                                          QUEUE_ORDERED_DO_POSTFLUSH,
-        QUEUE_ORDERED_TAG_FUA           = QUEUE_ORDERED_TAG |
-                                          QUEUE_ORDERED_DO_PREFLUSH |
-                                          QUEUE_ORDERED_DO_FUA,
-
-        /*
-         * Ordered operation sequence
-         */
-        QUEUE_ORDSEQ_STARTED    = 0x01, /* flushing in progress */
-        QUEUE_ORDSEQ_DRAIN      = 0x02, /* waiting for the queue to be drained */
-        QUEUE_ORDSEQ_PREFLUSH   = 0x04, /* pre-flushing in progress */
-        QUEUE_ORDSEQ_BAR        = 0x08, /* original barrier req in progress */
-        QUEUE_ORDSEQ_POSTFLUSH  = 0x10, /* post-flushing in progress */
-        QUEUE_ORDSEQ_DONE       = 0x20,
-};
-
-#define blk_queue_plugged(q)    test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
 #define blk_queue_tagged(q)     test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
 #define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
 #define blk_queue_nomerges(q)   test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
@@ -521,7 +482,6 @@ enum {
 #define blk_queue_nonrot(q)     test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
 #define blk_queue_io_stat(q)    test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
 #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
-#define blk_queue_flushing(q)   ((q)->ordseq)
 #define blk_queue_stackable(q)  \
         test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
 #define blk_queue_discard(q)    test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
@@ -550,6 +510,11 @@ enum {
 
 #define rq_data_dir(rq)         ((rq)->cmd_flags & 1)
 
+static inline unsigned int blk_queue_cluster(struct request_queue *q)
+{
+        return q->limits.cluster;
+}
+
 /*
  * We regard a request as sync, if either a read or a sync write
  */
@@ -592,7 +557,7 @@ static inline void blk_clear_queue_full(struct request_queue *q, int sync)
  * it already be started by driver.
  */
 #define RQ_NOMERGE_FLAGS        \
-        (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
+        (REQ_NOMERGE | REQ_STARTED | REQ_SOFTBARRIER | REQ_FLUSH | REQ_FUA)
 #define rq_mergeable(rq)        \
         (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && \
          (((rq)->cmd_flags & REQ_DISCARD) || \
@@ -683,7 +648,6 @@ static inline void rq_flush_dcache_pages(struct request *rq)
 
 extern int blk_register_queue(struct gendisk *disk);
 extern void blk_unregister_queue(struct gendisk *disk);
-extern void register_disk(struct gendisk *dev);
 extern void generic_make_request(struct bio *bio);
 extern void blk_rq_init(struct request_queue *q, struct request *rq);
 extern void blk_put_request(struct request *);
@@ -704,9 +668,7 @@ extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
 extern void blk_rq_unprep_clone(struct request *rq);
 extern int blk_insert_cloned_request(struct request_queue *q,
                                      struct request *rq);
-extern void blk_plug_device(struct request_queue *);
-extern void blk_plug_device_unlocked(struct request_queue *);
-extern int blk_remove_plug(struct request_queue *);
+extern void blk_delay_queue(struct request_queue *, unsigned long);
 extern void blk_recount_segments(struct request_queue *, struct bio *);
 extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
                           unsigned int, void __user *);
@@ -736,8 +698,9 @@ extern void blk_start_queue(struct request_queue *q);
 extern void blk_stop_queue(struct request_queue *q);
 extern void blk_sync_queue(struct request_queue *q);
 extern void __blk_stop_queue(struct request_queue *q);
-extern void __blk_run_queue(struct request_queue *);
+extern void __blk_run_queue(struct request_queue *q);
 extern void blk_run_queue(struct request_queue *);
+extern void blk_run_queue_async(struct request_queue *q);
 extern int blk_rq_map_user(struct request_queue *, struct request *,
                            struct rq_map_data *, void __user *, unsigned long,
                            gfp_t);
@@ -750,7 +713,6 @@ extern int blk_execute_rq(struct request_queue *, struct gendisk *,
                           struct request *, int);
 extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
                                   struct request *, int, rq_end_io_fn *);
-extern void blk_unplug(struct request_queue *q);
 
 static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
 {
@@ -845,13 +807,14 @@ extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
 extern void blk_cleanup_queue(struct request_queue *);
 extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 extern void blk_queue_bounce_limit(struct request_queue *, u64);
+extern void blk_limits_max_hw_sectors(struct queue_limits *, unsigned int);
 extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
 extern void blk_queue_max_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
 extern void blk_queue_max_discard_sectors(struct request_queue *q,
                 unsigned int max_discard_sectors);
 extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
-extern void blk_queue_physical_block_size(struct request_queue *, unsigned short);
+extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
 extern void blk_queue_alignment_offset(struct request_queue *q,
                                        unsigned int alignment);
 extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
@@ -881,16 +844,12 @@ extern void blk_queue_update_dma_alignment(struct request_queue *, int);
 extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
 extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
 extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
+extern void blk_queue_flush(struct request_queue *q, unsigned int flush);
+extern void blk_queue_flush_queueable(struct request_queue *q, bool queueable);
 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
-extern int blk_queue_ordered(struct request_queue *, unsigned);
-extern bool blk_do_ordered(struct request_queue *, struct request **);
-extern unsigned blk_ordered_cur_seq(struct request_queue *);
-extern unsigned blk_ordered_req_seq(struct request *);
-extern bool blk_ordered_complete_seq(struct request_queue *, unsigned, int);
 
 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
 extern void blk_dump_rq_flags(struct request *, char *);
-extern void generic_unplug_device(struct request_queue *);
 extern long nr_blockdev_pages(void);
 
 int blk_get_queue(struct request_queue *);
@@ -898,6 +857,44 @@ struct request_queue *blk_alloc_queue(gfp_t);
 struct request_queue *blk_alloc_queue_node(gfp_t, int);
 extern void blk_put_queue(struct request_queue *);
 
+struct blk_plug {
+        unsigned long magic;
+        struct list_head list;
+        struct list_head cb_list;
+        unsigned int should_sort;
+};
+struct blk_plug_cb {
+        struct list_head list;
+        void (*callback)(struct blk_plug_cb *);
+};
+
+extern void blk_start_plug(struct blk_plug *);
+extern void blk_finish_plug(struct blk_plug *);
+extern void blk_flush_plug_list(struct blk_plug *, bool);
+
+static inline void blk_flush_plug(struct task_struct *tsk)
+{
+        struct blk_plug *plug = tsk->plug;
+
+        if (plug)
+                blk_flush_plug_list(plug, false);
+}
+
+static inline void blk_schedule_flush_plug(struct task_struct *tsk)
+{
+        struct blk_plug *plug = tsk->plug;
+
+        if (plug)
+                blk_flush_plug_list(plug, true);
+}
+
+static inline bool blk_needs_flush_plug(struct task_struct *tsk)
+{
+        struct blk_plug *plug = tsk->plug;
+
+        return plug && (!list_empty(&plug->list) || !list_empty(&plug->cb_list));
+}
+
 /*
  * tag stuff
  */
@@ -919,27 +916,28 @@ static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
                 return NULL;
         return bqt->tag_index[tag];
 }
-enum{
-        BLKDEV_WAIT,    /* wait for completion */
-        BLKDEV_BARRIER, /* issue request with barrier */
-        BLKDEV_SECURE,  /* secure discard */
-};
-#define BLKDEV_IFL_WAIT         (1 << BLKDEV_WAIT)
-#define BLKDEV_IFL_BARRIER      (1 << BLKDEV_BARRIER)
-#define BLKDEV_IFL_SECURE       (1 << BLKDEV_SECURE)
-extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *,
-                        unsigned long);
+
+#define BLKDEV_DISCARD_SECURE  0x01    /* secure discard */
+
+extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
 extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
 extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
-                        sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
-static inline int sb_issue_discard(struct super_block *sb,
-                                   sector_t block, sector_t nr_blocks)
+                        sector_t nr_sects, gfp_t gfp_mask);
+static inline int sb_issue_discard(struct super_block *sb, sector_t block,
+                sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
 {
-        block <<= (sb->s_blocksize_bits - 9);
-        nr_blocks <<= (sb->s_blocksize_bits - 9);
-        return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_NOFS,
-                                   BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
+        return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),
+                                    nr_blocks << (sb->s_blocksize_bits - 9),
+                                    gfp_mask, flags);
+}
+static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
+                sector_t nr_blocks, gfp_t gfp_mask)
+{
+        return blkdev_issue_zeroout(sb->s_bdev,
+                                    block << (sb->s_blocksize_bits - 9),
+                                    nr_blocks << (sb->s_blocksize_bits - 9),
+                                    gfp_mask);
 }
 
 extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
@@ -1004,7 +1002,7 @@ static inline unsigned int queue_physical_block_size(struct request_queue *q)
         return q->limits.physical_block_size;
 }
 
-static inline int bdev_physical_block_size(struct block_device *bdev)
+static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
 {
         return queue_physical_block_size(bdev_get_queue(bdev));
 }
@@ -1071,13 +1069,16 @@ static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector
 {
         unsigned int alignment = (sector << 9) & (lim->discard_granularity - 1);
 
+        if (!lim->max_discard_sectors)
+                return 0;
+
         return (lim->discard_granularity + lim->discard_alignment - alignment)
                 & (lim->discard_granularity - 1);
 }
 
 static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
 {
-        if (q->limits.discard_zeroes_data == 1)
+        if (q->limits.max_discard_sectors && q->limits.discard_zeroes_data == 1)
                 return 1;
 
         return 0;
@@ -1093,11 +1094,11 @@ static inline int queue_dma_alignment(struct request_queue *q)
         return q ? q->dma_alignment : 511;
 }
 
-static inline int blk_rq_aligned(struct request_queue *q, void *addr,
+static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
                                  unsigned int len)
 {
         unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
-        return !((unsigned long)addr & alignment) && !(len & alignment);
+        return !(addr & alignment) && !(len & alignment);
 }
 
 /* assumes size > 256 */
@@ -1116,6 +1117,11 @@ static inline unsigned int block_size(struct block_device *bdev)
         return bdev->bd_block_size;
 }
 
+static inline bool queue_flush_queueable(struct request_queue *q)
+{
+        return !q->flush_not_queueable;
+}
+
 typedef struct {struct page *v;} Sector;
 
 unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
@@ -1170,6 +1176,20 @@ static inline uint64_t rq_io_start_time_ns(struct request *req)
 }
 #endif
 
+#ifdef CONFIG_BLK_DEV_THROTTLING
+extern int blk_throtl_init(struct request_queue *q);
+extern void blk_throtl_exit(struct request_queue *q);
+extern int blk_throtl_bio(struct request_queue *q, struct bio **bio);
+#else /* CONFIG_BLK_DEV_THROTTLING */
+static inline int blk_throtl_bio(struct request_queue *q, struct bio **bio)
+{
+        return 0;
+}
+
+static inline int blk_throtl_init(struct request_queue *q) { return 0; }
+static inline int blk_throtl_exit(struct request_queue *q) { return 0; }
+#endif /* CONFIG_BLK_DEV_THROTTLING */
+
 #define MODULE_ALIAS_BLOCKDEV(major,minor) \
         MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
@@ -1210,11 +1230,17 @@ struct blk_integrity {
         struct kobject          kobj;
 };
 
+extern bool blk_integrity_is_initialized(struct gendisk *);
 extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
 extern void blk_integrity_unregister(struct gendisk *);
 extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
-extern int blk_rq_map_integrity_sg(struct request *, struct scatterlist *);
-extern int blk_rq_count_integrity_sg(struct request *);
+extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
+                                   struct scatterlist *);
+extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
+extern int blk_integrity_merge_rq(struct request_queue *, struct request *,
+                                  struct request *);
+extern int blk_integrity_merge_bio(struct request_queue *, struct request *,
+                                   struct bio *);
 
 static inline
 struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
@@ -1235,16 +1261,33 @@ static inline int blk_integrity_rq(struct request *rq)
         return bio_integrity(rq->bio);
 }
 
+static inline void blk_queue_max_integrity_segments(struct request_queue *q,
+                                                    unsigned int segs)
+{
+        q->limits.max_integrity_segments = segs;
+}
+
+static inline unsigned short
+queue_max_integrity_segments(struct request_queue *q)
+{
+        return q->limits.max_integrity_segments;
+}
+
 #else /* CONFIG_BLK_DEV_INTEGRITY */
 
 #define blk_integrity_rq(rq)                    (0)
-#define blk_rq_count_integrity_sg(a)            (0)
-#define blk_rq_map_integrity_sg(a, b)           (0)
+#define blk_rq_count_integrity_sg(a, b)         (0)
+#define blk_rq_map_integrity_sg(a, b, c)        (0)
 #define bdev_get_integrity(a)                   (0)
 #define blk_get_integrity(a)                    (0)
 #define blk_integrity_compare(a, b)             (0)
 #define blk_integrity_register(a, b)            (0)
-#define blk_integrity_unregister(a)             do { } while (0);
+#define blk_integrity_unregister(a)             do { } while (0)
+#define blk_queue_max_integrity_segments(a, b)  do { } while (0)
+#define queue_max_integrity_segments(a)         (0)
+#define blk_integrity_merge_rq(a, b, c)         (0)
+#define blk_integrity_merge_bio(a, b, c)        (0)
+#define blk_integrity_is_initialized(a)         (0)
 
 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 
@@ -1255,6 +1298,9 @@ struct block_device_operations {
         int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*direct_access) (struct block_device *, sector_t,
                                                 void **, unsigned long *);
+        unsigned int (*check_events) (struct gendisk *disk,
+                                      unsigned int clearing);
+        /* ->media_changed() is DEPRECATED, use ->check_events() instead */
         int (*media_changed) (struct gendisk *);
         void (*unlock_native_capacity) (struct gendisk *);
         int (*revalidate_disk) (struct gendisk *);
@@ -1277,6 +1323,31 @@ static inline long nr_blockdev_pages(void)
         return 0;
 }
 
+struct blk_plug {
+};
+
+static inline void blk_start_plug(struct blk_plug *plug)
+{
+}
+
+static inline void blk_finish_plug(struct blk_plug *plug)
+{
+}
+
+static inline void blk_flush_plug(struct task_struct *task)
+{
+}
+
+static inline void blk_schedule_flush_plug(struct task_struct *task)
+{
+}
+
+
+static inline bool blk_needs_flush_plug(struct task_struct *tsk)
+{
+        return false;
+}
+
 #endif /* CONFIG_BLOCK */
 
 #endif