Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 74 insertions, 128 deletions

diff --git a/block/elevator.c b/block/elevator.c
index 4e11559aa2b0..b0b38ce0dcb6 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -113,7 +113,7 @@ int elv_rq_merge_ok(struct request *rq, struct bio *bio)
 }
 EXPORT_SYMBOL(elv_rq_merge_ok);
 
-static inline int elv_try_merge(struct request *__rq, struct bio *bio)
+int elv_try_merge(struct request *__rq, struct bio *bio)
 {
         int ret = ELEVATOR_NO_MERGE;
 
@@ -155,13 +155,8 @@ static struct elevator_type *elevator_get(const char *name)
 
         e = elevator_find(name);
         if (!e) {
-                char elv[ELV_NAME_MAX + strlen("-iosched")];
-
                 spin_unlock(&elv_list_lock);
-
-                snprintf(elv, sizeof(elv), "%s-iosched", name);
-
-                request_module("%s", elv);
+                request_module("%s-iosched", name);
                 spin_lock(&elv_list_lock);
                 e = elevator_find(name);
         }
@@ -429,7 +424,7 @@ void elv_dispatch_sort(struct request_queue *q, struct request *rq)
         q->nr_sorted--;
 
         boundary = q->end_sector;
-        stop_flags = REQ_SOFTBARRIER | REQ_HARDBARRIER | REQ_STARTED;
+        stop_flags = REQ_SOFTBARRIER | REQ_STARTED;
         list_for_each_prev(entry, &q->queue_head) {
                 struct request *pos = list_entry_rq(entry);
 
@@ -519,6 +514,40 @@ int elv_merge(struct request_queue *q, struct request **req, struct bio *bio)
         return ELEVATOR_NO_MERGE;
 }
 
+/*
+ * Attempt to do an insertion back merge. Only check for the case where
+ * we can append 'rq' to an existing request, so we can throw 'rq' away
+ * afterwards.
+ *
+ * Returns true if we merged, false otherwise
+ */
+static bool elv_attempt_insert_merge(struct request_queue *q,
+                                     struct request *rq)
+{
+        struct request *__rq;
+
+        if (blk_queue_nomerges(q))
+                return false;
+
+        /*
+         * First try one-hit cache.
+         */
+        if (q->last_merge && blk_attempt_req_merge(q, q->last_merge, rq))
+                return true;
+
+        if (blk_queue_noxmerges(q))
+                return false;
+
+        /*
+         * See if our hash lookup can find a potential backmerge.
+         */
+        __rq = elv_rqhash_find(q, blk_rq_pos(rq));
+        if (__rq && blk_attempt_req_merge(q, __rq, rq))
+                return true;
+
+        return false;
+}
+
 void elv_merged_request(struct request_queue *q, struct request *rq, int type)
 {
         struct elevator_queue *e = q->elevator;
@@ -536,14 +565,18 @@ void elv_merge_requests(struct request_queue *q, struct request *rq,
                              struct request *next)
 {
         struct elevator_queue *e = q->elevator;
+        const int next_sorted = next->cmd_flags & REQ_SORTED;
 
-        if (e->ops->elevator_merge_req_fn)
+        if (next_sorted && e->ops->elevator_merge_req_fn)
                 e->ops->elevator_merge_req_fn(q, rq, next);
 
         elv_rqhash_reposition(q, rq);
-        elv_rqhash_del(q, next);
 
-        q->nr_sorted--;
+        if (next_sorted) {
+                elv_rqhash_del(q, next);
+                q->nr_sorted--;
+        }
+
         q->last_merge = rq;
 }
 
@@ -570,7 +603,7 @@ void elv_requeue_request(struct request_queue *q, struct request *rq)
 
         rq->cmd_flags &= ~REQ_STARTED;
 
-        elv_insert(q, rq, ELEVATOR_INSERT_REQUEUE);
+        __elv_add_request(q, rq, ELEVATOR_INSERT_REQUEUE);
 }
 
 void elv_drain_elevator(struct request_queue *q)
@@ -615,20 +648,28 @@ void elv_quiesce_end(struct request_queue *q)
         queue_flag_clear(QUEUE_FLAG_ELVSWITCH, q);
 }
 
