8 files changed, 57 insertions, 57 deletions

diff --git a/block/blk-ioc.c b/block/blk-ioc.c
index cbdabb0dd6d7..98e6bf61b0ac 100644
--- a/block/blk-ioc.c
+++ b/block/blk-ioc.c
@@ -39,8 +39,6 @@ int put_io_context(struct io_context *ioc)
 
         if (atomic_long_dec_and_test(&ioc->refcount)) {
                 rcu_read_lock();
-                if (ioc->aic && ioc->aic->dtor)
-                        ioc->aic->dtor(ioc->aic);
                 cfq_dtor(ioc);
                 rcu_read_unlock();
 
@@ -76,8 +74,6 @@ void exit_io_context(struct task_struct *task)
         task_unlock(task);
 
         if (atomic_dec_and_test(&ioc->nr_tasks)) {
-                if (ioc->aic && ioc->aic->exit)
-                        ioc->aic->exit(ioc->aic);
                 cfq_exit(ioc);
 
         }
@@ -97,7 +93,6 @@ struct io_context *alloc_io_context(gfp_t gfp_flags, int node)
                 ret->ioprio = 0;
                 ret->last_waited = jiffies; /* doesn't matter... */
                 ret->nr_batch_requests = 0; /* because this is 0 */
-                ret->aic = NULL;
                 INIT_RADIX_TREE(&ret->radix_root, GFP_ATOMIC | __GFP_HIGH);
                 INIT_HLIST_HEAD(&ret->cic_list);
                 ret->ioc_data = NULL;
diff --git a/block/blk-settings.c b/block/blk-settings.c
index d52d4adc440b..5eeb9e0d256e 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -528,7 +528,7 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
                      sector_t offset)
 {
         sector_t alignment;
-        unsigned int top, bottom;
+        unsigned int top, bottom, ret = 0;
 
         t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
         t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
@@ -546,6 +546,8 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
         t->max_segment_size = min_not_zero(t->max_segment_size,
                                            b->max_segment_size);
 
+        t->misaligned |= b->misaligned;
+
         alignment = queue_limit_alignment_offset(b, offset);
 
         /* Bottom device has different alignment.  Check that it is
@@ -558,8 +560,10 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
                 bottom = max(b->physical_block_size, b->io_min) + alignment;
 
                 /* Verify that top and bottom intervals line up */
-                if (max(top, bottom) & (min(top, bottom) - 1))
+                if (max(top, bottom) & (min(top, bottom) - 1)) {
                         t->misaligned = 1;
+                        ret = -1;
+                }
         }
 
         t->logical_block_size = max(t->logical_block_size,
@@ -578,18 +582,21 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
         if (t->physical_block_size & (t->logical_block_size - 1)) {
                 t->physical_block_size = t->logical_block_size;
                 t->misaligned = 1;
+                ret = -1;
         }
 
         /* Minimum I/O a multiple of the physical block size? */
         if (t->io_min & (t->physical_block_size - 1)) {
                 t->io_min = t->physical_block_size;
                 t->misaligned = 1;
+                ret = -1;
         }
 
         /* Optimal I/O a multiple of the physical block size? */
         if (t->io_opt & (t->physical_block_size - 1)) {
                 t->io_opt = 0;
                 t->misaligned = 1;
+                ret = -1;
         }
 
         /* Find lowest common alignment_offset */
@@ -597,8 +604,10 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
                 & (max(t->physical_block_size, t->io_min) - 1);
 
         /* Verify that new alignment_offset is on a logical block boundary */
-        if (t->alignment_offset & (t->logical_block_size - 1))
+        if (t->alignment_offset & (t->logical_block_size - 1)) {
                 t->misaligned = 1;
+                ret = -1;
+        }
 
         /* Discard alignment and granularity */
         if (b->discard_granularity) {
@@ -626,11 +635,33 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
                         (t->discard_granularity - 1);
         }
 
-        return t->misaligned ? -1 : 0;
+        return ret;
 }
 EXPORT_SYMBOL(blk_stack_limits);
 
 /**
+ * bdev_stack_limits - adjust queue limits for stacked drivers
+ * @t:  the stacking driver limits (top device)
+ * @bdev:  the component block_device (bottom)
+ * @start:  first data sector within component device
+ *
+ * Description:
+ *    Merges queue limits for a top device and a block_device.  Returns
+ *    0 if alignment didn't change.  Returns -1 if adding the bottom
+ *    device caused misalignment.
+ */
+int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
+                      sector_t start)
+{
+        struct request_queue *bq = bdev_get_queue(bdev);
+
+        start += get_start_sect(bdev);
+
+        return blk_stack_limits(t, &bq->limits, start << 9);
+}
+EXPORT_SYMBOL(bdev_stack_limits);
+
+/**
  * disk_stack_limits - adjust queue limits for stacked drivers
  * @disk:  MD/DM gendisk (top)
  * @bdev:  the underlying block device (bottom)
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index 918c7fd9aeb1..ee130f14d1fc 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -3077,6 +3077,12 @@ cfq_should_preempt(struct cfq_data *cfqd, struct cfq_queue *new_cfqq,
                 return true;
 
         /*
+         * Don't allow a non-RT request to preempt an ongoing RT cfqq timeslice.
+         */
+        if (cfq_class_rt(cfqq) && !cfq_class_rt(new_cfqq))
+                return false;
+
+        /*
          * if the new request is sync, but the currently running queue is
          * not, let the sync request have priority.
          */
