1 files changed, 46 insertions, 27 deletions

diff --git a/block/blk-timeout.c b/block/blk-timeout.c
index 65f103563969..22846cf3595a 100644
--- a/block/blk-timeout.c
+++ b/block/blk-timeout.c
@@ -7,6 +7,7 @@
 #include <linux/fault-inject.h>
 
 #include "blk.h"
+#include "blk-mq.h"
 
 #ifdef CONFIG_FAIL_IO_TIMEOUT
 
@@ -88,11 +89,18 @@ static void blk_rq_timed_out(struct request *req)
                 ret = q->rq_timed_out_fn(req);
         switch (ret) {
         case BLK_EH_HANDLED:
-                __blk_complete_request(req);
+                /* Can we use req->errors here? */
+                if (q->mq_ops)
+                        blk_mq_complete_request(req, req->errors);
+                else
+                        __blk_complete_request(req);
                 break;
         case BLK_EH_RESET_TIMER:
                 blk_clear_rq_complete(req);
-                blk_add_timer(req);
+                if (q->mq_ops)
+                        blk_mq_add_timer(req);
+                else
+                        blk_add_timer(req);
                 break;
         case BLK_EH_NOT_HANDLED:
                 /*
@@ -108,6 +116,23 @@ static void blk_rq_timed_out(struct request *req)
         }
 }
 
+void blk_rq_check_expired(struct request *rq, unsigned long *next_timeout,
+                          unsigned int *next_set)
+{
+        if (time_after_eq(jiffies, rq->deadline)) {
+                list_del_init(&rq->timeout_list);
+
+                /*
+                 * Check if we raced with end io completion
+                 */
+                if (!blk_mark_rq_complete(rq))
+                        blk_rq_timed_out(rq);
+        } else if (!*next_set || time_after(*next_timeout, rq->deadline)) {
+                *next_timeout = rq->deadline;
+                *next_set = 1;
+        }
+}
+
 void blk_rq_timed_out_timer(unsigned long data)
 {
         struct request_queue *q = (struct request_queue *) data;
@@ -117,21 +142,8 @@ void blk_rq_timed_out_timer(unsigned long data)
 
         spin_lock_irqsave(q->queue_lock, flags);
 
-        list_for_each_entry_safe(rq, tmp, &q->timeout_list, timeout_list) {
-                if (time_after_eq(jiffies, rq->deadline)) {
-                        list_del_init(&rq->timeout_list);
-
-                        /*
-                         * Check if we raced with end io completion
-                         */
-                        if (blk_mark_rq_complete(rq))
-                                continue;
-                        blk_rq_timed_out(rq);
-                } else if (!next_set || time_after(next, rq->deadline)) {
-                        next = rq->deadline;
-                        next_set = 1;
-                }
-        }
+        list_for_each_entry_safe(rq, tmp, &q->timeout_list, timeout_list)
+                blk_rq_check_expired(rq, &next, &next_set);
 
         if (next_set)
                 mod_timer(&q->timeout, round_jiffies_up(next));
@@ -157,15 +169,7 @@ void blk_abort_request(struct request *req)
 }
 EXPORT_SYMBOL_GPL(blk_abort_request);
 
-/**
- * blk_add_timer - Start timeout timer for a single request
- * @req:        request that is about to start running.
- *
- * Notes:
- *    Each request has its own timer, and as it is added to the queue, we
- *    set up the timer. When the request completes, we cancel the timer.
- */
-void blk_add_timer(struct request *req)
+void __blk_add_timer(struct request *req, struct list_head *timeout_list)
 {
         struct request_queue *q = req->q;
         unsigned long expiry;
@@ -184,7 +188,8 @@ void blk_add_timer(struct request *req)
                 req->timeout = q->rq_timeout;
 
         req->deadline = jiffies + req->timeout;
-        list_add_tail(&req->timeout_list, &q->timeout_list);
+        if (timeout_list)
+                list_add_tail(&req->timeout_list, timeout_list);
 
         /*
          * If the timer isn't already pending or this timeout is earlier
@@ -196,5 +201,19 @@ void blk_add_timer(struct request *req)
         if (!timer_pending(&q->timeout) ||
             time_before(expiry, q->timeout.expires))
                 mod_timer(&q->timeout, expiry);
+
+}
+
+/**
+ * blk_add_timer - Start timeout timer for a single request
+ * @req:        request that is about to start running.
+ *
+ * Notes:
+ *    Each request has its own timer, and as it is added to the queue, we
+ *    set up the timer. When the request completes, we cancel the timer.
+ */
+void blk_add_timer(struct request *req)
+{
+        __blk_add_timer(req, &req->q->timeout_list);
 }