-void elv_insert(struct request_queue *q, struct request *rq, int where)
+void __elv_add_request(struct request_queue *q, struct request *rq, int where)
 {
-        struct list_head *pos;
-        unsigned ordseq;
-        int unplug_it = 1;
-
         trace_block_rq_insert(q, rq);
 
         rq->q = q;
 
+        if (rq->cmd_flags & REQ_SOFTBARRIER) {
+                /* barriers are scheduling boundary, update end_sector */
+                if (rq->cmd_type == REQ_TYPE_FS ||
+                    (rq->cmd_flags & REQ_DISCARD)) {
+                        q->end_sector = rq_end_sector(rq);
+                        q->boundary_rq = rq;
+                }
+        } else if (!(rq->cmd_flags & REQ_ELVPRIV) &&
+                    (where == ELEVATOR_INSERT_SORT ||
+                     where == ELEVATOR_INSERT_SORT_MERGE))
+                where = ELEVATOR_INSERT_BACK;
+
         switch (where) {
+        case ELEVATOR_INSERT_REQUEUE:
         case ELEVATOR_INSERT_FRONT:
                 rq->cmd_flags |= REQ_SOFTBARRIER;
-
                 list_add(&rq->queuelist, &q->queue_head);
                 break;
 
@@ -649,6 +690,14 @@ void elv_insert(struct request_queue *q, struct request *rq, int where)
                 __blk_run_queue(q);
                 break;
 
+        case ELEVATOR_INSERT_SORT_MERGE:
+                /*
+                 * If we succeed in merging this request with one in the
+                 * queue already, we are done - rq has now been freed,
+                 * so no need to do anything further.
+                 */
+                if (elv_attempt_insert_merge(q, rq))
+                        break;
         case ELEVATOR_INSERT_SORT:
                 BUG_ON(rq->cmd_type != REQ_TYPE_FS &&
                        !(rq->cmd_flags & REQ_DISCARD));
@@ -668,115 +717,28 @@ void elv_insert(struct request_queue *q, struct request *rq, int where)
                 q->elevator->ops->elevator_add_req_fn(q, rq);
                 break;
 
-        case ELEVATOR_INSERT_REQUEUE:
-                /*
-                 * If ordered flush isn't in progress, we do front
-                 * insertion; otherwise, requests should be requeued
-                 * in ordseq order.
-                 */
+        case ELEVATOR_INSERT_FLUSH:
                 rq->cmd_flags |= REQ_SOFTBARRIER;
-
-                /*
-                 * Most requeues happen because of a busy condition,
-                 * don't force unplug of the queue for that case.
-                 */
-                unplug_it = 0;
-
-                if (q->ordseq == 0) {
-                        list_add(&rq->queuelist, &q->queue_head);
-                        break;
-                }
-
-                ordseq = blk_ordered_req_seq(rq);
-
-                list_for_each(pos, &q->queue_head) {
-                        struct request *pos_rq = list_entry_rq(pos);
-                        if (ordseq <= blk_ordered_req_seq(pos_rq))
-                                break;
-                }
-
-                list_add_tail(&rq->queuelist, pos);
+                blk_insert_flush(rq);
                 break;
-
         default:
                 printk(KERN_ERR "%s: bad insertion point %d\n",
                        __func__, where);
                 BUG();
         }
-
-        if (unplug_it && blk_queue_plugged(q)) {
-                int nrq = q->rq.count[BLK_RW_SYNC] + q->rq.count[BLK_RW_ASYNC]
-                                - queue_in_flight(q);
-
-                if (nrq >= q->unplug_thresh)
-                        __generic_unplug_device(q);
-        }
-}
-
-void __elv_add_request(struct request_queue *q, struct request *rq, int where,
-                       int plug)
-{
-        if (q->ordcolor)
-                rq->cmd_flags |= REQ_ORDERED_COLOR;
-
-        if (rq->cmd_flags & (REQ_SOFTBARRIER | REQ_HARDBARRIER)) {
-                /*
-                 * toggle ordered color
-                 */
-                if (rq->cmd_flags & REQ_HARDBARRIER)
-                        q->ordcolor ^= 1;
-
-                /*
-                 * barriers implicitly indicate back insertion
-                 */
-                if (where == ELEVATOR_INSERT_SORT)
-                        where = ELEVATOR_INSERT_BACK;
-
-                /*
-                 * this request is scheduling boundary, update
-                 * end_sector
-                 */
-                if (rq->cmd_type == REQ_TYPE_FS ||
-                    (rq->cmd_flags & REQ_DISCARD)) {
-                        q->end_sector = rq_end_sector(rq);
-                        q->boundary_rq = rq;
-                }
-        } else if (!(rq->cmd_flags & REQ_ELVPRIV) &&
-                    where == ELEVATOR_INSERT_SORT)
-                where = ELEVATOR_INSERT_BACK;
-
-        if (plug)
-                blk_plug_device(q);
-
-        elv_insert(q, rq, where);
 }
 EXPORT_SYMBOL(__elv_add_request);
 
