1 files changed, 127 insertions, 167 deletions

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 5c8018977efa..2c54906f678f 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -60,7 +60,6 @@ enum rq_cmd_type_bits {
         REQ_TYPE_PM_RESUME,             /* resume request */
         REQ_TYPE_PM_SHUTDOWN,           /* shutdown request */
         REQ_TYPE_SPECIAL,               /* driver defined type */
-        REQ_TYPE_LINUX_BLOCK,           /* generic block layer message */
         /*
          * for ATA/ATAPI devices. this really doesn't belong here, ide should
          * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
@@ -70,84 +69,6 @@ enum rq_cmd_type_bits {
         REQ_TYPE_ATA_PC,
 };
 
-/*
- * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
- * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
- * SCSI cdb.
- *
- * 0x00 -> 0x3f are driver private, to be used for whatever purpose they need,
- * typically to differentiate REQ_TYPE_SPECIAL requests.
- *
- */
-enum {
-        REQ_LB_OP_EJECT = 0x40,         /* eject request */
-        REQ_LB_OP_FLUSH = 0x41,         /* flush request */
-};
-
-/*
- * request type modified bits. first four bits match BIO_RW* bits, important
- */
-enum rq_flag_bits {
-        __REQ_RW,               /* not set, read. set, write */
-        __REQ_FAILFAST_DEV,     /* no driver retries of device errors */
-        __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */
-        __REQ_FAILFAST_DRIVER,  /* no driver retries of driver errors */
-        /* above flags must match BIO_RW_* */
-        __REQ_DISCARD,          /* request to discard sectors */
-        __REQ_SORTED,           /* elevator knows about this request */
-        __REQ_SOFTBARRIER,      /* may not be passed by ioscheduler */
-        __REQ_HARDBARRIER,      /* may not be passed by drive either */
-        __REQ_FUA,              /* forced unit access */
-        __REQ_NOMERGE,          /* don't touch this for merging */
-        __REQ_STARTED,          /* drive already may have started this one */
-        __REQ_DONTPREP,         /* don't call prep for this one */
-        __REQ_QUEUED,           /* uses queueing */
-        __REQ_ELVPRIV,          /* elevator private data attached */
-        __REQ_FAILED,           /* set if the request failed */
-        __REQ_QUIET,            /* don't worry about errors */
-        __REQ_PREEMPT,          /* set for "ide_preempt" requests */
-        __REQ_ORDERED_COLOR,    /* is before or after barrier */
-        __REQ_RW_SYNC,          /* request is sync (sync write or read) */
-        __REQ_ALLOCED,          /* request came from our alloc pool */
-        __REQ_RW_META,          /* metadata io request */
-        __REQ_COPY_USER,        /* contains copies of user pages */
-        __REQ_INTEGRITY,        /* integrity metadata has been remapped */
-        __REQ_NOIDLE,           /* Don't anticipate more IO after this one */
-        __REQ_IO_STAT,          /* account I/O stat */
-        __REQ_MIXED_MERGE,      /* merge of different types, fail separately */
-        __REQ_NR_BITS,          /* stops here */
-};
-
-#define REQ_RW          (1 << __REQ_RW)
-#define REQ_FAILFAST_DEV        (1 << __REQ_FAILFAST_DEV)
-#define REQ_FAILFAST_TRANSPORT  (1 << __REQ_FAILFAST_TRANSPORT)
-#define REQ_FAILFAST_DRIVER     (1 << __REQ_FAILFAST_DRIVER)
-#define REQ_DISCARD     (1 << __REQ_DISCARD)
-#define REQ_SORTED      (1 << __REQ_SORTED)
-#define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER)
-#define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER)
-#define REQ_FUA         (1 << __REQ_FUA)
-#define REQ_NOMERGE     (1 << __REQ_NOMERGE)
-#define REQ_STARTED     (1 << __REQ_STARTED)
-#define REQ_DONTPREP    (1 << __REQ_DONTPREP)
-#define REQ_QUEUED      (1 << __REQ_QUEUED)
-#define REQ_ELVPRIV     (1 << __REQ_ELVPRIV)
-#define REQ_FAILED      (1 << __REQ_FAILED)
-#define REQ_QUIET       (1 << __REQ_QUIET)
-#define REQ_PREEMPT     (1 << __REQ_PREEMPT)
-#define REQ_ORDERED_COLOR       (1 << __REQ_ORDERED_COLOR)
-#define REQ_RW_SYNC     (1 << __REQ_RW_SYNC)
-#define REQ_ALLOCED     (1 << __REQ_ALLOCED)
-#define REQ_RW_META     (1 << __REQ_RW_META)
-#define REQ_COPY_USER   (1 << __REQ_COPY_USER)
-#define REQ_INTEGRITY   (1 << __REQ_INTEGRITY)
-#define REQ_NOIDLE      (1 << __REQ_NOIDLE)
-#define REQ_IO_STAT     (1 << __REQ_IO_STAT)
-#define REQ_MIXED_MERGE (1 << __REQ_MIXED_MERGE)
-
-#define REQ_FAILFAST_MASK       (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | \
-                                 REQ_FAILFAST_DRIVER)
-
 #define BLK_MAX_CDB     16
 
 /*
@@ -158,7 +79,6 @@ enum rq_flag_bits {
 struct request {
         struct list_head queuelist;
         struct call_single_data csd;
-        int cpu;
 
         struct request_queue *q;
 
@@ -166,9 +86,11 @@ struct request {
         enum rq_cmd_type_bits cmd_type;
         unsigned long atomic_flags;
 
+        int cpu;
+
         /* the following two fields are internal, NEVER access directly */
