[Qemu-devel] [PATCH 1/6] block: Keep track of devices' I/O status

[Luiz Capitulino]

This commit adds support to the BlockDriverState type to keep track
of the devices' I/O status.

There are three possible status: BDRV_IOS_OK (no error so far),
BDRV_IOS_ENOSPC (no space error) and BDRV_IOS_FAILED (any other error).
The distinction between no space and other errors is important because
a management application may want to watch for no space in order to
extend the host's underline device and put the VM to run again.

Qemu devices supporting the I/O status feature have to enable it
explicitly by calling bdrv_iostatus_enable() _and_ have to be
configured to stop the VM on errors (ie. werror=stop|enospc or
rerror=stop).

In case of multiple errors being triggered in sequence only the first
one is stored. The I/O status is set back to BDRV_IOS_OK when the
'cont' command is issued.

Next commits will add support to some devices and extend the
query-block/info block commands with the I/O status information.

Signed-off-by: Luiz Capitulino <address@hidden>
---
 block.c     |   32 ++++++++++++++++++++++++++++++++
 block.h     |    9 +++++++++
 block_int.h |    1 +
 monitor.c   |    6 ++++++
 4 files changed, 48 insertions(+), 0 deletions(-)

diff --git a/block.c b/block.c
index 03a21d8..c54caf2 100644
--- a/block.c
+++ b/block.c
@@ -220,6 +220,7 @@ BlockDriverState *bdrv_new(const char *device_name)
     if (device_name[0] != '\0') {
         QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
     }
+    bs->iostatus = BDRV_IOS_INVAL;
     return bs;
 }
 
@@ -3165,6 +3166,37 @@ int bdrv_in_use(BlockDriverState *bs)
     return bs->in_use;
 }
 
+void bdrv_iostatus_enable(BlockDriverState *bs)
+{
+    assert(bs->iostatus == BDRV_IOS_INVAL);
+    bs->iostatus = BDRV_IOS_OK;
+}
+
+/* The I/O status is only enabled if the drive explicitly
+ * enables it _and_ the VM is configured to stop on errors */
+bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
+{
+    return (bs->iostatus != BDRV_IOS_INVAL &&
+           (bs->on_write_error == BLOCK_ERR_STOP_ENOSPC ||
+            bs->on_write_error == BLOCK_ERR_STOP_ANY    ||
+            bs->on_read_error == BLOCK_ERR_STOP_ANY));
+}
+
+void bdrv_iostatus_reset(BlockDriverState *bs)
+{
+    if (bdrv_iostatus_is_enabled(bs)) {
+        bs->iostatus = BDRV_IOS_OK;
+    }
+}
+
+void bdrv_iostatus_update(BlockDriverState *bs, int error)
+{
+    if (bdrv_iostatus_is_enabled(bs) && bs->iostatus == BDRV_IOS_OK) {
+        bs->iostatus = (abs(error) == ENOSPC) ? BDRV_IOS_ENOSPC :
+                                                BDRV_IOS_FAILED;
+    }
+}
+
 void
 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
         enum BlockAcctType type)
diff --git a/block.h b/block.h
index 3ac0b94..24914e0 100644
--- a/block.h
+++ b/block.h
@@ -51,6 +51,15 @@ typedef enum {
     BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
 } BlockMonEventAction;
 
+typedef enum {
+    BDRV_IOS_INVAL, BDRV_IOS_OK, BDRV_IOS_FAILED, BDRV_IOS_ENOSPC,
+    BDRV_IOS_MAX
+} BlockIOStatus;
+
+void bdrv_iostatus_enable(BlockDriverState *bs);
+void bdrv_iostatus_reset(BlockDriverState *bs);
+bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
+void bdrv_iostatus_update(BlockDriverState *bs, int error);
 void bdrv_mon_event(const BlockDriverState *bdrv,
                     BlockMonEventAction action, int is_read);
 void bdrv_info_print(Monitor *mon, const QObject *data);
diff --git a/block_int.h b/block_int.h
index 8a72b80..600801d 100644
--- a/block_int.h
+++ b/block_int.h
@@ -203,6 +203,7 @@ struct BlockDriverState {
        drivers. They are not used by the block driver */
     int cyls, heads, secs, translation;
     BlockErrorAction on_read_error, on_write_error;
+    BlockIOStatus iostatus;
     char device_name[32];
     unsigned long *dirty_bitmap;
     int64_t dirty_count;
diff --git a/monitor.c b/monitor.c
index 9807005..69f1b3c 100644
--- a/monitor.c
+++ b/monitor.c
@@ -1302,6 +1302,11 @@ struct bdrv_iterate_context {
     int err;
 };
 
+static void iostatus_bdrv_it(void *opaque, BlockDriverState *bs)
+{
+    bdrv_iostatus_reset(bs);
+}
+
 /**
  * do_cont(): Resume emulation.
  */
@@ -1318,6 +1323,7 @@ static int do_cont(Monitor *mon, const QDict *qdict, 
QObject **ret_data)
         return -1;
     }
 
+    bdrv_iterate(iostatus_bdrv_it, NULL);
     bdrv_iterate(encrypted_bdrv_it, &context);
     /* only resume the vm if all keys are set and valid */
     if (!context.err) {
-- 
1.7.7.rc0.72.g4b5ea