QEMU is to pause the VM when dm-qcow2 holds a failed request, but it
cannot use dm_table_event(): waiting for dm events needs dm ioctls
and CAP_SYS_ADMIN, which QEMU does not have. libvirt already passes
QEMU a NETLINK_KOBJECT_UEVENT socket to watch the vhost-blk disk for
RESIZE=1 change events.

Send a change uevent on the dm disk with

  IO_ERROR=1
  IO_ERROR_OP=read|write
  IO_ERROR_ERRNO=<positive errno>

when the held list turns non-empty. A periodic retry that fails
again repopulates the list, so the event is repeated while the error
persists and a lost netlink message is not fatal. Only ENOSPC writes
and flushes are held for now; the op and errno are reported so that
other held errors need no new interface. A flush is reported as a
write, as QEMU does.

The event carries no DM_COOKIE, so udev handles it as a spurious
change and probes the disk, as it does after a close or a resize. A
cookie with the flags that disable the disk rules would avoid the probe
but makes 13-dm-disk.rules drop the by-id and by-uuid links, and the
flags stay in the udev database after the error is gone. The probe
only reads, and reads are not held.

get_event keeps reporting a held ENOSPC as "event_ENOSPC", which
dm-ploop answers too, and reports other held errors as
"event_io_error <op> <errno>".

https://virtuozzo.atlassian.net/browse/VSTOR-152175
Feature: dm-qcow2: block device over QCOW2 files driver
Signed-off-by: Alexander Ivanov <[email protected]>
---
 drivers/md/dm-qcow2-cmd.c    | 11 ++++++++---
 drivers/md/dm-qcow2-map.c    |  8 +++++++-
 drivers/md/dm-qcow2-target.c | 28 ++++++++++++++++++++++++++++
 drivers/md/dm-qcow2.h        |  5 ++++-
 4 files changed, 47 insertions(+), 5 deletions(-)

diff --git a/drivers/md/dm-qcow2-cmd.c b/drivers/md/dm-qcow2-cmd.c
index 3bccce090f01..7af3ac154127 100644
--- a/drivers/md/dm-qcow2-cmd.c
+++ b/drivers/md/dm-qcow2-cmd.c
@@ -584,10 +584,15 @@ static int qcow2_get_event(struct qcow2_target *tgt, char 
*result, unsigned int
        int ret = 0;
 
        spin_lock_irq(&tgt->event_lock);
-       if (tgt->event_enospc) {
-               ret = (DMEMIT("event_ENOSPC\n")) ? 1 : 0;
+       if (tgt->event_io_error) {
+               if (tgt->event_errno == ENOSPC)
+                       ret = (DMEMIT("event_ENOSPC\n")) ? 1 : 0;
+               else
+                       ret = (DMEMIT("event_io_error %s %d\n",
+                                     tgt->event_write ? "write" : "read",
+                                     tgt->event_errno)) ? 1 : 0;
                if (ret)
-                       tgt->event_enospc = false;
+                       tgt->event_io_error = false;
        }
        spin_unlock_irq(&tgt->event_lock);
 
diff --git a/drivers/md/dm-qcow2-map.c b/drivers/md/dm-qcow2-map.c
index d6f8bcd98a39..2a663eb652f4 100644
--- a/drivers/md/dm-qcow2-map.c
+++ b/drivers/md/dm-qcow2-map.c
@@ -4569,6 +4569,7 @@ void do_qcow2_fsync_work(struct work_struct *ws)
 static bool qcow2_try_hold_error(struct qcow2_target *tgt, struct qcow2_rq 
*qrq,
                                 struct qio *qio, blk_status_t bi_status)
 {
+       bool write = op_is_write(qio->bi_op) || qio->bi_op == REQ_OP_FLUSH;
        bool held = true, first = false;
        unsigned long flags;
 
@@ -4585,8 +4586,13 @@ static bool qcow2_try_hold_error(struct qcow2_target 
*tgt, struct qcow2_rq *qrq,
 
        pr_err_once(QCOW2_FMT("underlying disk is almost full"),
                        qcow2_device_name(tgt->ti));
-       tgt->event_enospc = true;
+       tgt->event_io_error = true;
        first = list_empty(&tgt->held_qios);
+       if (first) {
+               tgt->event_uevent = true;
+               tgt->event_write = write;
+               tgt->event_errno = -blk_status_to_errno(bi_status);
+       }
        list_add_tail(&qio->link, &tgt->held_qios);
 unlock:
        spin_unlock_irqrestore(&tgt->event_lock, flags);
diff --git a/drivers/md/dm-qcow2-target.c b/drivers/md/dm-qcow2-target.c
index 89b12c4f971b..2a57f66fe25d 100644
--- a/drivers/md/dm-qcow2-target.c
+++ b/drivers/md/dm-qcow2-target.c
@@ -8,6 +8,7 @@
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/error-injection.h>
+#include <linux/sched/mm.h>
 
 #include "dm.h"
 #include "dm-qcow2.h"
@@ -493,11 +494,38 @@ static void qcow2_held_timer(struct timer_list *timer)
        qcow2_submit_embedded_qios(tgt, &list);
 }
 
+static void qcow2_send_io_error_uevent(struct qcow2_target *tgt,
+                                      bool write, int err)
+{
+       struct mapped_device *md = dm_table_get_md(tgt->ti->table);
+       char op[24], errno_env[24];
+       char *envp[] = { "IO_ERROR=1", op, errno_env, NULL };
+       unsigned int noio_flag;
+
+       snprintf(op, sizeof(op), "IO_ERROR_OP=%s", write ? "write" : "read");
+       snprintf(errno_env, sizeof(errno_env), "IO_ERROR_ERRNO=%d", err);
+
+       noio_flag = memalloc_noio_save();
+       kobject_uevent_env(&disk_to_dev(dm_disk(md))->kobj, KOBJ_CHANGE, envp);
+       memalloc_noio_restore(noio_flag);
+}
+
 static void qcow2_event_work(struct work_struct *ws)
 {
        struct qcow2_target *tgt = container_of(ws, struct qcow2_target, 
event_work);
+       bool uevent, write;
+       int err;
+
+       spin_lock_irq(&tgt->event_lock);
+       uevent = tgt->event_uevent;
+       tgt->event_uevent = false;
+       write = tgt->event_write;
+       err = tgt->event_errno;
+       spin_unlock_irq(&tgt->event_lock);
 
        dm_table_event(tgt->ti->table);
+       if (uevent)
+               qcow2_send_io_error_uevent(tgt, write, err);
 }
 
 static struct qcow2_target *alloc_qcow2_target(struct dm_target *ti)
diff --git a/drivers/md/dm-qcow2.h b/drivers/md/dm-qcow2.h
index ea6bc6258cb0..03233090da23 100644
--- a/drivers/md/dm-qcow2.h
+++ b/drivers/md/dm-qcow2.h
@@ -208,7 +208,10 @@ struct qcow2_target {
        bool wants_suspend;
        bool md_writeback_error;
        bool truncate_error;
-       bool event_enospc;
+       bool event_io_error;
+       bool event_uevent;
+       bool event_write;
+       int event_errno;
 
        atomic_t service_qios;
        struct wait_queue_head service_wq;
-- 
2.53.0

_______________________________________________
Devel mailing list
[email protected]
https://lists.openvz.org/mailman/listinfo/devel

Reply via email to