-        sector_t __sector;              /* sector cursor */
         unsigned int __data_len;        /* total data len */
+        sector_t __sector;              /* sector cursor */
 
         struct bio *bio;
         struct bio *biotail;
@@ -185,15 +107,19 @@ struct request {
         };
 
         /*
-         * two pointers are available for the IO schedulers, if they need
+         * Three pointers are available for the IO schedulers, if they need
          * more they have to dynamically allocate it.
          */
         void *elevator_private;
         void *elevator_private2;
+        void *elevator_private3;
 
         struct gendisk *rq_disk;
         unsigned long start_time;
-
+#ifdef CONFIG_BLK_CGROUP
+        unsigned long long start_time_ns;
+        unsigned long long io_start_time_ns;    /* when passed to hardware */
+#endif
         /* Number of scatter-gather DMA addr+len pairs after
          * physical address coalescing is performed.
          */
@@ -201,20 +127,20 @@ struct request {
 
         unsigned short ioprio;
 
+        int ref_count;
+
         void *special;          /* opaque pointer available for LLD use */
         char *buffer;           /* kaddr of the current segment if available */
 
         int tag;
         int errors;
 
-        int ref_count;
-
         /*
          * when request is used as a packet command carrier
          */
-        unsigned short cmd_len;
         unsigned char __cmd[BLK_MAX_CDB];
         unsigned char *cmd;
+        unsigned short cmd_len;
 
         unsigned int extra_len; /* length of alignment and padding */
         unsigned int sense_len;
@@ -259,6 +185,7 @@ struct request_pm_state
 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;
@@ -270,7 +197,6 @@ struct bvec_merge_data {
 };
 typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
                              struct bio_vec *);
-typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
 typedef void (softirq_done_fn)(struct request *);
 typedef int (dma_drain_needed_fn)(struct request *);
 typedef int (lld_busy_fn) (struct request_queue *q);
