ublk: support device recovery without I/O queueing

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

The behavior A + 2 is currently unsupported. Add support for this
behavior under the new flag combination
UBLK_F_USER_RECOVERY|UBLK_F_USER_RECOVERY_FAIL_IO.

Signed-off-by: Uday Shankar <ushankar@purestorage.com>
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Link: https://lore.kernel.org/r/20241007182419.3263186-5-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 0e75283e3bdae0cda9b89bc4f372243e95502053..59951e7c25939f471a777956916fa768d8c46e18 100644 (file)
--- a/drivers/block/ublk_drv.c
+++ b/drivers/block/ublk_drv.c
@@ -60,10 +60,12 @@
                | UBLK_F_UNPRIVILEGED_DEV \
                | UBLK_F_CMD_IOCTL_ENCODE \
                | UBLK_F_USER_COPY \
-               | UBLK_F_ZONED)
+               | UBLK_F_ZONED \
+               | UBLK_F_USER_RECOVERY_FAIL_IO)
 
 #define UBLK_F_ALL_RECOVERY_FLAGS (UBLK_F_USER_RECOVERY \
-               | UBLK_F_USER_RECOVERY_REISSUE)
+               | UBLK_F_USER_RECOVERY_REISSUE \
+               | UBLK_F_USER_RECOVERY_FAIL_IO)
 
 /* All UBLK_PARAM_TYPE_* should be included here */
 #define UBLK_PARAM_TYPE_ALL                                \