diff --git a/block/genhd.c b/block/genhd.c
index b11a4ad7d571..d13ba76a169c 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -867,7 +867,7 @@ static ssize_t disk_discard_alignment_show(struct device *dev,
 {
         struct gendisk *disk = dev_to_disk(dev);
 
-        return sprintf(buf, "%u\n", queue_discard_alignment(disk->queue));
+        return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
 }
 
 static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index be625475cf6d..4b22feb01a0c 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -503,16 +503,15 @@ int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
                 return 0;
         }
 
-        if (blk_stack_limits(limits, &q->limits, start << 9) < 0)
-                DMWARN("%s: target device %s is misaligned: "
+        if (bdev_stack_limits(limits, bdev, start) < 0)
+                DMWARN("%s: adding target device %s caused an alignment inconsistency: "
                        "physical_block_size=%u, logical_block_size=%u, "
                        "alignment_offset=%u, start=%llu",
                        dm_device_name(ti->table->md), bdevname(bdev, b),
                        q->limits.physical_block_size,
                        q->limits.logical_block_size,
                        q->limits.alignment_offset,
-                       (unsigned long long) start << 9);
-
+                       (unsigned long long) start << SECTOR_SHIFT);
 
         /*
          * Check if merge fn is supported.
@@ -1026,9 +1025,9 @@ combine_limits:
                  * for the table.
                  */
                 if (blk_stack_limits(limits, &ti_limits, 0) < 0)
-                        DMWARN("%s: target device "
+                        DMWARN("%s: adding target device "
                                "(start sect %llu len %llu) "
-                               "is misaligned",
+                               "caused an alignment inconsistency",
                                dm_device_name(table->md),
                                (unsigned long long) ti->begin,
                                (unsigned long long) ti->len);
@@ -1080,15 +1079,6 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
                                struct queue_limits *limits)
 {
         /*
-         * Each target device in the table has a data area that should normally
-         * be aligned such that the DM device's alignment_offset is 0.
-         * FIXME: Propagate alignment_offsets up the stack and warn of
-         *        sub-optimal or inconsistent settings.
-         */
-        limits->alignment_offset = 0;
-        limits->misaligned = 0;
-
-        /*
          * Copy table's limits to the DM device's request_queue
          */
         q->limits = *limits;
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 9b98173a8184..5c8018977efa 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -938,6 +938,8 @@ extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
 extern void blk_set_default_limits(struct queue_limits *lim);
 extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
                             sector_t offset);
+extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
+                            sector_t offset);
 extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
                               sector_t offset);
 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
@@ -1148,8 +1150,11 @@ static inline int queue_discard_alignment(struct request_queue *q)
 static inline int queue_sector_discard_alignment(struct request_queue *q,
                                                  sector_t sector)
 {
-        return ((sector << 9) - q->limits.discard_alignment)
-                & (q->limits.discard_granularity - 1);
+        struct queue_limits *lim = &q->limits;
+        unsigned int alignment = (sector << 9) & (lim->discard_granularity - 1);
+
+        return (lim->discard_granularity + lim->discard_alignment - alignment)
+                & (lim->discard_granularity - 1);
 }
 
 static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index c6c0c41af35f..9717081c75ad 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -256,9 +256,9 @@ extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
 #define part_stat_read(part, field)                                     \
 ({                                                                      \
         typeof((part)->dkstats->field) res = 0;                         \
-        int i;                                                          \
-        for_each_possible_cpu(i)                                        \
-                res += per_cpu_ptr((part)->dkstats, i)->field;          \
+        unsigned int _cpu;                                              \
+        for_each_possible_cpu(_cpu)                                     \
+                res += per_cpu_ptr((part)->dkstats, _cpu)->field;       \
         res;                                                            \
 })
 
diff --git a/include/linux/iocontext.h b/include/linux/iocontext.h
index a63235996309..78ef023227d4 100644
--- a/include/linux/iocontext.h
+++ b/include/linux/iocontext.h
@@ -4,32 +4,6 @@
 #include <linux/radix-tree.h>
 #include <linux/rcupdate.h>
 
-/*
- * This is the per-process anticipatory I/O scheduler state.
- */
-struct as_io_context {
-        spinlock_t lock;
-
-        void (*dtor)(struct as_io_context *aic); /* destructor */
-        void (*exit)(struct as_io_context *aic); /* called on task exit */
-
-        unsigned long state;
-        atomic_t nr_queued; /* queued reads & sync writes */
-        atomic_t nr_dispatched; /* number of requests gone to the drivers */
-
-        /* IO History tracking */
-        /* Thinktime */
-        unsigned long last_end_request;
-        unsigned long ttime_total;
-        unsigned long ttime_samples;
-        unsigned long ttime_mean;
-        /* Layout pattern */
-        unsigned int seek_samples;
-        sector_t last_request_pos;
-        u64 seek_total;
-        sector_t seek_mean;
-};
-
 struct cfq_queue;
 struct cfq_io_context {
         void *key;
@@ -78,7 +52,6 @@ struct io_context {
         unsigned long last_waited; /* Time last woken after wait for request */
         int nr_batch_requests;     /* Number of requests left in the batch */
 
-        struct as_io_context *aic;
         struct radix_tree_root radix_root;
         struct hlist_head cic_list;
         void *ioc_data;