@@ -316,8 +242,7 @@ struct queue_limits {
         unsigned int            discard_alignment;
 
         unsigned short          logical_block_size;
-        unsigned short          max_hw_segments;
-        unsigned short          max_phys_segments;
+        unsigned short          max_segments;
 
         unsigned char           misaligned;
         unsigned char           discard_misaligned;
@@ -342,9 +267,9 @@ struct request_queue
         request_fn_proc         *request_fn;
         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;
-        prepare_flush_fn        *prepare_flush_fn;
         softirq_done_fn         *softirq_done_fn;
         rq_timed_out_fn         *rq_timed_out_fn;
         dma_drain_needed_fn     *dma_drain_needed;
@@ -461,13 +386,16 @@ struct request_queue
 #define QUEUE_FLAG_NONROT      14       /* 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_CQ          16       /* hardware does queuing */
-#define QUEUE_FLAG_DISCARD     17       /* supports DISCARD */
+#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_DEFAULT      ((1 << QUEUE_FLAG_IO_STAT) |            \
                                  (1 << QUEUE_FLAG_CLUSTER) |            \
                                  (1 << QUEUE_FLAG_STACKABLE)    |       \
-                                 (1 << QUEUE_FLAG_SAME_COMP))
+                                 (1 << QUEUE_FLAG_SAME_COMP)    |       \
+                                 (1 << QUEUE_FLAG_ADD_RANDOM))
 
 static inline int queue_is_locked(struct request_queue *q)
 {
@@ -586,43 +514,34 @@ enum {
 
 #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_queuing(q)    test_bit(QUEUE_FLAG_CQ, &(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)
+#define blk_queue_noxmerges(q)  \
+        test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
 #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)
+#define blk_queue_secdiscard(q) (blk_queue_discard(q) && \
+        test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
+
+#define blk_noretry_request(rq) \
+        ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
+                             REQ_FAILFAST_DRIVER))
+
+#define blk_account_rq(rq) \
+        (((rq)->cmd_flags & REQ_STARTED) && \
+         ((rq)->cmd_type == REQ_TYPE_FS || \
+          ((rq)->cmd_flags & REQ_DISCARD)))
 
-#define blk_fs_request(rq)      ((rq)->cmd_type == REQ_TYPE_FS)
-#define blk_pc_request(rq)      ((rq)->cmd_type == REQ_TYPE_BLOCK_PC)
-#define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL)
-#define blk_sense_request(rq)   ((rq)->cmd_type == REQ_TYPE_SENSE)
-
-#define blk_failfast_dev(rq)    ((rq)->cmd_flags & REQ_FAILFAST_DEV)
-#define blk_failfast_transport(rq) ((rq)->cmd_flags & REQ_FAILFAST_TRANSPORT)
-#define blk_failfast_driver(rq) ((rq)->cmd_flags & REQ_FAILFAST_DRIVER)
-#define blk_noretry_request(rq) (blk_failfast_dev(rq) ||        \
-                                 blk_failfast_transport(rq) ||  \
-                                 blk_failfast_driver(rq))
-#define blk_rq_started(rq)      ((rq)->cmd_flags & REQ_STARTED)
-#define blk_rq_io_stat(rq)      ((rq)->cmd_flags & REQ_IO_STAT)
-#define blk_rq_quiet(rq)        ((rq)->cmd_flags & REQ_QUIET)
-
-#define blk_account_rq(rq)      (blk_rq_started(rq) && (blk_fs_request(rq) || blk_discard_rq(rq))) 
-
-#define blk_pm_suspend_request(rq)      ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND)
-#define blk_pm_resume_request(rq)       ((rq)->cmd_type == REQ_TYPE_PM_RESUME)
 #define blk_pm_request(rq)      \
-        (blk_pm_suspend_request(rq) || blk_pm_resume_request(rq))
+        ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND || \
+         (rq)->cmd_type == REQ_TYPE_PM_RESUME)
 
 #define blk_rq_cpu_valid(rq)    ((rq)->cpu != -1)
-#define blk_sorted_rq(rq)       ((rq)->cmd_flags & REQ_SORTED)
-#define blk_barrier_rq(rq)      ((rq)->cmd_flags & REQ_HARDBARRIER)
-#define blk_fua_rq(rq)          ((rq)->cmd_flags & REQ_FUA)
-#define blk_discard_rq(rq)      ((rq)->cmd_flags & REQ_DISCARD)
 #define blk_bidi_rq(rq)         ((rq)->next_rq != NULL)
 /* rq->queuelist of dequeued request must be list_empty() */
 #define blk_queued_rq(rq)       (!list_empty(&(rq)->queuelist))
@@ -636,7 +555,7 @@ enum {
  */
 static inline bool rw_is_sync(unsigned int rw_flags)
 {
-        return !(rw_flags & REQ_RW) || (rw_flags & REQ_RW_SYNC);
+        return !(rw_flags & REQ_WRITE) || (rw_flags & REQ_SYNC);
 }
 
 static inline bool rq_is_sync(struct request *rq)
@@ -644,9 +563,6 @@ static inline bool rq_is_sync(struct request *rq)
         return rw_is_sync(rq->cmd_flags);
 }
 