@@ -146,6 +148,7 @@ struct ublk_queue {
        bool force_abort;
        bool timeout;
        bool canceling;
+       bool fail_io; /* copy of dev->state == UBLK_S_DEV_FAIL_IO */
        unsigned short nr_io_ready;     /* how many ios setup */
        spinlock_t              cancel_lock;
        struct ublk_device *dev;
@@ -690,7 +693,8 @@ static inline bool ublk_nosrv_should_reissue_outstanding(struct ublk_device *ub)
  */
 static inline bool ublk_nosrv_dev_should_queue_io(struct ublk_device *ub)
 {
-       return ub->dev_info.flags & UBLK_F_USER_RECOVERY;
+       return (ub->dev_info.flags & UBLK_F_USER_RECOVERY) &&
+              !(ub->dev_info.flags & UBLK_F_USER_RECOVERY_FAIL_IO);
 }
 
 /*
@@ -700,7 +704,8 @@ static inline bool ublk_nosrv_dev_should_queue_io(struct ublk_device *ub)
  */
 static inline bool ublk_nosrv_should_queue_io(struct ublk_queue *ubq)
 {
-       return ubq->flags & UBLK_F_USER_RECOVERY;
+       return (ubq->flags & UBLK_F_USER_RECOVERY) &&
+              !(ubq->flags & UBLK_F_USER_RECOVERY_FAIL_IO);
 }
 
 /*
@@ -714,6 +719,12 @@ static inline bool ublk_nosrv_should_stop_dev(struct ublk_device *ub)
        return !(ub->dev_info.flags & UBLK_F_USER_RECOVERY);
 }
 
+static inline bool ublk_dev_in_recoverable_state(struct ublk_device *ub)
+{
+       return ub->dev_info.state == UBLK_S_DEV_QUIESCED ||
+              ub->dev_info.state == UBLK_S_DEV_FAIL_IO;
+}
+
 static void ublk_free_disk(struct gendisk *disk)
 {
        struct ublk_device *ub = disk->private_data;
@@ -1275,6 +1286,10 @@ static blk_status_t ublk_queue_rq(struct blk_mq_hw_ctx *hctx,
        struct request *rq = bd->rq;
        blk_status_t res;
 
+       if (unlikely(ubq->fail_io)) {
+               return BLK_STS_TARGET;
+       }
+
        /* fill iod to slot in io cmd buffer */
        res = ublk_setup_iod(ubq, rq);
        if (unlikely(res != BLK_STS_OK))
@@ -1625,6 +1640,7 @@ static void ublk_nosrv_work(struct work_struct *work)
 {
        struct ublk_device *ub =
                container_of(work, struct ublk_device, nosrv_work);
+       int i;
 
        if (ublk_nosrv_should_stop_dev(ub)) {
                ublk_stop_dev(ub);
@@ -1634,7 +1650,18 @@ static void ublk_nosrv_work(struct work_struct *work)
        mutex_lock(&ub->mutex);
        if (ub->dev_info.state != UBLK_S_DEV_LIVE)
                goto unlock;
-       __ublk_quiesce_dev(ub);
+
+       if (ublk_nosrv_dev_should_queue_io(ub)) {
+               __ublk_quiesce_dev(ub);
+       } else {
+               blk_mq_quiesce_queue(ub->ub_disk->queue);
+               ub->dev_info.state = UBLK_S_DEV_FAIL_IO;
+               for (i = 0; i < ub->dev_info.nr_hw_queues; i++) {
+                       ublk_get_queue(ub, i)->fail_io = true;
+               }
+               blk_mq_unquiesce_queue(ub->ub_disk->queue);
+       }
+
  unlock:
        mutex_unlock(&ub->mutex);
        ublk_cancel_dev(ub);
@@ -2387,8 +2414,13 @@ static int ublk_ctrl_add_dev(struct io_uring_cmd *cmd)
                return -EPERM;
 
        /* forbid nonsense combinations of recovery flags */
-       if ((info.flags & UBLK_F_USER_RECOVERY_REISSUE) &&
-           !(info.flags & UBLK_F_USER_RECOVERY)) {
+       switch (info.flags & UBLK_F_ALL_RECOVERY_FLAGS) {
+       case 0:
+       case UBLK_F_USER_RECOVERY:
+       case (UBLK_F_USER_RECOVERY | UBLK_F_USER_RECOVERY_REISSUE):
+       case (UBLK_F_USER_RECOVERY | UBLK_F_USER_RECOVERY_FAIL_IO):
+               break;
+       default:
                pr_warn("%s: invalid recovery flags %llx\n", __func__,
                        info.flags & UBLK_F_ALL_RECOVERY_FLAGS);
                return -EINVAL;
@@ -2729,14 +2761,18 @@ static int ublk_ctrl_start_recovery(struct ublk_device *ub,
         *     and related io_uring ctx is freed so file struct of /dev/ublkcX is
         *     released.
         *
+        * and one of the following holds
+        *
         * (2) UBLK_S_DEV_QUIESCED is set, which means the quiesce_work:
         *     (a)has quiesced request queue
         *     (b)has requeued every inflight rqs whose io_flags is ACTIVE
         *     (c)has requeued/aborted every inflight rqs whose io_flags is NOT ACTIVE
         *     (d)has completed/camceled all ioucmds owned by ther dying process
+        *
+        * (3) UBLK_S_DEV_FAIL_IO is set, which means the queue is not
+        *     quiesced, but all I/O is being immediately errored
         */
-       if (test_bit(UB_STATE_OPEN, &ub->state) ||
-                       ub->dev_info.state != UBLK_S_DEV_QUIESCED) {
+       if (test_bit(UB_STATE_OPEN, &ub->state) || !ublk_dev_in_recoverable_state(ub)) {
                ret = -EBUSY;
                goto out_unlock;
        }
@@ -2760,6 +2796,7 @@ static int ublk_ctrl_end_recovery(struct ublk_device *ub,
        const struct ublksrv_ctrl_cmd *header = io_uring_sqe_cmd(cmd->sqe);
        int ublksrv_pid = (int)header->data[0];
        int ret = -EINVAL;
+       int i;
 
        pr_devel("%s: Waiting for new ubq_daemons(nr: %d) are ready, dev id %d...\n",
                        __func__, ub->dev_info.nr_hw_queues, header->dev_id);
@@ -2774,18 +2811,29 @@ static int ublk_ctrl_end_recovery(struct ublk_device *ub,
        if (ublk_nosrv_should_stop_dev(ub))
                goto out_unlock;
 
-       if (ub->dev_info.state != UBLK_S_DEV_QUIESCED) {
+       if (!ublk_dev_in_recoverable_state(ub)) {
                ret = -EBUSY;
                goto out_unlock;
        }
        ub->dev_info.ublksrv_pid = ublksrv_pid;
        pr_devel("%s: new ublksrv_pid %d, dev id %d\n",
                        __func__, ublksrv_pid, header->dev_id);
-       blk_mq_unquiesce_queue(ub->ub_disk->queue);
-       pr_devel("%s: queue unquiesced, dev id %d.\n",
-                       __func__, header->dev_id);
-       blk_mq_kick_requeue_list(ub->ub_disk->queue);
-       ub->dev_info.state = UBLK_S_DEV_LIVE;
+
+       if (ublk_nosrv_dev_should_queue_io(ub)) {
+               ub->dev_info.state = UBLK_S_DEV_LIVE;
+               blk_mq_unquiesce_queue(ub->ub_disk->queue);
+               pr_devel("%s: queue unquiesced, dev id %d.\n",
+                               __func__, header->dev_id);
+               blk_mq_kick_requeue_list(ub->ub_disk->queue);
+       } else {
+               blk_mq_quiesce_queue(ub->ub_disk->queue);
+               ub->dev_info.state = UBLK_S_DEV_LIVE;
+               for (i = 0; i < ub->dev_info.nr_hw_queues; i++) {
+                       ublk_get_queue(ub, i)->fail_io = false;
+               }
+               blk_mq_unquiesce_queue(ub->ub_disk->queue);
+       }
+
        ret = 0;
  out_unlock:
        mutex_unlock(&ub->mutex);

diff --git a/include/uapi/linux/ublk_cmd.h b/include/uapi/linux/ublk_cmd.h
index 12873639ea9644ea7264e5577c672dae54643489..a8bc98bb69fce395e88986c5e013b1934830795e 100644 (file)
--- a/include/uapi/linux/ublk_cmd.h
+++ b/include/uapi/linux/ublk_cmd.h
@@ -147,8 +147,18 @@
  */
 #define UBLK_F_NEED_GET_DATA (1UL << 2)
 
+/*
+ * - Block devices are recoverable if ublk server exits and restarts
+ * - Outstanding I/O when ublk server exits is met with errors
+ * - I/O issued while there is no ublk server queues
+ */
 #define UBLK_F_USER_RECOVERY   (1UL << 3)
 
+/*
+ * - Block devices are recoverable if ublk server exits and restarts
+ * - Outstanding I/O when ublk server exits is reissued
+ * - I/O issued while there is no ublk server queues
+ */
 #define UBLK_F_USER_RECOVERY_REISSUE   (1UL << 4)
 
 /*
@@ -190,10 +200,18 @@
  */
 #define UBLK_F_ZONED (1ULL << 8)
 
+/*
+ * - Block devices are recoverable if ublk server exits and restarts
+ * - Outstanding I/O when ublk server exits is met with errors
+ * - I/O issued while there is no ublk server is met with errors
+ */
+#define UBLK_F_USER_RECOVERY_FAIL_IO (1ULL << 9)
+
 /* device state */
 #define UBLK_S_DEV_DEAD        0
 #define UBLK_S_DEV_LIVE        1
 #define UBLK_S_DEV_QUIESCED    2
+#define UBLK_S_DEV_FAIL_IO     3
 
 /* shipped via sqe->cmd of io_uring command */
 struct ublksrv_ctrl_cmd {