Unverified Commit 3340cc60 authored by openeuler-ci-bot's avatar openeuler-ci-bot Committed by Gitee
Browse files

!9511 blk-throttle: check for overflow in calculate_bytes_allowed 

Merge Pull Request from: @ci-robot 
 
PR sync from: Li Lingfeng <lilingfeng3@huawei.com>
https://mailweb.openeuler.org/hyperkitty/list/kernel@openeuler.org/message/FEDEGGJ3L4JB67X3IPT5JMH3WQFYRSDQ/ 
Check for overflow in calculate_bytes_allowed.

Khazhismel Kumykov (1):
  blk-throttle: check for overflow in calculate_bytes_allowed

Yu Kuai (2):
  blk-throttle: factor out code to calculate ios/bytes_allowed
  blk-throttle: use calculate_io/bytes_allowed() for throtl_trim_slice()


-- 
2.31.1
 
https://gitee.com/openeuler/kernel/issues/IA8QFN 
 
Link:https://gitee.com/openeuler/kernel/pulls/9511

 

Reviewed-by: default avatarYu Kuai <yukuai3@huawei.com>
Reviewed-by: default avatarJialin Zhang <zhangjialin11@huawei.com>
Signed-off-by: default avatarJialin Zhang <zhangjialin11@huawei.com>
parents 5b8dd9be adfd3b65

block/blk-throttle.c

+55 −42
Original line number Diff line number Diff line
@@ -853,11 +853,46 @@ static bool throtl_slice_used(struct throtl_grp *tg, bool rw) 
	return true;

}



static unsigned int calculate_io_allowed(u32 iops_limit,

					 unsigned long jiffy_elapsed)

{

	unsigned int io_allowed;

	u64 tmp;



	/*

	 * jiffy_elapsed should not be a big value as minimum iops can be

	 * 1 then at max jiffy elapsed should be equivalent of 1 second as we

	 * will allow dispatch after 1 second and after that slice should

	 * have been trimmed.

	 */



	tmp = (u64)iops_limit * jiffy_elapsed;

	do_div(tmp, HZ);



	if (tmp > UINT_MAX)

		io_allowed = UINT_MAX;

	else

		io_allowed = tmp;



	return io_allowed;

}



static u64 calculate_bytes_allowed(u64 bps_limit, unsigned long jiffy_elapsed)

{

	/*

	 * Can result be wider than 64 bits?

	 * We check against 62, not 64, due to ilog2 truncation.

	 */

	if (ilog2(bps_limit) + ilog2(jiffy_elapsed) - ilog2(HZ) > 62)

		return U64_MAX;

	return mul_u64_u64_div_u64(bps_limit, (u64)jiffy_elapsed, (u64)HZ);

}



/* Trim the used slices and adjust slice start accordingly */

static inline void throtl_trim_slice(struct throtl_grp *tg, bool rw)

{

	unsigned long nr_slices, time_elapsed, io_trim;

	u64 bytes_trim, tmp;

	unsigned long time_elapsed, io_trim;

	u64 bytes_trim;



	BUG_ON(time_before(tg->slice_end[rw], tg->slice_start[rw]));
@@ -879,19 +914,14 @@ static inline void throtl_trim_slice(struct throtl_grp *tg, bool rw) 


	throtl_set_slice_end(tg, rw, jiffies + tg->td->throtl_slice);



	time_elapsed = jiffies - tg->slice_start[rw];



	nr_slices = time_elapsed / tg->td->throtl_slice;



	if (!nr_slices)

	time_elapsed = rounddown(jiffies - tg->slice_start[rw],

				 tg->td->throtl_slice);

	if (!time_elapsed)

		return;

	tmp = tg_bps_limit(tg, rw) * tg->td->throtl_slice * nr_slices;

	do_div(tmp, HZ);

	bytes_trim = tmp;



	io_trim = (tg_iops_limit(tg, rw) * tg->td->throtl_slice * nr_slices) /

		HZ;



	bytes_trim = calculate_bytes_allowed(tg_bps_limit(tg, rw),

					     time_elapsed);

	io_trim = calculate_io_allowed(tg_iops_limit(tg, rw), time_elapsed);

	if (!bytes_trim && !io_trim)

		return;
@@ -905,21 +935,21 @@ static inline void throtl_trim_slice(struct throtl_grp *tg, bool rw) 
	else

		tg->io_disp[rw] = 0;



	tg->slice_start[rw] += nr_slices * tg->td->throtl_slice;

	tg->slice_start[rw] += time_elapsed;



	throtl_log(&tg->service_queue,

		   "[%c] trim slice nr=%lu bytes=%llu io=%lu start=%lu end=%lu jiffies=%lu",

		   rw == READ ? 'R' : 'W', nr_slices, bytes_trim, io_trim,

		   tg->slice_start[rw], tg->slice_end[rw], jiffies);

		   rw == READ ? 'R' : 'W', time_elapsed / tg->td->throtl_slice,

		   bytes_trim, io_trim, tg->slice_start[rw], tg->slice_end[rw],

		   jiffies);

}