-#define rq_is_meta(rq)          ((rq)->cmd_flags & REQ_RW_META)
-#define rq_noidle(rq)           ((rq)->cmd_flags & REQ_NOIDLE)
-
 static inline int blk_queue_full(struct request_queue *q, int sync)
 {
         if (sync)
@@ -679,7 +595,8 @@ static inline void blk_clear_queue_full(struct request_queue *q, int sync)
         (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
 #define rq_mergeable(rq)        \
         (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && \
-         (blk_discard_rq(rq) || blk_fs_request((rq))))
+         (((rq)->cmd_flags & REQ_DISCARD) || \
+          (rq)->cmd_type == REQ_TYPE_FS))
 
 /*
  * q->prep_rq_fn return values
@@ -704,7 +621,7 @@ extern unsigned long blk_max_low_pfn, blk_max_pfn;
 #define BLK_BOUNCE_HIGH         -1ULL
 #endif
 #define BLK_BOUNCE_ANY          (-1ULL)
-#define BLK_BOUNCE_ISA          (ISA_DMA_THRESHOLD)
+#define BLK_BOUNCE_ISA          (DMA_BIT_MASK(24))
 
 /*
  * default timeout for SG_IO if none specified
@@ -776,6 +693,8 @@ extern struct request *blk_make_request(struct request_queue *, struct bio *,
                                         gfp_t);
 extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
 extern void blk_requeue_request(struct request_queue *, struct request *);
+extern void blk_add_request_payload(struct request *rq, struct page *page,
+                unsigned int len);
 extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
 extern int blk_lld_busy(struct request_queue *q);
 extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
@@ -910,20 +829,24 @@ extern void blk_complete_request(struct request *);
 extern void __blk_complete_request(struct request *);
 extern void blk_abort_request(struct request *);
 extern void blk_abort_queue(struct request_queue *);
+extern void blk_unprep_request(struct request *);
 
 /*
  * Access functions for manipulating queue properties
  */
 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
                                         spinlock_t *lock, int node_id);
+extern struct request_queue *blk_init_allocated_queue_node(struct request_queue *,
+                                                           request_fn_proc *,
+                                                           spinlock_t *, int node_id);
 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
+extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
+                                                      request_fn_proc *, spinlock_t *);
 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_queue_max_sectors(struct request_queue *, unsigned int);
 extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
-extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
-extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
+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);
@@ -951,6 +874,7 @@ extern int blk_queue_dma_drain(struct request_queue *q,
 extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
 extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
+extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn);
 extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
 extern void blk_queue_dma_alignment(struct request_queue *, int);
 extern void blk_queue_update_dma_alignment(struct request_queue *, int);
@@ -958,7 +882,7 @@ 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 struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
-extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
+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 *);
@@ -995,32 +919,38 @@ static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
                 return NULL;
         return bqt->tag_index[tag];
 }
-
-extern int blkdev_issue_flush(struct block_device *, sector_t *);
-#define DISCARD_FL_WAIT         0x01    /* wait for completion */
-#define DISCARD_FL_BARRIER      0x02    /* issue DISCARD_BARRIER request */
-extern int blkdev_issue_discard(struct block_device *, sector_t sector,
-                sector_t nr_sects, gfp_t, int flags);
-
+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);
+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)
 {
         block <<= (sb->s_blocksize_bits - 9);
         nr_blocks <<= (sb->s_blocksize_bits - 9);
-        return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL,
-                                    DISCARD_FL_BARRIER);
+        return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_NOFS,
+                                   BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
 }
 
 extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
 
-#define MAX_PHYS_SEGMENTS 128
-#define MAX_HW_SEGMENTS 128
-#define SAFE_MAX_SECTORS 255
-#define BLK_DEF_MAX_SECTORS 1024
-
-#define MAX_SEGMENT_SIZE        65536
-
-#define BLK_SEG_BOUNDARY_MASK   0xFFFFFFFFUL
+enum blk_default_limits {
+        BLK_MAX_SEGMENTS        = 128,
+        BLK_SAFE_MAX_SECTORS    = 255,
+        BLK_DEF_MAX_SECTORS     = 1024,
+        BLK_MAX_SEGMENT_SIZE    = 65536,
+        BLK_SEG_BOUNDARY_MASK   = 0xFFFFFFFFUL,
+};
 
 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
 
