block, bfq: check and switch back to interactive wr also on queue split

As already explained in the message of commit "block, bfq: fix
wrong init of saved start time for weight raising", if a soft
real-time weight-raising period happens to be nested in a larger
interactive weight-raising period, then BFQ restores the interactive
weight raising at the end of the soft real-time weight raising. In
particular, BFQ checks whether the latter has ended only on request
dispatches.

Unfortunately, the above scheme fails to restore interactive weight
raising in the following corner case: if a bfq_queue, say Q,
1) Is merged with another bfq_queue while it is in a nested soft
real-time weight-raising period. The weight-raising state of Q is
then saved, and not considered any longer until a split occurs.
2) Is split from the other bfq_queue(s) at a time instant when its
soft real-time weight raising is already finished.
On the split, while resuming the previous, soft real-time
weight-raised state of the bfq_queue Q, BFQ checks whether the
current soft real-time weight-raising period is actually over. If so,
BFQ switches weight raising off for Q, *without* checking whether the
soft real-time period was actually nested in a non-yet-finished
interactive weight-raising period.

This commit addresses this issue by adding the above missing check in
bfq_queue splits, and restoring interactive weight raising if needed.

Signed-off-by: Paolo Valente <paolo.valente@linaro.org>
Tested-by: Angelo Ruocco <angeloruocco90@gmail.com>
Tested-by: Mirko Montanari <mirkomontanari91@gmail.com>
Tested-by: Oleksandr Natalenko <oleksandr@natalenko.name>
Tested-by: Lee Tibbert <lee.tibbert@gmail.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 49 insertions, 38 deletions

diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
index c25955c25e03..33b63bc4a64b 100644
--- a/block/bfq-iosched.c
+++ b/block/bfq-iosched.c
@@ -724,6 +724,44 @@ static void bfq_updated_next_req(struct bfq_data *bfqd,
         }
 }
 
+static unsigned int bfq_wr_duration(struct bfq_data *bfqd)
+{
+        u64 dur;
+
+        if (bfqd->bfq_wr_max_time > 0)
+                return bfqd->bfq_wr_max_time;
+
+        dur = bfqd->RT_prod;
+        do_div(dur, bfqd->peak_rate);
+
+        /*
+         * Limit duration between 3 and 13 seconds. Tests show that
+         * higher values than 13 seconds often yield the opposite of
+         * the desired result, i.e., worsen responsiveness by letting
+         * non-interactive and non-soft-real-time applications
+         * preserve weight raising for a too long time interval.
+         *
+         * On the other end, lower values than 3 seconds make it
+         * difficult for most interactive tasks to complete their jobs
+         * before weight-raising finishes.
+         */
+        if (dur > msecs_to_jiffies(13000))
+                dur = msecs_to_jiffies(13000);
+        else if (dur < msecs_to_jiffies(3000))
+                dur = msecs_to_jiffies(3000);
+
+        return dur;
+}
+
+/* switch back from soft real-time to interactive weight raising */
+static void switch_back_to_interactive_wr(struct bfq_queue *bfqq,
+                                          struct bfq_data *bfqd)
+{
+        bfqq->wr_coeff = bfqd->bfq_wr_coeff;
+        bfqq->wr_cur_max_time = bfq_wr_duration(bfqd);
+        bfqq->last_wr_start_finish = bfqq->wr_start_at_switch_to_srt;
+}
+
 static void
 bfq_bfqq_resume_state(struct bfq_queue *bfqq, struct bfq_data *bfqd,
                       struct bfq_io_cq *bic, bool bfq_already_existing)
@@ -750,10 +788,16 @@ bfq_bfqq_resume_state(struct bfq_queue *bfqq, struct bfq_data *bfqd,
         if (bfqq->wr_coeff > 1 && (bfq_bfqq_in_large_burst(bfqq) ||
             time_is_before_jiffies(bfqq->last_wr_start_finish +
                                    bfqq->wr_cur_max_time))) {
-                bfq_log_bfqq(bfqq->bfqd, bfqq,
-                    "resume state: switching off wr");
-
-                bfqq->wr_coeff = 1;
+                if (bfqq->wr_cur_max_time == bfqd->bfq_wr_rt_max_time &&
+                    !bfq_bfqq_in_large_burst(bfqq) &&
+                    time_is_after_eq_jiffies(bfqq->wr_start_at_switch_to_srt +
+                                             bfq_wr_duration(bfqd))) {
+                        switch_back_to_interactive_wr(bfqq, bfqd);
+                } else {
+                        bfqq->wr_coeff = 1;
+                        bfq_log_bfqq(bfqq->bfqd, bfqq,
+                                     "resume state: switching off wr");
+                }
         }
 
         /* make sure weight will be updated, however we got here */
@@ -1173,35 +1217,6 @@ static bool bfq_bfqq_update_budg_for_activation(struct bfq_data *bfqd,
         return wr_or_deserves_wr;
 }
 
-static unsigned int bfq_wr_duration(struct bfq_data *bfqd)
-{
-        u64 dur;
-
-        if (bfqd->bfq_wr_max_time > 0)
-                return bfqd->bfq_wr_max_time;
-
-        dur = bfqd->RT_prod;
-        do_div(dur, bfqd->peak_rate);
-
-        /*
-         * Limit duration between 3 and 13 seconds. Tests show that
-         * higher values than 13 seconds often yield the opposite of
-         * the desired result, i.e., worsen responsiveness by letting
-         * non-interactive and non-soft-real-time applications
-         * preserve weight raising for a too long time interval.
-         *
-         * On the other end, lower values than 3 seconds make it
-         * difficult for most interactive tasks to complete their jobs
-         * before weight-raising finishes.
-         */
-        if (dur > msecs_to_jiffies(13000))
-                dur = msecs_to_jiffies(13000);
-        else if (dur < msecs_to_jiffies(3000))
-                dur = msecs_to_jiffies(3000);
-
-        return dur;
-}
-
 /*
  * Return the farthest future time instant according to jiffies
  * macros.
@@ -3501,11 +3516,7 @@ static void bfq_update_wr_data(struct bfq_data *bfqd, struct bfq_queue *bfqq)
                                                bfq_wr_duration(bfqd)))
                                 bfq_bfqq_end_wr(bfqq);
                         else {
-                                /* switch back to interactive wr */
-                                bfqq->wr_coeff = bfqd->bfq_wr_coeff;
-                                bfqq->wr_cur_max_time = bfq_wr_duration(bfqd);
-                                bfqq->last_wr_start_finish =
-                                        bfqq->wr_start_at_switch_to_srt;
+                                switch_back_to_interactive_wr(bfqq, bfqd);
                                 bfqq->entity.prio_changed = 1;
                         }
                 }