4 files changed, 73 insertions, 4 deletions

diff --git a/Documentation/ABI/testing/sysfs-block-dm b/Documentation/ABI/testing/sysfs-block-dm
index 87ca5691e29b..ac4b6fe245d9 100644
--- a/Documentation/ABI/testing/sysfs-block-dm
+++ b/Documentation/ABI/testing/sysfs-block-dm
@@ -23,3 +23,17 @@ Description:	Device-mapper device suspend state.
                 Contains the value 1 while the device is suspended.
                 Otherwise it contains 0. Read-only attribute.
 Users:          util-linux, device-mapper udev rules
+
+What:           /sys/block/dm-<num>/dm/rq_based_seq_io_merge_deadline
+Date:           March 2015
+KernelVersion:  4.1
+Contact:        dm-devel@redhat.com
+Description:    Allow control over how long a request that is a
+                reasonable merge candidate can be queued on the request
+                queue.  The resolution of this deadline is in
+                microseconds (ranging from 1 to 100000 usecs).
+                Setting this attribute to 0 (the default) will disable
+                request-based DM's merge heuristic and associated extra
+                accounting.  This attribute is not applicable to
+                bio-based DM devices so it will only ever report 0 for
+                them.
diff --git a/drivers/md/dm-sysfs.c b/drivers/md/dm-sysfs.c
index 1271c31709fd..f5bb3944f75e 100644
--- a/drivers/md/dm-sysfs.c
+++ b/drivers/md/dm-sysfs.c
@@ -92,11 +92,13 @@ static ssize_t dm_attr_suspended_show(struct mapped_device *md, char *buf)
 static DM_ATTR_RO(name);
 static DM_ATTR_RO(uuid);
 static DM_ATTR_RO(suspended);
+static DM_ATTR_RW(rq_based_seq_io_merge_deadline);
 
 static struct attribute *dm_attrs[] = {
         &dm_attr_name.attr,
         &dm_attr_uuid.attr,
         &dm_attr_suspended.attr,
+        &dm_attr_rq_based_seq_io_merge_deadline.attr,
         NULL,
 };
 
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 2ae78b31e4c0..5294e016e92b 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -21,6 +21,7 @@
 #include <linux/delay.h>
 #include <linux/wait.h>
 #include <linux/kthread.h>
+#include <linux/ktime.h>
 #include <linux/elevator.h> /* for rq_end_sector() */
 
 #include <trace/events/block.h>
@@ -219,8 +220,10 @@ struct mapped_device {
         struct task_struct *kworker_task;
 
         /* for request-based merge heuristic in dm_request_fn() */
-        sector_t last_rq_pos;
+        unsigned seq_rq_merge_deadline_usecs;
         int last_rq_rw;
+        sector_t last_rq_pos;
+        ktime_t last_rq_start_time;
 };
 
 /*
@@ -1935,8 +1938,11 @@ static void dm_start_request(struct mapped_device *md, struct request *orig)
         blk_start_request(orig);
         atomic_inc(&md->pending[rq_data_dir(orig)]);
 
-        md->last_rq_pos = rq_end_sector(orig);
-        md->last_rq_rw = rq_data_dir(orig);
+        if (md->seq_rq_merge_deadline_usecs) {
+                md->last_rq_pos = rq_end_sector(orig);
+                md->last_rq_rw = rq_data_dir(orig);
+                md->last_rq_start_time = ktime_get();
+        }
 
         /*
          * Hold the md reference here for the in-flight I/O.
@@ -1948,6 +1954,45 @@ static void dm_start_request(struct mapped_device *md, struct request *orig)
         dm_get(md);
 }
 
+#define MAX_SEQ_RQ_MERGE_DEADLINE_USECS 100000
+
+ssize_t dm_attr_rq_based_seq_io_merge_deadline_show(struct mapped_device *md, char *buf)
+{
+        return sprintf(buf, "%u\n", md->seq_rq_merge_deadline_usecs);
+}
+
+ssize_t dm_attr_rq_based_seq_io_merge_deadline_store(struct mapped_device *md,
+                                                     const char *buf, size_t count)
+{
+        unsigned deadline;
+
+        if (!dm_request_based(md))
+                return count;
+
+        if (kstrtouint(buf, 10, &deadline))
+                return -EINVAL;
+
+        if (deadline > MAX_SEQ_RQ_MERGE_DEADLINE_USECS)
+                deadline = MAX_SEQ_RQ_MERGE_DEADLINE_USECS;
+
+        md->seq_rq_merge_deadline_usecs = deadline;
+
+        return count;
+}
+
+static bool dm_request_peeked_before_merge_deadline(struct mapped_device *md)
+{
+        ktime_t kt_deadline;
+
+        if (!md->seq_rq_merge_deadline_usecs)
+                return false;
+
+        kt_deadline = ns_to_ktime((u64)md->seq_rq_merge_deadline_usecs * NSEC_PER_USEC);
+        kt_deadline = ktime_add_safe(md->last_rq_start_time, kt_deadline);
+
+        return !ktime_after(ktime_get(), kt_deadline);
+}
+
 /*
  * q->request_fn for request-based dm.
  * Called with the queue lock held.
@@ -1990,7 +2035,8 @@ static void dm_request_fn(struct request_queue *q)
                         continue;
                 }
 
-                if (md_in_flight(md) && rq->bio && rq->bio->bi_vcnt == 1 &&
+                if (dm_request_peeked_before_merge_deadline(md) &&
+                    md_in_flight(md) && rq->bio && rq->bio->bi_vcnt == 1 &&
                     md->last_rq_pos == pos && md->last_rq_rw == rq_data_dir(rq))
                         goto delay_and_out;
 
@@ -2532,6 +2578,9 @@ static int dm_init_request_based_queue(struct mapped_device *md)
         if (!q)
                 return 0;
 
+        /* disable dm_request_fn's merge heuristic by default */
+        md->seq_rq_merge_deadline_usecs = 0;
+
         md->queue = q;
         dm_init_md_queue(md);
         blk_queue_softirq_done(md->queue, dm_softirq_done);
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index db495863fa5f..5522422cc6c4 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -234,4 +234,8 @@ static inline bool dm_message_test_buffer_overflow(char *result, unsigned maxlen
         return !maxlen || strlen(result) + 1 >= maxlen;
 }
 
+ssize_t dm_attr_rq_based_seq_io_merge_deadline_show(struct mapped_device *md, char *buf);
+ssize_t dm_attr_rq_based_seq_io_merge_deadline_store(struct mapped_device *md,
+                                                     const char *buf, size_t count);
+
 #endif