@@ -1044,14 +974,9 @@ static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
         return q->limits.max_hw_sectors;
 }
 
-static inline unsigned short queue_max_hw_segments(struct request_queue *q)
-{
-        return q->limits.max_hw_segments;
-}
-
-static inline unsigned short queue_max_phys_segments(struct request_queue *q)
+static inline unsigned short queue_max_segments(struct request_queue *q)
 {
-        return q->limits.max_phys_segments;
+        return q->limits.max_segments;
 }
 
 static inline unsigned int queue_max_segment_size(struct request_queue *q)
@@ -1112,18 +1037,13 @@ static inline int queue_alignment_offset(struct request_queue *q)
         return q->limits.alignment_offset;
 }
 
-static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t offset)
+static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
 {
         unsigned int granularity = max(lim->physical_block_size, lim->io_min);
+        unsigned int alignment = (sector << 9) & (granularity - 1);
 
-        offset &= granularity - 1;
-        return (granularity + lim->alignment_offset - offset) & (granularity - 1);
-}
-
-static inline int queue_sector_alignment_offset(struct request_queue *q,
-                                                sector_t sector)
-{
-        return queue_limit_alignment_offset(&q->limits, sector << 9);
+        return (granularity + lim->alignment_offset - alignment)
+                & (granularity - 1);
 }
 
 static inline int bdev_alignment_offset(struct block_device *bdev)
@@ -1147,10 +1067,8 @@ static inline int queue_discard_alignment(struct request_queue *q)
         return q->limits.discard_alignment;
 }
 
-static inline int queue_sector_discard_alignment(struct request_queue *q,
-                                                 sector_t sector)
+static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
 {
-        struct queue_limits *lim = &q->limits;
         unsigned int alignment = (sector << 9) & (lim->discard_granularity - 1);
 
         return (lim->discard_granularity + lim->discard_alignment - alignment)
@@ -1210,6 +1128,48 @@ static inline void put_dev_sector(Sector p)
 struct work_struct;
 int kblockd_schedule_work(struct request_queue *q, struct work_struct *work);
 
+#ifdef CONFIG_BLK_CGROUP
+/*
+ * This should not be using sched_clock(). A real patch is in progress
+ * to fix this up, until that is in place we need to disable preemption
+ * around sched_clock() in this function and set_io_start_time_ns().
+ */
+static inline void set_start_time_ns(struct request *req)
+{
+        preempt_disable();
+        req->start_time_ns = sched_clock();
+        preempt_enable();
+}
+
+static inline void set_io_start_time_ns(struct request *req)
+{
+        preempt_disable();
+        req->io_start_time_ns = sched_clock();
+        preempt_enable();
+}
+
+static inline uint64_t rq_start_time_ns(struct request *req)
+{
+        return req->start_time_ns;
+}
+
+static inline uint64_t rq_io_start_time_ns(struct request *req)
+{
+        return req->io_start_time_ns;
+}
+#else
+static inline void set_start_time_ns(struct request *req) {}
+static inline void set_io_start_time_ns(struct request *req) {}
+static inline uint64_t rq_start_time_ns(struct request *req)
+{
+        return 0;
+}
+static inline uint64_t rq_io_start_time_ns(struct request *req)
+{
+        return 0;
+}
+#endif
+
 #define MODULE_ALIAS_BLOCKDEV(major,minor) \
         MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
@@ -1291,16 +1251,16 @@ static inline int blk_integrity_rq(struct request *rq)
 struct block_device_operations {
         int (*open) (struct block_device *, fmode_t);
         int (*release) (struct gendisk *, fmode_t);
-        int (*locked_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*direct_access) (struct block_device *, sector_t,
                                                 void **, unsigned long *);
         int (*media_changed) (struct gendisk *);
-        unsigned long long (*set_capacity) (struct gendisk *,
-                                                unsigned long long);
+        void (*unlock_native_capacity) (struct gendisk *);
         int (*revalidate_disk) (struct gendisk *);
         int (*getgeo)(struct block_device *, struct hd_geometry *);
+        /* this callback is with swap_lock and sometimes page table lock held */
+        void (*swap_slot_free_notify) (struct block_device *, unsigned long);
         struct module *owner;
 };