4 files changed, 201 insertions, 97 deletions

diff --git a/drivers/block/elevator.c b/drivers/block/elevator.c
index 4144f30d82a9..a27555908d35 100644
--- a/drivers/block/elevator.c
+++ b/drivers/block/elevator.c
@@ -40,6 +40,11 @@
 static DEFINE_SPINLOCK(elv_list_lock);
 static LIST_HEAD(elv_list);
 
+static inline sector_t rq_last_sector(struct request *rq)
+{
+        return rq->sector + rq->nr_sectors;
+}
+
 /*
  * can we safely merge with this request?
  */
@@ -143,6 +148,9 @@ static int elevator_attach(request_queue_t *q, struct elevator_type *e,
         INIT_LIST_HEAD(&q->queue_head);
         q->last_merge = NULL;
         q->elevator = eq;
+        q->last_sector = 0;
+        q->boundary_rq = NULL;
+        q->max_back_kb = 0;
 
         if (eq->ops->elevator_init_fn)
                 ret = eq->ops->elevator_init_fn(q, eq);
@@ -225,6 +233,48 @@ void elevator_exit(elevator_t *e)
         kfree(e);
 }
 
+/*
+ * Insert rq into dispatch queue of q.  Queue lock must be held on
+ * entry.  If sort != 0, rq is sort-inserted; otherwise, rq will be
+ * appended to the dispatch queue.  To be used by specific elevators.
+ */
+void elv_dispatch_insert(request_queue_t *q, struct request *rq, int sort)
+{
+        sector_t boundary;
+        unsigned max_back;
+        struct list_head *entry;
+
+        if (!sort) {
+                /* Specific elevator is performing sort.  Step away. */
+                q->last_sector = rq_last_sector(rq);
+                q->boundary_rq = rq;
+                list_add_tail(&rq->queuelist, &q->queue_head);
+                return;
+        }
+
+        boundary = q->last_sector;
+        max_back = q->max_back_kb * 2;
+        boundary = boundary > max_back ? boundary - max_back : 0;
+
+        list_for_each_prev(entry, &q->queue_head) {
+                struct request *pos = list_entry_rq(entry);
+
+                if (pos->flags & (REQ_SOFTBARRIER|REQ_HARDBARRIER|REQ_STARTED))
+                        break;
+                if (rq->sector >= boundary) {
+                        if (pos->sector < boundary)
+                                continue;
+                } else {
+                        if (pos->sector >= boundary)
+                                break;
+                }
+                if (rq->sector >= pos->sector)
+                        break;
+        }
+
+        list_add(&rq->queuelist, entry);
+}
+
 int elv_merge(request_queue_t *q, struct request **req, struct bio *bio)
 {
         elevator_t *e = q->elevator;
@@ -255,13 +305,7 @@ void elv_merge_requests(request_queue_t *q, struct request *rq,
                 e->ops->elevator_merge_req_fn(q, rq, next);
 }
 
-/*
- * For careful internal use by the block layer. Essentially the same as
- * a requeue in that it tells the io scheduler that this request is not
- * active in the driver or hardware anymore, but we don't want the request
- * added back to the scheduler. Function is not exported.
- */
-void elv_deactivate_request(request_queue_t *q, struct request *rq)
+void elv_requeue_request(request_queue_t *q, struct request *rq)
 {
         elevator_t *e = q->elevator;
 
@@ -269,19 +313,14 @@ void elv_deactivate_request(request_queue_t *q, struct request *rq)
          * it already went through dequeue, we need to decrement the
          * in_flight count again
          */
-        if (blk_account_rq(rq))
+        if (blk_account_rq(rq)) {
                 q->in_flight--;
+                if (blk_sorted_rq(rq) && e->ops->elevator_deactivate_req_fn)
+                        e->ops->elevator_deactivate_req_fn(q, rq);
+        }
 
         rq->flags &= ~REQ_STARTED;
 
-        if (e->ops->elevator_deactivate_req_fn)
-                e->ops->elevator_deactivate_req_fn(q, rq);
-}
-
-void elv_requeue_request(request_queue_t *q, struct request *rq)
-{
-        elv_deactivate_request(q, rq);
-
         /*
          * if this is the flush, requeue the original instead and drop the flush
          */
@@ -290,55 +329,89 @@ void elv_requeue_request(request_queue_t *q, struct request *rq)
                 rq = rq->end_io_data;
         }
 
-        /*
-         * the request is prepped and may have some resources allocated.
-         * allowing unprepped requests to pass this one may cause resource
-         * deadlock.  turn on softbarrier.
-         */
-        rq->flags |= REQ_SOFTBARRIER;
-
-        /*
-         * if iosched has an explicit requeue hook, then use that. otherwise
-         * just put the request at the front of the queue
-         */
-        if (q->elevator->ops->elevator_requeue_req_fn)
-                q->elevator->ops->elevator_requeue_req_fn(q, rq);
-        else
-                __elv_add_request(q, rq, ELEVATOR_INSERT_FRONT, 0);
+        __elv_add_request(q, rq, ELEVATOR_INSERT_FRONT, 0);
 }
 
 void __elv_add_request(request_queue_t *q, struct request *rq, int where,
                        int plug)
 {
-        /*
-         * barriers implicitly indicate back insertion
-         */
-        if (rq->flags & (REQ_SOFTBARRIER | REQ_HARDBARRIER) &&
-            where == ELEVATOR_INSERT_SORT)
-                where = ELEVATOR_INSERT_BACK;
+        if (rq->flags & (REQ_SOFTBARRIER | REQ_HARDBARRIER)) {
+                /*
+                 * barriers implicitly indicate back insertion
+                 */
+                if (where == ELEVATOR_INSERT_SORT)
+                        where = ELEVATOR_INSERT_BACK;
+
+                /*
+                 * this request is scheduling boundary, update last_sector
+                 */
+                if (blk_fs_request(rq)) {
+                        q->last_sector = rq_last_sector(rq);
+                        q->boundary_rq = rq;
+                }
+        }
 
         if (plug)
                 blk_plug_device(q);
 
         rq->q = q;
 
-        if (!test_bit(QUEUE_FLAG_DRAIN, &q->queue_flags)) {
-                q->elevator->ops->elevator_add_req_fn(q, rq, where);
-
-                if (blk_queue_plugged(q)) {
-                        int nrq = q->rq.count[READ] + q->rq.count[WRITE]
-                                  - q->in_flight;
-
-                        if (nrq >= q->unplug_thresh)
-                                __generic_unplug_device(q);
-                }
-        } else
+        if (unlikely(test_bit(QUEUE_FLAG_DRAIN, &q->queue_flags))) {
                 /*
                  * if drain is set, store the request "locally". when the drain
                  * is finished, the requests will be handed ordered to the io