Commit 3b939b8f authored by Uday Shankar's avatar Uday Shankar Committed by Jens Axboe
Browse files

ublk: refactor recovery configuration flag helpers 



ublk currently supports the following behaviors on ublk server exit:

A: outstanding I/Os get errors, subsequently issued I/Os get errors
B: outstanding I/Os get errors, subsequently issued I/Os queue
C: outstanding I/Os get reissued, subsequently issued I/Os queue

and the following behaviors for recovery of preexisting block devices by
a future incarnation of the ublk server:

1: ublk devices stopped on ublk server exit (no recovery possible)
2: ublk devices are recoverable using start/end_recovery commands

The userspace interface allows selection of combinations of these
behaviors using flags specified at device creation time, namely:

default behavior: A + 1
UBLK_F_USER_RECOVERY: B + 2
UBLK_F_USER_RECOVERY|UBLK_F_USER_RECOVERY_REISSUE: C + 2

We can't easily change the userspace interface to allow independent
selection of one of {A, B, C} and one of {1, 2}, but we can refactor the
internal helpers which test for the flags. Replace the existing helpers
with the following set:

ublk_nosrv_should_reissue_outstanding: tests for behavior C
ublk_nosrv_[dev_]should_queue_io: tests for behavior B
ublk_nosrv_should_stop_dev: tests for behavior 1

Signed-off-by: default avatarUday Shankar <ushankar@purestorage.com>
Reviewed-by: default avatarMing Lei <ming.lei@redhat.com>
Link: https://lore.kernel.org/r/20241007182419.3263186-3-ushankar@purestorage.com


Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent d00c0ea1

drivers/block/ublk_drv.c

+42 −20
Original line number Diff line number Diff line
@@ -675,22 +675,44 @@ static inline int ublk_queue_cmd_buf_size(struct ublk_device *ub, int q_id) 
			PAGE_SIZE);

}



static inline bool ublk_queue_can_use_recovery_reissue(

		struct ublk_queue *ubq)

/*

 * Should I/O outstanding to the ublk server when it exits be reissued?

 * If not, outstanding I/O will get errors.

 */

static inline bool ublk_nosrv_should_reissue_outstanding(struct ublk_device *ub)

{

	return (ubq->flags & UBLK_F_USER_RECOVERY) &&

			(ubq->flags & UBLK_F_USER_RECOVERY_REISSUE);

	return (ub->dev_info.flags & UBLK_F_USER_RECOVERY) &&

	       (ub->dev_info.flags & UBLK_F_USER_RECOVERY_REISSUE);

}



static inline bool ublk_queue_can_use_recovery(

		struct ublk_queue *ubq)

/*

 * Should I/O issued while there is no ublk server queue? If not, I/O

 * issued while there is no ublk server will get errors.

 */

static inline bool ublk_nosrv_dev_should_queue_io(struct ublk_device *ub)

{

	return ub->dev_info.flags & UBLK_F_USER_RECOVERY;

}



/*

 * Same as ublk_nosrv_dev_should_queue_io, but uses a queue-local copy

 * of the device flags for smaller cache footprint - better for fast

 * paths.

 */

static inline bool ublk_nosrv_should_queue_io(struct ublk_queue *ubq)

{

	return ubq->flags & UBLK_F_USER_RECOVERY;

}



static inline bool ublk_can_use_recovery(struct ublk_device *ub)

/*

 * Should ublk devices be stopped (i.e. no recovery possible) when the

 * ublk server exits? If not, devices can be used again by a future

 * incarnation of a ublk server via the start_recovery/end_recovery

 * commands.

 */

static inline bool ublk_nosrv_should_stop_dev(struct ublk_device *ub)

{

	return ub->dev_info.flags & UBLK_F_USER_RECOVERY;

	return !(ub->dev_info.flags & UBLK_F_USER_RECOVERY);

}



static void ublk_free_disk(struct gendisk *disk)
@@ -1066,7 +1088,7 @@ static void __ublk_fail_req(struct ublk_queue *ubq, struct ublk_io *io, 
{

	WARN_ON_ONCE(io->flags & UBLK_IO_FLAG_ACTIVE);



	if (ublk_queue_can_use_recovery_reissue(ubq))

	if (ublk_nosrv_should_reissue_outstanding(ubq->dev))

		blk_mq_requeue_request(req, false);

	else

		ublk_put_req_ref(ubq, req);
@@ -1094,7 +1116,7 @@ static inline void __ublk_abort_rq(struct ublk_queue *ubq, 
		struct request *rq)

{

	/* We cannot process this rq so just requeue it. */

	if (ublk_queue_can_use_recovery(ubq))

	if (ublk_nosrv_dev_should_queue_io(ubq->dev))

		blk_mq_requeue_request(rq, false);

	else

		blk_mq_end_request(rq, BLK_STS_IOERR);
@@ -1239,10 +1261,10 @@ static enum blk_eh_timer_return ublk_timeout(struct request *rq) 
		struct ublk_device *ub = ubq->dev;



		if (ublk_abort_requests(ub, ubq)) {

			if (ublk_can_use_recovery(ub))

				schedule_work(&ub->quiesce_work);

			else

			if (ublk_nosrv_should_stop_dev(ub))

				schedule_work(&ub->stop_work);

			else

				schedule_work(&ub->quiesce_work);

		}

		return BLK_EH_DONE;

	}
@@ -1271,7 +1293,7 @@ static blk_status_t ublk_queue_rq(struct blk_mq_hw_ctx *hctx, 
	 * Note: force_abort is guaranteed to be seen because it is set

	 * before request queue is unqiuesced.

	 */

	if (ublk_queue_can_use_recovery(ubq) && unlikely(ubq->force_abort))

	if (ublk_nosrv_should_queue_io(ubq) && unlikely(ubq->force_abort))

		return BLK_STS_IOERR;



	if (unlikely(ubq->canceling)) {
@@ -1492,10 +1514,10 @@ static void ublk_uring_cmd_cancel_fn(struct io_uring_cmd *cmd, 
	ublk_cancel_cmd(ubq, io, issue_flags);



	if (need_schedule) {

		if (ublk_can_use_recovery(ub))

			schedule_work(&ub->quiesce_work);

		else

		if (ublk_nosrv_should_stop_dev(ub))

			schedule_work(&ub->stop_work);

		else

			schedule_work(&ub->quiesce_work);

	}

}
@@ -1600,7 +1622,7 @@ static void ublk_stop_dev(struct ublk_device *ub) 
	mutex_lock(&ub->mutex);

	if (ub->dev_info.state == UBLK_S_DEV_DEAD)

		goto unlock;

	if (ublk_can_use_recovery(ub)) {

	if (ublk_nosrv_dev_should_queue_io(ub)) {

		if (ub->dev_info.state == UBLK_S_DEV_LIVE)

			__ublk_quiesce_dev(ub);

		ublk_unquiesce_dev(ub);
@@ -2710,7 +2732,7 @@ static int ublk_ctrl_start_recovery(struct ublk_device *ub, 
	int i;



	mutex_lock(&ub->mutex);

	if (!ublk_can_use_recovery(ub))

	if (ublk_nosrv_should_stop_dev(ub))

		goto out_unlock;

	if (!ub->nr_queues_ready)

		goto out_unlock;
@@ -2763,7 +2785,7 @@ static int ublk_ctrl_end_recovery(struct ublk_device *ub, 
			__func__, ub->dev_info.nr_hw_queues, header->dev_id);



	mutex_lock(&ub->mutex);

	if (!ublk_can_use_recovery(ub))

	if (ublk_nosrv_should_stop_dev(ub))

		goto out_unlock;



	if (ub->dev_info.state != UBLK_S_DEV_QUIESCED) {