block: kill legacy parts of timeout handling

[mirror_ubuntu-hirsute-kernel.git] / block / blk-timeout.c

diff --git a/block/blk-timeout.c b/block/blk-timeout.c
index f2cfd56e1606ed9d8e1da979a1e1e6cdcb506a38..6428d458072a274b980e4d8054f9de4dc639e391 100644 (file)
--- a/block/blk-timeout.c
+++ b/block/blk-timeout.c
@@ -78,70 +78,6 @@ void blk_delete_timer(struct request *req)
        list_del_init(&req->timeout_list);
 }
 
-static void blk_rq_timed_out(struct request *req)
-{
-       struct request_queue *q = req->q;
-       enum blk_eh_timer_return ret = BLK_EH_RESET_TIMER;
-
-       if (q->rq_timed_out_fn)
-               ret = q->rq_timed_out_fn(req);
-       switch (ret) {
-       case BLK_EH_RESET_TIMER:
-               blk_add_timer(req);
-               blk_clear_rq_complete(req);
-               break;
-       case BLK_EH_DONE:
-               /*
-                * LLD handles this for now but in the future
-                * we can send a request msg to abort the command
-                * and we can move more of the generic scsi eh code to
-                * the blk layer.
-                */
-               break;
-       default:
-               printk(KERN_ERR "block: bad eh return: %d\n", ret);
-               break;
-       }
-}
-
-static void blk_rq_check_expired(struct request *rq, unsigned long *next_timeout,
-                         unsigned int *next_set)
-{
-       const unsigned long deadline = blk_rq_deadline(rq);
-
-       if (time_after_eq(jiffies, 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, deadline)) {
-               *next_timeout = deadline;
-               *next_set = 1;
-       }
-}
-
-void blk_timeout_work(struct work_struct *work)
-{
-       struct request_queue *q =
-               container_of(work, struct request_queue, timeout_work);
-       unsigned long flags, next = 0;
-       struct request *rq, *tmp;
-       int next_set = 0;
-
-       spin_lock_irqsave(q->queue_lock, flags);
-
-       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));
-
-       spin_unlock_irqrestore(q->queue_lock, flags);
-}
-
 /**
  * blk_abort_request -- Request request recovery for the specified command
  * @req:       pointer to the request of interest
@@ -153,20 +89,13 @@ void blk_timeout_work(struct work_struct *work)
  */
 void blk_abort_request(struct request *req)
 {
-       if (req->q->mq_ops) {
-               /*
-                * All we need to ensure is that timeout scan takes place
-                * immediately and that scan sees the new timeout value.
-                * No need for fancy synchronizations.
-                */
-               blk_rq_set_deadline(req, jiffies);
-               kblockd_schedule_work(&req->q->timeout_work);
-       } else {
-               if (blk_mark_rq_complete(req))
-                       return;
-               blk_delete_timer(req);
-               blk_rq_timed_out(req);
-       }
+       /*
+        * All we need to ensure is that timeout scan takes place
+        * immediately and that scan sees the new timeout value.
+        * No need for fancy synchronizations.
+        */
+       blk_rq_set_deadline(req, jiffies);
+       kblockd_schedule_work(&req->q->timeout_work);
 }
 EXPORT_SYMBOL_GPL(blk_abort_request);
 
@@ -194,13 +123,6 @@ void blk_add_timer(struct request *req)
        struct request_queue *q = req->q;
        unsigned long expiry;
 
-       if (!q->mq_ops)
-               lockdep_assert_held(q->queue_lock);
-
-       /* blk-mq has its own handler, so we don't need ->rq_timed_out_fn */
-       if (!q->mq_ops && !q->rq_timed_out_fn)
-               return;
-
        BUG_ON(!list_empty(&req->timeout_list));
 
        /*
@@ -213,13 +135,6 @@ void blk_add_timer(struct request *req)
        req->rq_flags &= ~RQF_TIMED_OUT;
        blk_rq_set_deadline(req, jiffies + req->timeout);
 
-       /*
-        * Only the non-mq case needs to add the request to a protected list.
-        * For the mq case we simply scan the tag map.
-        */
-       if (!q->mq_ops)
-               list_add_tail(&req->timeout_list, &req->q->timeout_list);
-
        /*
         * If the timer isn't already pending or this timeout is earlier
         * than an existing one, modify the timer. Round up to next nearest