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: Uday Shankar <ushankar@purestorage.com>
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Link: https://lore.kernel.org/r/20241007182419.3263186-3-ushankar@purestorage.com
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c
index 2fc47aea54d18f2e5e2962fd0594412ec0cf9384..50eb608b98a40b99b0a10cf59d8b76052e7bac8a 100644 (file)
--- a/drivers/block/ublk_drv.c
+++ b/drivers/block/ublk_drv.c
@@ -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) {