Commit 297cbccc authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-linus-20191010' of git://git.kernel.dk/linux-block 

Pull block fixes from Jens Axboe:

 - Fix wbt performance regression introduced with the blk-rq-qos
   refactoring (Harshad)

 - Fix io_uring fileset removal inadvertently killing the workqueue (me)

 - Fix io_uring typo in linked command nonblock submission (Pavel)

 - Remove spurious io_uring wakeups on request free (Pavel)

 - Fix null_blk zoned command error return (Keith)

 - Don't use freezable workqueues for backing_dev, also means we can
   revert a previous libata hack (Mika)

 - Fix nbd sysfs mutex dropped too soon at removal time (Xiubo)

* tag 'for-linus-20191010' of git://git.kernel.dk/linux-block:
  nbd: fix possible sysfs duplicate warning
  null_blk: Fix zoned command return code
  io_uring: only flush workqueues on fileset removal
  io_uring: remove wait loop spurious wakeups
  blk-wbt: fix performance regression in wbt scale_up/scale_down
  Revert "libata, freezer: avoid block device removal while system is frozen"
  bdi: Do not use freezable workqueue
  io_uring: fix reversed nonblock flag for link submission
parents 9e208aa0 86248810

block/blk-rq-qos.c

+9 −5
Original line number Diff line number Diff line
@@ -160,24 +160,27 @@ bool rq_depth_calc_max_depth(struct rq_depth *rqd) 
	return ret;

}



void rq_depth_scale_up(struct rq_depth *rqd)

/* Returns true on success and false if scaling up wasn't possible */

bool rq_depth_scale_up(struct rq_depth *rqd)

{

	/*

	 * Hit max in previous round, stop here

	 */

	if (rqd->scaled_max)

		return;

		return false;



	rqd->scale_step--;



	rqd->scaled_max = rq_depth_calc_max_depth(rqd);

	return true;

}



/*

 * Scale rwb down. If 'hard_throttle' is set, do it quicker, since we

 * had a latency violation.

 * had a latency violation. Returns true on success and returns false if

 * scaling down wasn't possible.

 */

void rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle)

bool rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle)

{

	/*

	 * Stop scaling down when we've hit the limit. This also prevents
@@ -185,7 +188,7 @@ void rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle) 
	 * keep up.

	 */

	if (rqd->max_depth == 1)

		return;

		return false;



	if (rqd->scale_step < 0 && hard_throttle)

		rqd->scale_step = 0;
@@ -194,6 +197,7 @@ void rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle) 


	rqd->scaled_max = false;

	rq_depth_calc_max_depth(rqd);

	return true;

}



struct rq_qos_wait_data {

block/blk-rq-qos.h

+2 −2
Original line number Diff line number Diff line
@@ -130,8 +130,8 @@ void rq_qos_wait(struct rq_wait *rqw, void *private_data, 
		 acquire_inflight_cb_t *acquire_inflight_cb,

		 cleanup_cb_t *cleanup_cb);

bool rq_wait_inc_below(struct rq_wait *rq_wait, unsigned int limit);

void rq_depth_scale_up(struct rq_depth *rqd);

void rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle);

bool rq_depth_scale_up(struct rq_depth *rqd);

bool rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle);

bool rq_depth_calc_max_depth(struct rq_depth *rqd);



void __rq_qos_cleanup(struct rq_qos *rqos, struct bio *bio);

block/blk-wbt.c

+4 −2
Original line number Diff line number Diff line
@@ -308,7 +308,8 @@ static void calc_wb_limits(struct rq_wb *rwb) 


static void scale_up(struct rq_wb *rwb)

{

	rq_depth_scale_up(&rwb->rq_depth);

	if (!rq_depth_scale_up(&rwb->rq_depth))

		return;

	calc_wb_limits(rwb);

	rwb->unknown_cnt = 0;

	rwb_wake_all(rwb);
@@ -317,7 +318,8 @@ static void scale_up(struct rq_wb *rwb) 


static void scale_down(struct rq_wb *rwb, bool hard_throttle)

{

	rq_depth_scale_down(&rwb->rq_depth, hard_throttle);

	if (!rq_depth_scale_down(&rwb->rq_depth, hard_throttle))

		return;

	calc_wb_limits(rwb);

	rwb->unknown_cnt = 0;

	rwb_trace_step(rwb, "scale down");

drivers/ata/libata-scsi.c

+0 −21
Original line number Diff line number Diff line
@@ -4791,27 +4791,6 @@ void ata_scsi_hotplug(struct work_struct *work) 
		return;

	}



	/*

	 * XXX - UGLY HACK

	 *

	 * The block layer suspend/resume path is fundamentally broken due

	 * to freezable kthreads and workqueue and may deadlock if a block

	 * device gets removed while resume is in progress.  I don't know

	 * what the solution is short of removing freezable kthreads and

	 * workqueues altogether.

	 *

	 * The following is an ugly hack to avoid kicking off device

	 * removal while freezer is active.  This is a joke but does avoid

	 * this particular deadlock scenario.

	 *

	 * https://bugzilla.kernel.org/show_bug.cgi?id=62801

	 * http://marc.info/?l=linux-kernel&m=138695698516487

	 */

#ifdef CONFIG_FREEZER

	while (pm_freezing)

		msleep(10);

#endif



	DPRINTK("ENTER\n");

	mutex_lock(&ap->scsi_scan_mutex);

drivers/block/nbd.c

+1 −1
Original line number Diff line number Diff line
@@ -248,8 +248,8 @@ static void nbd_put(struct nbd_device *nbd) 
	if (refcount_dec_and_mutex_lock(&nbd->refs,

					&nbd_index_mutex)) {

		idr_remove(&nbd_index_idr, nbd->index);

		mutex_unlock(&nbd_index_mutex);

		nbd_dev_remove(nbd);

		mutex_unlock(&nbd_index_mutex);

	}

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE