Commit 7402e635 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'block-6.6-2023-09-08' of git://git.kernel.dk/linux 

Pull block fixes from Jens Axboe:

 - Fix null_blk polled IO timeout handling (Chengming)

 - Regression fix for swapped arguments in drbd bvec_set_page()
   (Christoph)

 - String length handling fix for s390 dasd (Heiko)

 - Fixes for blk-throttle accounting (Yu)

 - Fix page pinning issue for same page segments (Christoph)

 - Remove redundant file_remove_privs() call (Christoph)

 - Fix a regression in partition handling for devices not supporting
   partitions (Li)

* tag 'block-6.6-2023-09-08' of git://git.kernel.dk/linux:
  drbd: swap bvec_set_page len and offset
  block: fix pin count management when merging same-page segments
  null_blk: fix poll request timeout handling
  s390/dasd: fix string length handling
  block: don't add or resize partition on the disk with GENHD_FL_NO_PART
  block: remove the call to file_remove_privs in blkdev_write_iter
  blk-throttle: consider 'carryover_ios/bytes' in throtl_trim_slice()
  blk-throttle: use calculate_io/bytes_allowed() for throtl_trim_slice()
  blk-throttle: fix wrong comparation while 'carryover_ios/bytes' is negative
  blk-throttle: print signed value 'carryover_bytes/ios' for user
parents 7ccc3ebf 4b9c2eda

block/blk-map.c

+3 −4
Original line number Diff line number Diff line
@@ -315,12 +315,11 @@ static int bio_map_user_iov(struct request *rq, struct iov_iter *iter, 
					n = bytes;



				if (!bio_add_hw_page(rq->q, bio, page, n, offs,

						     max_sectors, &same_page)) {

					if (same_page)

						bio_release_page(bio, page);

						     max_sectors, &same_page))

					break;

				}



				if (same_page)

					bio_release_page(bio, page);

				bytes -= n;

				offs = 0;

			}

block/blk-throttle.c

+56 −56
Original line number Diff line number Diff line
@@ -697,11 +697,41 @@ 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)

{

	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;

	long long bytes_trim;

	int io_trim;



	BUG_ON(time_before(tg->slice_end[rw], tg->slice_start[rw]));
@@ -723,67 +753,38 @@ 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;



	if (!bytes_trim && !io_trim)

	bytes_trim = calculate_bytes_allowed(tg_bps_limit(tg, rw),

					     time_elapsed) +

		     tg->carryover_bytes[rw];

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

		  tg->carryover_ios[rw];

	if (bytes_trim <= 0 && io_trim <= 0)

		return;



	if (tg->bytes_disp[rw] >= bytes_trim)

	tg->carryover_bytes[rw] = 0;

	if ((long long)tg->bytes_disp[rw] >= bytes_trim)

		tg->bytes_disp[rw] -= bytes_trim;

	else

		tg->bytes_disp[rw] = 0;



	if (tg->io_disp[rw] >= io_trim)

	tg->carryover_ios[rw] = 0;

	if ((int)tg->io_disp[rw] >= io_trim)

		tg->io_disp[rw] -= io_trim;

	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);

}



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)

{

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

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

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

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

		   jiffies);

}



static void __tg_update_carryover(struct throtl_grp *tg, bool rw)
@@ -816,7 +817,7 @@ static void tg_update_carryover(struct throtl_grp *tg) 
		__tg_update_carryover(tg, WRITE);



	/* see comments in struct throtl_grp for meaning of these fields. */

	throtl_log(&tg->service_queue, "%s: %llu %llu %u %u\n", __func__,

	throtl_log(&tg->service_queue, "%s: %lld %lld %d %d\n", __func__,

		   tg->carryover_bytes[READ], tg->carryover_bytes[WRITE],

		   tg->carryover_ios[READ], tg->carryover_ios[WRITE]);

}
@@ -825,7 +826,7 @@ static unsigned long tg_within_iops_limit(struct throtl_grp *tg, struct bio *bio 
				 u32 iops_limit)

{

	bool rw = bio_data_dir(bio);

	unsigned int io_allowed;

	int io_allowed;

	unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd;



	if (iops_limit == UINT_MAX) {
@@ -838,9 +839,8 @@ static unsigned long tg_within_iops_limit(struct throtl_grp *tg, struct bio *bio 
	jiffy_elapsed_rnd = roundup(jiffy_elapsed + 1, tg->td->throtl_slice);

	io_allowed = calculate_io_allowed(iops_limit, jiffy_elapsed_rnd) +

		     tg->carryover_ios[rw];

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

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

		return 0;

	}



	/* Calc approx time to dispatch */

	jiffy_wait = jiffy_elapsed_rnd - jiffy_elapsed;
@@ -851,7 +851,8 @@ static unsigned long tg_within_bps_limit(struct throtl_grp *tg, struct bio *bio, 
				u64 bps_limit)

{

	bool rw = bio_data_dir(bio);

	u64 bytes_allowed, extra_bytes;

	long long bytes_allowed;

	u64 extra_bytes;

	unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd;

	unsigned int bio_size = throtl_bio_data_size(bio);
@@ -869,9 +870,8 @@ static unsigned long tg_within_bps_limit(struct throtl_grp *tg, struct bio *bio, 
	jiffy_elapsed_rnd = roundup(jiffy_elapsed_rnd, tg->td->throtl_slice);

	bytes_allowed = calculate_bytes_allowed(bps_limit, jiffy_elapsed_rnd) +

			tg->carryover_bytes[rw];

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

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

		return 0;

	}



	/* Calc approx time to dispatch */

	extra_bytes = tg->bytes_disp[rw] + bio_size - bytes_allowed;

block/blk-throttle.h

+2 −2
Original line number Diff line number Diff line
@@ -127,8 +127,8 @@ struct throtl_grp { 
	 * bytes/ios are waited already in previous configuration, and they will

	 * be used to calculate wait time under new configuration.

	 */

	uint64_t carryover_bytes[2];

	unsigned int carryover_ios[2];

	long long carryover_bytes[2];

	int carryover_ios[2];



	unsigned long last_check_time;

block/fops.c

+0 −4
Original line number Diff line number Diff line
@@ -671,10 +671,6 @@ static ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from) 
		iov_iter_truncate(from, size);

	}



	ret = file_remove_privs(file);

	if (ret)

		return ret;



	ret = file_update_time(file);

	if (ret)

		return ret;

block/ioctl.c

+2 −0
Original line number Diff line number Diff line
@@ -20,6 +20,8 @@ static int blkpg_do_ioctl(struct block_device *bdev, 
	struct blkpg_partition p;

	long long start, length;



	if (disk->flags & GENHD_FL_NO_PART)

		return -EINVAL;

	if (!capable(CAP_SYS_ADMIN))

		return -EACCES;

	if (copy_from_user(&p, upart, sizeof(struct blkpg_partition)))