Commit 4baa8bb1 authored Sep 21, 2017 by Paolo Valente Committed by Jens Axboe Oct 03, 2017

block, bfq: fix wrong init of saved start time for weight raising

This commit fixes a bug that causes bfq to fail to guarantee a high
responsiveness on some drives, if there is heavy random read+write I/O
in the background. More precisely, such a failure allowed this bug to
be found [1], but the bug may well cause other yet unreported
anomalies.

BFQ raises the weight of the bfq_queues associated with soft real-time
applications, to privilege the I/O, and thus reduce latency, for these
applications. This mechanism is named soft-real-time weight raising in
BFQ. A soft real-time period may happen to be nested into an
interactive weight raising period, i.e., it may happen that, when a
bfq_queue switches to a soft real-time weight-raised state, the
bfq_queue is already being weight-raised because deemed interactive
too. In this case, BFQ saves in a special variable
wr_start_at_switch_to_srt, the time instant when the interactive
weight-raising period started for the bfq_queue, i.e., the time
instant when BFQ started to deem the bfq_queue interactive. This value
is then used to check whether the interactive weight-raising period
would still be in progress when the soft real-time weight-raising
period ends. If so, interactive weight raising is restored for the
bfq_queue. This restore is useful, in particular, because it prevents
bfq_queues from losing their interactive weight raising prematurely,
as a consequence of spurious, short-lived soft real-time
weight-raising periods caused by wrong detections as soft real-time.

If, instead, a bfq_queue switches to soft-real-time weight raising
while it *is not* already in an interactive weight-raising period,
then the variable wr_start_at_switch_to_srt has no meaning during the
following soft real-time weight-raising period. Unfortunately the
handling of this case is wrong in BFQ: not only the variable is not
flagged somehow as meaningless, but it is also set to the time when
the switch to soft real-time weight-raising occurs. This may cause an
interactive weight-raising period to be considered mistakenly as still
in progress, and thus a spurious interactive weight-raising period to
start for the bfq_queue, at the end of the soft-real-time
weight-raising period. In particular the spurious interactive
weight-raising period will be considered as still in progress, if the
soft-real-time weight-raising period does not last very long. The
bfq_queue will then be wrongly privileged and, if I/O bound, will
unjustly steal bandwidth to truly interactive or soft real-time
bfq_queues, harming responsiveness and low latency.

This commit fixes this issue by just setting wr_start_at_switch_to_srt
to minus infinity (farthest past time instant according to jiffies
macros): when the soft-real-time weight-raising period ends, certainly
no interactive weight-raising period will be considered as still in
progress.

[1] Background I/O Type: Random - Background I/O mix: Reads and writes
- Application to start: LibreOffice Writer in
http://www.phoronix.com/scan.php?page=news_item&px=Linux-4.13-IO-Laptop

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

parent aac8d41c

block/bfq-iosched.c

+31 −19

Original line number	Diff line number	Diff line
		@@ -1202,6 +1202,24 @@ static unsigned int bfq_wr_duration(struct bfq_data *bfqd)
		return dur;
		}

		/*
		* 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.
		*/
		static unsigned long bfq_smallest_from_now(void)
		{
		return jiffies - MAX_JIFFY_OFFSET;
		}

		static void bfq_update_bfqq_wr_on_rq_arrival(struct bfq_data *bfqd,
		struct bfq_queue *bfqq,
		unsigned int old_wr_coeff,
		@@ -1216,7 +1234,19 @@ static void bfq_update_bfqq_wr_on_rq_arrival(struct bfq_data *bfqd,
		bfqq->wr_coeff = bfqd->bfq_wr_coeff;
		bfqq->wr_cur_max_time = bfq_wr_duration(bfqd);
		} else {
		bfqq->wr_start_at_switch_to_srt = jiffies;
		/*
		* No interactive weight raising in progress
		* here: assign minus infinity to
		* wr_start_at_switch_to_srt, to make sure
		* that, at the end of the soft-real-time
		* weight raising periods that is starting
		* now, no interactive weight-raising period
		* may be wrongly considered as still in
		* progress (and thus actually started by
		* mistake).
		*/
		bfqq->wr_start_at_switch_to_srt =
		bfq_smallest_from_now();
		bfqq->wr_coeff = bfqd->bfq_wr_coeff *
		BFQ_SOFTRT_WEIGHT_FACTOR;
		bfqq->wr_cur_max_time =
		@@ -2897,24 +2927,6 @@ static unsigned long bfq_bfqq_softrt_next_start(struct bfq_data *bfqd,
		jiffies + nsecs_to_jiffies(bfqq->bfqd->bfq_slice_idle) + 4);
		}

		/*
		* 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.
		*/
		static unsigned long bfq_smallest_from_now(void)
		{
		return jiffies - MAX_JIFFY_OFFSET;
		}

		/**
		* bfq_bfqq_expire - expire a queue.
		* @bfqd: device owning the queue.