block, bfq: prevent soft_rt_next_start from being stuck at infinity

BFQ can deem a bfq_queue as soft real-time only if the queue
- periodically becomes completely idle, i.e., empty and with
  no still-outstanding I/O request;
- after becoming idle, gets new I/O only after a special reference
  time soft_rt_next_start.

In this respect, after commit "block, bfq: consider also past I/O in
soft real-time detection", the value of soft_rt_next_start can never
decrease. This causes a problem with the following special updating
case for soft_rt_next_start: to prevent queues that are not completely
idle to be wrongly detected as soft real-time (when they become
non-empty again), soft_rt_next_start is temporarily set to infinity
for empty queues with still outstanding I/O requests. But, if such an
update is actually performed, then, because of the above commit,
soft_rt_next_start will be stuck at infinity forever, and the queue
will have no more chance to be considered soft real-time.

On slow systems, this problem does cause actual soft real-time
applications to be occasionally not detected as such.

This commit addresses this issue by eliminating the pushing of
soft_rt_next_start to infinity, and by changing the way non-empty
queues are prevented from being wrongly detected as soft
real-time. Simply, a queue that becomes non-empty again can now be
detected as soft real-time only if it has no outstanding I/O request.

Signed-off-by: Davide Sapienza <sapienza.dav@gmail.com>
Signed-off-by: Paolo Valente <paolo.valente@linaro.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 2 insertions, 27 deletions

diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
index 128b3be49463..495b9ddb3355 100644
--- a/block/bfq-iosched.c
+++ b/block/bfq-iosched.c
@@ -1363,15 +1363,6 @@ static bool bfq_bfqq_update_budg_for_activation(struct bfq_data *bfqd,
 }
 
 /*
- * Return the farthest future time instant according to jiffies
- * macros.
- */
-static unsigned long bfq_greatest_from_now(void)
-{
-        return jiffies + MAX_JIFFY_OFFSET;
-}
-
-/*
  * Return the farthest past time instant according to jiffies
  * macros.
  */
@@ -1515,7 +1506,8 @@ static void bfq_bfqq_handle_idle_busy_switch(struct bfq_data *bfqd,
         in_burst = bfq_bfqq_in_large_burst(bfqq);
         soft_rt = bfqd->bfq_wr_max_softrt_rate > 0 &&
                 !in_burst &&
-                time_is_before_jiffies(bfqq->soft_rt_next_start);
+                time_is_before_jiffies(bfqq->soft_rt_next_start) &&
+                bfqq->dispatched == 0;
         *interactive = !in_burst && idle_for_long_time;
         wr_or_deserves_wr = bfqd->low_latency &&
                 (bfqq->wr_coeff > 1 ||
@@ -3222,23 +3214,6 @@ void bfq_bfqq_expire(struct bfq_data *bfqd,
                                 bfq_bfqq_softrt_next_start(bfqd, bfqq);
                 else {
                         /*
-                         * The application is still waiting for the
-                         * completion of one or more requests:
-                         * prevent it from possibly being incorrectly
-                         * deemed as soft real-time by setting its
-                         * soft_rt_next_start to infinity. In fact,
-                         * without this assignment, the application
-                         * would be incorrectly deemed as soft
-                         * real-time if:
-                         * 1) it issued a new request before the
-                         *    completion of all its in-flight
-                         *    requests, and
-                         * 2) at that time, its soft_rt_next_start
-                         *    happened to be in the past.
-                         */
-                        bfqq->soft_rt_next_start =
-                                bfq_greatest_from_now();
-                        /*
                          * Schedule an update of soft_rt_next_start to when
                          * the task may be discovered to be isochronous.
                          */