block: kill legacy parts of timeout handling

The only user of legacy timing now is BSG, which is invoked
from the mq timeout handler. Kill the legacy code, and rename
the q->rq_timed_out_fn to q->bsg_job_timeout_fn.

Reviewed-by: Hannes Reinecke <hare@suse.com>
Tested-by: Ming Lei <ming.lei@redhat.com>
Reviewed-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 7 insertions, 92 deletions

diff --git a/block/blk-timeout.c b/block/blk-timeout.c
index f2cfd56e1606..6428d458072a 100644
--- 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));
 
         /*
@@ -214,13 +136,6 @@ void blk_add_timer(struct request *req)
         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
          * second.