Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-22 12:11:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

blk-iocost: Don't let merges push vtime into the future

Browse Source 
Merges have the same problem that forced-bios had which is fixed by
the previous patch.  The cost of a merge is calculated at the time of
issue and force-advances vtime into the future.  Until global vtime
catches up, how the cgroup's hweight changes in the meantime doesn't
matter and it often leads to situations where the cost is calculated
at one hweight and paid at a very different one.  See the previous
patch for more details.

Fix it by never advancing vtime into the future for merges.  If budget
is available, vtime is advanced.  Otherwise, the cost is charged as
debt.

This brings merge cost handling in line with issue cost handling in
ioc_rqos_throttle().

Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Tejun Heo 2019-09-04 12:45:53 -07:00 committed by Jens Axboe
parent 36a524814f
commit e1518f63f2
1 changed files with 18 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
block/blk-iocost.c
View File

@ -1784,28 +1784,39 @@ static void ioc_rqos_merge(struct rq_qos *rqos, struct request *rq,
struct bio *bio) struct bio *bio)
{ {
struct ioc_gq *iocg = blkg_to_iocg(bio->bi_blkg); struct ioc_gq *iocg = blkg_to_iocg(bio->bi_blkg);
struct ioc *ioc = iocg->ioc;
sector_t bio_end = bio_end_sector(bio); sector_t bio_end = bio_end_sector(bio);
struct ioc_now now;
u32 hw_inuse; u32 hw_inuse;
u64 abs_cost, cost; u64 abs_cost, cost;
/* add iff the existing request has cost assigned */ /* bypass if disabled or for root cgroup */
if (!rq->bio || !rq->bio->bi_iocost_cost) if (!ioc->enabled || !iocg->level)
return; return;
abs_cost = calc_vtime_cost(bio, iocg, true); abs_cost = calc_vtime_cost(bio, iocg, true);
if (!abs_cost) if (!abs_cost)
return; return;
ioc_now(ioc, &now);
current_hweight(iocg, NULL, &hw_inuse);
cost = abs_cost_to_cost(abs_cost, hw_inuse);
/* update cursor if backmerging into the request at the cursor */ /* update cursor if backmerging into the request at the cursor */
if (blk_rq_pos(rq) < bio_end && if (blk_rq_pos(rq) < bio_end &&
blk_rq_pos(rq) + blk_rq_sectors(rq) == iocg->cursor) blk_rq_pos(rq) + blk_rq_sectors(rq) == iocg->cursor)
iocg->cursor = bio_end; iocg->cursor = bio_end;
current_hweight(iocg, NULL, &hw_inuse); /*
cost = div64_u64(abs_cost * HWEIGHT_WHOLE, hw_inuse); * Charge if there's enough vtime budget and the existing request
bio->bi_iocost_cost = cost; * has cost assigned. Otherwise, account it as debt. See debt
* handling in ioc_rqos_throttle() for details.
atomic64_add(cost, &iocg->vtime); */
if (rq->bio && rq->bio->bi_iocost_cost &&
time_before_eq64(atomic64_read(&iocg->vtime) + cost, now.vnow))
iocg_commit_bio(iocg, bio, cost);
else
atomic64_add(abs_cost, &iocg->abs_vdebt);
} }
static void ioc_rqos_done_bio(struct rq_qos *rqos, struct bio *bio) static void ioc_rqos_done_bio(struct rq_qos *rqos, struct bio *bio)