-void elv_add_request(struct request_queue *q, struct request *rq, int where,
-                     int plug)
+void elv_add_request(struct request_queue *q, struct request *rq, int where)
 {
         unsigned long flags;
 
         spin_lock_irqsave(q->queue_lock, flags);
-        __elv_add_request(q, rq, where, plug);
+        __elv_add_request(q, rq, where);
         spin_unlock_irqrestore(q->queue_lock, flags);
 }
 EXPORT_SYMBOL(elv_add_request);
 
-int elv_queue_empty(struct request_queue *q)
-{
-        struct elevator_queue *e = q->elevator;
-
-        if (!list_empty(&q->queue_head))
-                return 0;
-
-        if (e->ops->elevator_queue_empty_fn)
-                return e->ops->elevator_queue_empty_fn(q);
-
-        return 1;
-}
-EXPORT_SYMBOL(elv_queue_empty);
-
 struct request *elv_latter_request(struct request_queue *q, struct request *rq)
 {
         struct elevator_queue *e = q->elevator;
@@ -802,7 +764,7 @@ int elv_set_request(struct request_queue *q, struct request *rq, gfp_t gfp_mask)
         if (e->ops->elevator_set_req_fn)
                 return e->ops->elevator_set_req_fn(q, rq, gfp_mask);
 
-        rq->elevator_private = NULL;
+        rq->elevator_private[0] = NULL;
         return 0;
 }
 
@@ -828,6 +790,8 @@ void elv_abort_queue(struct request_queue *q)
 {
         struct request *rq;
 
+        blk_abort_flushes(q);
+
         while (!list_empty(&q->queue_head)) {
                 rq = list_entry_rq(q->queue_head.next);
                 rq->cmd_flags |= REQ_QUIET;
@@ -855,24 +819,6 @@ void elv_completed_request(struct request_queue *q, struct request *rq)
                     e->ops->elevator_completed_req_fn)
                         e->ops->elevator_completed_req_fn(q, rq);
         }
-
-        /*
-         * Check if the queue is waiting for fs requests to be
-         * drained for flush sequence.
-         */
-        if (unlikely(q->ordseq)) {
-                struct request *next = NULL;
-
-                if (!list_empty(&q->queue_head))
-                        next = list_entry_rq(q->queue_head.next);
-
-                if (!queue_in_flight(q) &&
-                    blk_ordered_cur_seq(q) == QUEUE_ORDSEQ_DRAIN &&
-                    (!next || blk_ordered_req_seq(next) > QUEUE_ORDSEQ_DRAIN)) {
-                        blk_ordered_complete_seq(q, QUEUE_ORDSEQ_DRAIN, 0);
-                        __blk_run_queue(q);
-                }
-        }
 }
 
 #define to_elv(atr) container_of((atr), struct elv_fs_entry, attr)