1 files changed, 45 insertions, 17 deletions

diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index 11ce6aaf1bd0..a46d030e092a 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -133,6 +133,7 @@ struct cfq_data {
         mempool_t *crq_pool;
 
         int rq_in_driver;
+        int hw_tag;
 
         /*
          * schedule slice state info
@@ -500,10 +501,13 @@ static void cfq_resort_rr_list(struct cfq_queue *cfqq, int preempted)
 
         /*
          * if queue was preempted, just add to front to be fair. busy_rr
-         * isn't sorted.
+         * isn't sorted, but insert at the back for fairness.
          */
         if (preempted || list == &cfqd->busy_rr) {
-                list_add(&cfqq->cfq_list, list);
+                if (preempted)
+                        list = list->prev;
+
+                list_add_tail(&cfqq->cfq_list, list);
                 return;
         }
 
@@ -664,6 +668,15 @@ static void cfq_activate_request(request_queue_t *q, struct request *rq)
         struct cfq_data *cfqd = q->elevator->elevator_data;
 
         cfqd->rq_in_driver++;
+
+        /*
+         * If the depth is larger 1, it really could be queueing. But lets
+         * make the mark a little higher - idling could still be good for
+         * low queueing, and a low queueing number could also just indicate
+         * a SCSI mid layer like behaviour where limit+1 is often seen.
+         */
+        if (!cfqd->hw_tag && cfqd->rq_in_driver > 4)
+                cfqd->hw_tag = 1;
 }
 
 static void cfq_deactivate_request(request_queue_t *q, struct request *rq)
@@ -879,6 +892,13 @@ static struct cfq_queue *cfq_set_active_queue(struct cfq_data *cfqd)
                 cfqq = list_entry_cfqq(cfqd->cur_rr.next);
 
         /*
+         * If no new queues are available, check if the busy list has some
+         * before falling back to idle io.
+         */
+        if (!cfqq && !list_empty(&cfqd->busy_rr))
+                cfqq = list_entry_cfqq(cfqd->busy_rr.next);
+
+        /*
          * if we have idle queues and no rt or be queues had pending
          * requests, either allow immediate service if the grace period
          * has passed or arm the idle grace timer
@@ -1458,7 +1478,8 @@ retry:
                  * set ->slice_left to allow preemption for a new process
                  */
                 cfqq->slice_left = 2 * cfqd->cfq_slice_idle;
-                cfq_mark_cfqq_idle_window(cfqq);
+                if (!cfqd->hw_tag)
+                        cfq_mark_cfqq_idle_window(cfqq);
                 cfq_mark_cfqq_prio_changed(cfqq);
                 cfq_init_prio_data(cfqq);
         }
@@ -1649,7 +1670,7 @@ cfq_update_idle_window(struct cfq_data *cfqd, struct cfq_queue *cfqq,
 {
         int enable_idle = cfq_cfqq_idle_window(cfqq);
 
-        if (!cic->ioc->task || !cfqd->cfq_slice_idle)
+        if (!cic->ioc->task || !cfqd->cfq_slice_idle || cfqd->hw_tag)
                 enable_idle = 0;
         else if (sample_valid(cic->ttime_samples)) {
                 if (cic->ttime_mean > cfqd->cfq_slice_idle)
@@ -1740,14 +1761,24 @@ cfq_crq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
 
         cfqq->next_crq = cfq_choose_req(cfqd, cfqq->next_crq, crq);
 
+        cic = crq->io_context;
+
         /*
          * we never wait for an async request and we don't allow preemption
          * of an async request. so just return early
          */
-        if (!cfq_crq_is_sync(crq))
+        if (!cfq_crq_is_sync(crq)) {
+                /*
+                 * sync process issued an async request, if it's waiting
+                 * then expire it and kick rq handling.
+                 */
+                if (cic == cfqd->active_cic &&
+                    del_timer(&cfqd->idle_slice_timer)) {
+                        cfq_slice_expired(cfqd, 0);
+                        cfq_start_queueing(cfqd, cfqq);
+                }
                 return;
-
-        cic = crq->io_context;
+        }
 
         cfq_update_io_thinktime(cfqd, cic);
         cfq_update_io_seektime(cfqd, cic, crq);
@@ -2165,10 +2196,9 @@ static void cfq_idle_class_timer(unsigned long data)
          * race with a non-idle queue, reset timer
          */
         end = cfqd->last_end_request + CFQ_IDLE_GRACE;
-        if (!time_after_eq(jiffies, end)) {
-                cfqd->idle_class_timer.expires = end;
-                add_timer(&cfqd->idle_class_timer);
-        } else
+        if (!time_after_eq(jiffies, end))
+                mod_timer(&cfqd->idle_class_timer, end);
+        else
                 cfq_schedule_dispatch(cfqd);
 
         spin_unlock_irqrestore(cfqd->queue->queue_lock, flags);
@@ -2221,14 +2251,14 @@ static void cfq_exit_queue(elevator_t *e)
         kfree(cfqd);
 }
 
-static int cfq_init_queue(request_queue_t *q, elevator_t *e)
+static void *cfq_init_queue(request_queue_t *q, elevator_t *e)
 {
         struct cfq_data *cfqd;
         int i;
 
         cfqd = kmalloc(sizeof(*cfqd), GFP_KERNEL);
         if (!cfqd)
-                return -ENOMEM;
+                return NULL;
 
         memset(cfqd, 0, sizeof(*cfqd));
 
@@ -2258,8 +2288,6 @@ static int cfq_init_queue(request_queue_t *q, elevator_t *e)
         for (i = 0; i < CFQ_QHASH_ENTRIES; i++)
                 INIT_HLIST_HEAD(&cfqd->cfq_hash[i]);
 
-        e->elevator_data = cfqd;
-
         cfqd->queue = q;
 
         cfqd->max_queued = q->nr_requests / 4;
@@ -2286,14 +2314,14 @@ static int cfq_init_queue(request_queue_t *q, elevator_t *e)
         cfqd->cfq_slice_async_rq = cfq_slice_async_rq;
         cfqd->cfq_slice_idle = cfq_slice_idle;
 
-        return 0;
+        return cfqd;
 out_crqpool:
         kfree(cfqd->cfq_hash);
 out_cfqhash:
         kfree(cfqd->crq_hash);
 out_crqhash:
         kfree(cfqd);
-        return -ENOMEM;
+        return NULL;
 }
 
 static void cfq_slab_kill(void)