static bool tg_with_in_iops_limit(struct throtl_grp *tg, struct bio *bio,

static bool tg_within_iops_limit(struct throtl_grp *tg, struct bio *bio,

				 u32 iops_limit, unsigned long *wait)

{

	bool rw = bio_data_dir(bio);

	unsigned int io_allowed;

	unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd;

	u64 tmp;



	if (iops_limit == UINT_MAX) {

		if (wait)
@@ -931,22 +961,7 @@ static bool tg_with_in_iops_limit(struct throtl_grp *tg, struct bio *bio, 


	/* Round up to the next throttle slice, wait time must be nonzero */

	jiffy_elapsed_rnd = roundup(jiffy_elapsed + 1, tg->td->throtl_slice);



	/*

	 * jiffy_elapsed_rnd should not be a big value as minimum iops can be

	 * 1 then at max jiffy elapsed should be equivalent of 1 second as we

	 * will allow dispatch after 1 second and after that slice should

	 * have been trimmed.

	 */



	tmp = (u64)iops_limit * jiffy_elapsed_rnd;

	do_div(tmp, HZ);



	if (tmp > UINT_MAX)

		io_allowed = UINT_MAX;

	else

		io_allowed = tmp;



	io_allowed = calculate_io_allowed(iops_limit, jiffy_elapsed_rnd);

	if (tg->io_disp[rw] + 1 <= io_allowed) {

		if (wait)

			*wait = 0;
@@ -961,7 +976,7 @@ static bool tg_with_in_iops_limit(struct throtl_grp *tg, struct bio *bio, 
	return false;

}



static bool tg_with_in_bps_limit(struct throtl_grp *tg, struct bio *bio,

static bool tg_within_bps_limit(struct throtl_grp *tg, struct bio *bio,

				u64 bps_limit, unsigned long *wait)

{

	bool rw = bio_data_dir(bio);
@@ -982,9 +997,7 @@ static bool tg_with_in_bps_limit(struct throtl_grp *tg, struct bio *bio, 
		jiffy_elapsed_rnd = tg->td->throtl_slice;



	jiffy_elapsed_rnd = roundup(jiffy_elapsed_rnd, tg->td->throtl_slice);

	bytes_allowed = mul_u64_u64_div_u64(bps_limit, (u64)jiffy_elapsed_rnd,

					    (u64)HZ);



	bytes_allowed = calculate_bytes_allowed(bps_limit, jiffy_elapsed_rnd);

	if (tg->bytes_disp[rw] + bio_size <= bytes_allowed) {

		if (wait)

			*wait = 0;
@@ -1055,8 +1068,8 @@ static bool tg_may_dispatch(struct throtl_grp *tg, struct bio *bio, 
	if (iops_limit != UINT_MAX)

		tg->io_disp[rw] += atomic_xchg(&tg->io_split_cnt[rw], 0);



	if (tg_with_in_bps_limit(tg, bio, bps_limit, &bps_wait) &&

	    tg_with_in_iops_limit(tg, bio, iops_limit, &iops_wait)) {

	if (tg_within_bps_limit(tg, bio, bps_limit, &bps_wait) &&

	    tg_within_iops_limit(tg, bio, iops_limit, &iops_wait)) {

		if (wait)

			*wait = 0;

		return true;