]> git.ipfire.org Git - thirdparty/libvirt.git/commitdiff
Add support for an explicit IO error event
authorDaniel P. Berrange <berrange@redhat.com>
Thu, 18 Mar 2010 19:37:44 +0000 (19:37 +0000)
committerDaniel P. Berrange <berrange@redhat.com>
Fri, 26 Mar 2010 13:53:11 +0000 (13:53 +0000)
This introduces a new event type

   VIR_DOMAIN_EVENT_ID_IO_ERROR

This event includes the action that is about to be taken
as a result of the watchdog triggering

  typedef enum {
     VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0,
     VIR_DOMAIN_EVENT_IO_ERROR_PAUSE,
     VIR_DOMAIN_EVENT_IO_ERROR_REPORT,
  } virDomainEventIOErrorAction;

In addition it has the source path of the disk that had the
error and its unique device alias. It does not include the
target device name (/dev/sda), since this would preclude
triggering IO errors from other file backed devices (eg
serial ports connected to a file)

Thus there is a new callback definition for this event type

typedef void (*virConnectDomainEventIOErrorCallback)(virConnectPtr conn,
                                                     virDomainPtr dom,
                                                     const char *srcPath,
                                                     const char *devAlias,
                                                     int action,
                                                     void *opaque);

This is currently wired up to the QEMU block IO error events

* daemon/remote.c: Dispatch IO error events to client
* examples/domain-events/events-c/event-test.c: Watch for
  IO error events
* include/libvirt/libvirt.h.in: Define new IO error event ID
  and callback signature
* src/conf/domain_event.c, src/conf/domain_event.h,
  src/libvirt_private.syms: Extend API to handle IO error events
* src/qemu/qemu_driver.c: Connect to the QEMU monitor event
  for block IO errors and emit a libvirt IO error event
* src/remote/remote_driver.c: Receive and dispatch IO error
  events to application
* src/remote/remote_protocol.x: Wire protocol definition for
  IO error events
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
  src/qemu/qemu_monitor_json.c: Watch for BLOCK_IO_ERROR event
  from QEMU monitor

16 files changed:
daemon/remote.c
daemon/remote_dispatch_table.h
examples/domain-events/events-c/event-test.c
include/libvirt/libvirt.h.in
python/generator.py
src/conf/domain_event.c
src/conf/domain_event.h
src/libvirt_private.syms
src/qemu/qemu_driver.c
src/qemu/qemu_monitor.c
src/qemu/qemu_monitor.h
src/qemu/qemu_monitor_json.c
src/remote/remote_driver.c
src/remote/remote_protocol.c
src/remote/remote_protocol.h
src/remote/remote_protocol.x

index 4bc7a45fc6e401f95e2385d8d34f1b76d23ec85a..885e9d4bf52f856daec073e69b9b8a1b9edfa7bd 100644 (file)
@@ -217,11 +217,46 @@ static int remoteRelayDomainEventWatchdog(virConnectPtr conn ATTRIBUTE_UNUSED,
 }
 
 
+static int remoteRelayDomainEventIOError(virConnectPtr conn ATTRIBUTE_UNUSED,
+                                         virDomainPtr dom,
+                                         const char *srcPath,
+                                         const char *devAlias,
+                                         int action,
+                                         void *opaque)
+{
+    struct qemud_client *client = opaque;
+    remote_domain_event_io_error_msg data;
+
+    if (!client)
+        return -1;
+
+    REMOTE_DEBUG("Relaying domain io error %s %d %s %s %d", dom->name, dom->id, srcPath, devAlias, action);
+
+    virMutexLock(&client->lock);
+
+    /* build return data */
+    memset(&data, 0, sizeof data);
+    make_nonnull_domain (&data.dom, dom);
+    data.srcPath = (char*)srcPath;
+    data.devAlias = (char*)devAlias;
+    data.action = action;
+
+    remoteDispatchDomainEventSend (client,
+                                   REMOTE_PROC_DOMAIN_EVENT_IO_ERROR,
+                                   (xdrproc_t)xdr_remote_domain_event_io_error_msg, &data);
+
+    virMutexUnlock(&client->lock);
+
+    return 0;
+}
+
+
 static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventLifecycle),
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventReboot),
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventRTCChange),
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventWatchdog),
+    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventIOError),
 };
 
 verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);
index a0a74fe7118388fda953cbfae8ea0f25b4c95410..019212d61cd385a928ae88cf0f49d06375a06be7 100644 (file)
     .args_filter = (xdrproc_t) xdr_void,
     .ret_filter = (xdrproc_t) xdr_void,
 },
+{   /* Async event DomainEventIoError => 172 */
+    .fn = NULL,
+    .args_filter = (xdrproc_t) xdr_void,
+    .ret_filter = (xdrproc_t) xdr_void,
+},
index 997af63e9fd7d1cf1e6a374793ec580b07f58294..bb3c7bbda6b0acaefeddf816d5c3727184f090e5 100644 (file)
@@ -204,6 +204,19 @@ static int myDomainEventWatchdogCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
     return 0;
 }
 
+static int myDomainEventIOErrorCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
+                                        virDomainPtr dom,
+                                        const char *srcPath,
+                                        const char *devAlias,
+                                        int action,
+                                        void *opaque ATTRIBUTE_UNUSED)
+{
+    printf("%s EVENT: Domain %s(%d) io error path=%s alias=%s action=%d\n", __func__, virDomainGetName(dom),
+           virDomainGetID(dom), srcPath, devAlias, action);
+
+    return 0;
+}
+
 static void myFreeFunc(void *opaque)
 {
     char *str = opaque;
@@ -324,6 +337,7 @@ int main(int argc, char **argv)
     int callback3ret = -1;
     int callback4ret = -1;
     int callback5ret = -1;
+    int callback6ret = -1;
 
     struct sigaction action_stop = {
         .sa_handler = stop
@@ -376,12 +390,18 @@ int main(int argc, char **argv)
                                                     VIR_DOMAIN_EVENT_ID_WATCHDOG,
                                                     VIR_DOMAIN_EVENT_CALLBACK(myDomainEventWatchdogCallback),
                                                     strdup("callback watchdog"), myFreeFunc);
+    callback6ret = virConnectDomainEventRegisterAny(dconn,
+                                                    NULL,
+                                                    VIR_DOMAIN_EVENT_ID_IO_ERROR,
+                                                    VIR_DOMAIN_EVENT_CALLBACK(myDomainEventIOErrorCallback),
+                                                    strdup("callback io error"), myFreeFunc);
 
     if ((callback1ret != -1) &&
         (callback2ret != -1) &&
         (callback3ret != -1) &&
         (callback4ret != -1) &&
-        (callback5ret != -1)) {
+        (callback5ret != -1) &&
+        (callback6ret != -1)) {
         while(run) {
             struct pollfd pfd = { .fd = h_fd,
                               .events = h_event,
@@ -422,6 +442,7 @@ int main(int argc, char **argv)
         virConnectDomainEventDeregisterAny(dconn, callback3ret);
         virConnectDomainEventDeregisterAny(dconn, callback4ret);
         virConnectDomainEventDeregisterAny(dconn, callback5ret);
+        virConnectDomainEventDeregisterAny(dconn, callback6ret);
     }
 
     DEBUG0("Closing connection");
index dace68fe3f1dfd029ca3c76f902e423ed4a0d62b..9c9076814774a7a85c26178956af2c3c8a9bd3c7 100644 (file)
@@ -1908,6 +1908,38 @@ typedef void (*virConnectDomainEventWatchdogCallback)(virConnectPtr conn,
                                                       int action,
                                                       void *opaque);
 
+/**
+ * virDomainEventIOErrorAction:
+ *
+ * The action that is to be taken due to an IO error occuring
+ */
+typedef enum {
+    VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0,  /* No action, IO error ignored */
+    VIR_DOMAIN_EVENT_IO_ERROR_PAUSE,     /* Guest CPUs are pausde */
+    VIR_DOMAIN_EVENT_IO_ERROR_REPORT,    /* IO error reported to guest OS */
+} virDomainEventIOErrorAction;
+
+
+/**
+ * virConnectDomainEventWatchdogCallback:
+ * @conn: connection object
+ * @dom: domain on which the event occurred
+ * @srcPath: The host file on which the IO error occurred
+ * @devAlias: The guest device alias associated with the path
+ * @action: action that is to be taken due to the IO error
+ * @opaque: application specified data
+ *
+ * The callback signature to use when registering for an event of type
+ * VIR_DOMAIN_EVENT_ID_IO_ERROR with virConnectDomainEventRegisterAny()
+ *
+ */
+typedef void (*virConnectDomainEventIOErrorCallback)(virConnectPtr conn,
+                                                     virDomainPtr dom,
+                                                     const char *srcPath,
+                                                     const char *devAlias,
+                                                     int action,
+                                                     void *opaque);
+
 /**
  * VIR_DOMAIN_EVENT_CALLBACK:
  *
@@ -1922,6 +1954,7 @@ typedef enum {
     VIR_DOMAIN_EVENT_ID_REBOOT = 1,          /* virConnectDomainEventGenericCallback */
     VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2,      /* virConnectDomainEventRTCChangeCallback */
     VIR_DOMAIN_EVENT_ID_WATCHDOG = 3,        /* virConnectDomainEventWatchdogCallback */
+    VIR_DOMAIN_EVENT_ID_IO_ERROR = 4,        /* virConnectDomainEventIOErrorCallback */
 
     /*
      * NB: this enum value will increase over time as new events are
index 95884464b43b73a1c8af4395d3cc3347a7871458..73a8b2b8a58a615d05881792c0522f7a3688d833 100755 (executable)
@@ -172,6 +172,7 @@ skipped_types = {
      'virConnectDomainEventGenericCallback': "No function types in python",
      'virConnectDomainEventRTCChangeCallback': "No function types in python",
      'virConnectDomainEventWatchdogCallback': "No function types in python",
+     'virConnectDomainEventIOErrorCallback': "No function types in python",
      'virEventAddHandleFunc': "No function types in python",
 }
 
index 8e4678d96d21f55ec10551481370995d48bcd5bb..839c99bc033d21f122ca0eaa02a75401302e8109 100644 (file)
@@ -70,6 +70,11 @@ struct _virDomainEvent {
         struct {
             int action;
         } watchdog;
+        struct {
+            char *srcPath;
+            char *devAlias;
+            int action;
+        } ioError;
     } data;
 };
 
@@ -458,6 +463,11 @@ void virDomainEventFree(virDomainEventPtr event)
     if (!event)
         return;
 
+    if (event->eventID == VIR_DOMAIN_EVENT_ID_IO_ERROR) {
+        VIR_FREE(event->data.ioError.srcPath);
+        VIR_FREE(event->data.ioError.devAlias);
+    }
+
     VIR_FREE(event->dom.name);
     VIR_FREE(event);
 }
@@ -590,6 +600,47 @@ virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj,
     return ev;
 }
 
+virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
+                                                  const char *srcPath,
+                                                  const char *devAlias,
+                                                  int action)
+{
+    virDomainEventPtr ev =
+        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_IO_ERROR,
+                                  dom->id, dom->name, dom->uuid);
+
+    if (ev) {
+        ev->data.ioError.action = action;
+        if (!(ev->data.ioError.srcPath = strdup(srcPath)) ||
+            !(ev->data.ioError.devAlias = strdup(devAlias))) {
+            virDomainEventFree(ev);
+            ev = NULL;
+        }
+    }
+
+    return ev;
+}
+virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+                                                  const char *srcPath,
+                                                  const char *devAlias,
+                                                  int action)
+{
+    virDomainEventPtr ev =
+        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_IO_ERROR,
+                                  obj->def->id, obj->def->name, obj->def->uuid);
+
+    if (ev) {
+        ev->data.watchdog.action = action;
+        if (!(ev->data.ioError.srcPath = strdup(srcPath)) ||
+            !(ev->data.ioError.devAlias = strdup(devAlias))) {
+            virDomainEventFree(ev);
+            ev = NULL;
+        }
+    }
+
+    return ev;
+}
+
 /**
  * virDomainEventQueueFree:
  * @queue: pointer to the queue
@@ -712,6 +763,14 @@ void virDomainEventDispatchDefaultFunc(virConnectPtr conn,
                                                     cbopaque);
         break;
 
+    case VIR_DOMAIN_EVENT_ID_IO_ERROR:
+        ((virConnectDomainEventIOErrorCallback)cb)(conn, dom,
+                                                   event->data.ioError.srcPath,
+                                                   event->data.ioError.devAlias,
+                                                   event->data.ioError.action,
+                                                   cbopaque);
+        break;
+
     default:
         VIR_WARN("Unexpected event ID %d", event->eventID);
         break;
index 8f6a764c58852e799491de6cdd5c6ffd626ade19..652c93744ec73249f896a23ef127078bfec71314 100644 (file)
@@ -121,6 +121,15 @@ virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long lo
 virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action);
 virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action);
 
+virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
+                                                  const char *srcPath,
+                                                  const char *devAlias,
+                                                  int action);
+virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+                                                  const char *srcPath,
+                                                  const char *devAlias,
+                                                  int action);
+
 int virDomainEventQueuePush(virDomainEventQueuePtr evtQueue,
                             virDomainEventPtr event);
 
index ebe029b6be10b00d263c374553c34778bfe4e539..f3dccd8812af978f1ccdb01c4a64e6ecd43f8de6 100644 (file)
@@ -220,6 +220,8 @@ virDomainEventRTCChangeNewFromDom;
 virDomainEventRTCChangeNewFromObj;
 virDomainEventWatchdogNewFromDom;
 virDomainEventWatchdogNewFromObj;
+virDomainEventIOErrorNewFromDom;
+virDomainEventIOErrorNewFromObj;
 virDomainEventFree;
 virDomainEventDispatchDefaultFunc;
 virDomainEventDispatch;
index 9e6d7470a2bef9f5280b38788ebf809a55e7f89f..5898eda71caf1085dd24ed919f1bdc9ff508777c 100644 (file)
@@ -756,6 +756,26 @@ findDomainDiskByPath(virDomainObjPtr vm,
     return NULL;
 }
 
+static virDomainDiskDefPtr
+findDomainDiskByAlias(virDomainObjPtr vm,
+                      const char *alias)
+{
+    int i;
+
+    for (i = 0; i < vm->def->ndisks; i++) {
+        virDomainDiskDefPtr disk;
+
+        disk = vm->def->disks[i];
+        if (disk->info.alias != NULL && STREQ(disk->info.alias, alias))
+            return disk;
+    }
+
+    qemuReportError(VIR_ERR_INTERNAL_ERROR,
+                    _("no disk found with alias %s"),
+                    alias);
+    return NULL;
+}
+
 static int
 getVolumeQcowPassphrase(virConnectPtr conn,
                         virDomainDiskDefPtr disk,
@@ -937,12 +957,49 @@ qemuHandleDomainWatchdog(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
 }
 
 
+static int
+qemuHandleDomainIOError(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
+                        virDomainObjPtr vm,
+                        const char *diskAlias,
+                        int action)
+{
+    struct qemud_driver *driver = qemu_driver;
+    virDomainEventPtr event;
+    const char *srcPath;
+    const char *devAlias;
+    virDomainDiskDefPtr disk;
+
+    virDomainObjLock(vm);
+    disk = findDomainDiskByAlias(vm, diskAlias);
+
+    if (disk) {
+        srcPath = disk->src;
+        devAlias = disk->info.alias;
+    } else {
+        srcPath = "";
+        devAlias = "";
+    }
+
+    event = virDomainEventIOErrorNewFromObj(vm, srcPath, devAlias, action);
+    virDomainObjUnlock(vm);
+
+    if (event) {
+        qemuDriverLock(driver);
+        qemuDomainEventQueue(driver, event);
+        qemuDriverUnlock(driver);
+    }
+
+    return 0;
+}
+
+
 static qemuMonitorCallbacks monitorCallbacks = {
     .eofNotify = qemuHandleMonitorEOF,
     .diskSecretLookup = findVolumeQcowPassphrase,
     .domainReset = qemuHandleDomainReset,
     .domainRTCChange = qemuHandleDomainRTCChange,
     .domainWatchdog = qemuHandleDomainWatchdog,
+    .domainIOError = qemuHandleDomainIOError,
 };
 
 static int
index 8e2eb00ace6a9f53de860b7989136071cb4b41c4..baf5bd8e4d594deebdbbf79a3d1dcc3ce6b44186 100644 (file)
@@ -821,6 +821,23 @@ int qemuMonitorEmitWatchdog(qemuMonitorPtr mon, int action)
 }
 
 
+int qemuMonitorEmitIOError(qemuMonitorPtr mon,
+                           const char *diskAlias,
+                           int action)
+{
+    int ret = -1;
+    VIR_DEBUG("mon=%p", mon);
+
+    qemuMonitorRef(mon);
+    qemuMonitorUnlock(mon);
+    if (mon->cb && mon->cb->domainIOError)
+        ret = mon->cb->domainIOError(mon, mon->vm, diskAlias, action);
+    qemuMonitorLock(mon);
+    qemuMonitorUnref(mon);
+    return ret;
+}
+
+
 int qemuMonitorSetCapabilities(qemuMonitorPtr mon)
 {
     int ret;
index 9349eaa41b6cb3e97008e1783067ed3b9d565502..ad5316f853043d8b0133e0a5907af30018286d22 100644 (file)
@@ -92,6 +92,10 @@ struct _qemuMonitorCallbacks {
     int (*domainWatchdog)(qemuMonitorPtr mon,
                           virDomainObjPtr vm,
                           int action);
+    int (*domainIOError)(qemuMonitorPtr mon,
+                         virDomainObjPtr vm,
+                         const char *diskAlias,
+                         int action);
 };
 
 
@@ -130,6 +134,9 @@ int qemuMonitorEmitPowerdown(qemuMonitorPtr mon);
 int qemuMonitorEmitStop(qemuMonitorPtr mon);
 int qemuMonitorEmitRTCChange(qemuMonitorPtr mon, long long offset);
 int qemuMonitorEmitWatchdog(qemuMonitorPtr mon, int action);
+int qemuMonitorEmitIOError(qemuMonitorPtr mon,
+                           const char *diskAlias,
+                           int action);
 
 int qemuMonitorStartCPUs(qemuMonitorPtr mon,
                          virConnectPtr conn);
index 767a4764c910e777fdecc28a0389d0d2d8e1704f..30ae80f1be2715fae900cb914372d65faa7621af 100644 (file)
@@ -51,6 +51,7 @@ static void qemuMonitorJSONHandlePowerdown(qemuMonitorPtr mon, virJSONValuePtr d
 static void qemuMonitorJSONHandleStop(qemuMonitorPtr mon, virJSONValuePtr data);
 static void qemuMonitorJSONHandleRTCChange(qemuMonitorPtr mon, virJSONValuePtr data);
 static void qemuMonitorJSONHandleWatchdog(qemuMonitorPtr mon, virJSONValuePtr data);
+static void qemuMonitorJSONHandleIOError(qemuMonitorPtr mon, virJSONValuePtr data);
 
 struct {
     const char *type;
@@ -62,6 +63,7 @@ struct {
     { "STOP", qemuMonitorJSONHandleStop, },
     { "RTC_CHANGE", qemuMonitorJSONHandleRTCChange, },
     { "WATCHDOG", qemuMonitorJSONHandleWatchdog, },
+    { "DISK_IO_ERROR", qemuMonitorJSONHandleIOError, },
 };
 
 
@@ -510,8 +512,8 @@ static void qemuMonitorJSONHandleRTCChange(qemuMonitorPtr mon, virJSONValuePtr d
 }
 
 VIR_ENUM_DECL(qemuMonitorWatchdogAction)
-VIR_ENUM_IMPL(qemuMonitorWatchdogAction, VIR_DOMAIN_EVENT_WATCHDOG_DEBUG,
-              "none", "pause", "reset", "poweroff" "shutdown", "debug");
+VIR_ENUM_IMPL(qemuMonitorWatchdogAction, VIR_DOMAIN_EVENT_WATCHDOG_DEBUG + 1,
+              "none", "pause", "reset", "poweroff", "shutdown", "debug");
 
 static void qemuMonitorJSONHandleWatchdog(qemuMonitorPtr mon, virJSONValuePtr data)
 {
@@ -531,6 +533,38 @@ static void qemuMonitorJSONHandleWatchdog(qemuMonitorPtr mon, virJSONValuePtr da
     qemuMonitorEmitRTCChange(mon, actionID);
 }
 
+VIR_ENUM_DECL(qemuMonitorIOErrorAction)
+VIR_ENUM_IMPL(qemuMonitorIOErrorAction, VIR_DOMAIN_EVENT_IO_ERROR_REPORT + 1,
+              "ignore", "stop", "report");
+
+
+static void qemuMonitorJSONHandleIOError(qemuMonitorPtr mon, virJSONValuePtr data)
+{
+    const char *device;
+    const char *action;
+    int actionID;
+
+    /* Throughout here we try our best to carry on upon errors,
+       since it's imporatant to get as much info as possible out
+       to the application */
+
+    if ((action = virJSONValueObjectGetString(data, "action")) == NULL) {
+        VIR_WARN0("Missing action in disk io error event");
+        action = "ignore";
+    }
+
+    if ((device = virJSONValueObjectGetString(data, "device")) == NULL) {
+        VIR_WARN0("missing device in disk io error event");
+    }
+
+    if ((actionID = qemuMonitorIOErrorActionTypeFromString(action)) < 0) {
+        VIR_WARN("unknown disk io error action '%s'", action);
+        actionID = VIR_DOMAIN_EVENT_IO_ERROR_NONE;
+    }
+
+    qemuMonitorEmitIOError(mon, device, actionID);
+}
+
 
 int
 qemuMonitorJSONSetCapabilities(qemuMonitorPtr mon)
index b3cb36a0e94ec520b0f2b18223bca487a90edd76..91b3a832e82970cc165858175ccaefb5b64a382e 100644 (file)
@@ -6994,6 +6994,36 @@ remoteDomainReadEventWatchdog(virConnectPtr conn, XDR *xdr)
 }
 
 
+static virDomainEventPtr
+remoteDomainReadEventIOError(virConnectPtr conn, XDR *xdr)
+{
+    remote_domain_event_io_error_msg msg;
+    virDomainPtr dom;
+    virDomainEventPtr event = NULL;
+    memset (&msg, 0, sizeof msg);
+
+    /* unmarshall parameters, and process it*/
+    if (! xdr_remote_domain_event_io_error_msg(xdr, &msg) ) {
+        error (conn, VIR_ERR_RPC,
+               _("unable to demarshall reboot event"));
+        return NULL;
+    }
+
+    dom = get_nonnull_domain(conn,msg.dom);
+    if (!dom)
+        return NULL;
+
+    event = virDomainEventIOErrorNewFromDom(dom,
+                                            msg.srcPath,
+                                            msg.devAlias,
+                                            msg.action);
+    xdr_free ((xdrproc_t) &xdr_remote_domain_event_io_error_msg, (char *) &msg);
+
+    virDomainFree(dom);
+    return event;
+}
+
+
 static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
 remoteSecretOpen (virConnectPtr conn,
                   virConnectAuthPtr auth,
@@ -8549,6 +8579,10 @@ processCallDispatchMessage(virConnectPtr conn, struct private_data *priv,
         event = remoteDomainReadEventWatchdog(conn, xdr);
         break;
 
+    case REMOTE_PROC_DOMAIN_EVENT_IO_ERROR:
+        event = remoteDomainReadEventIOError(conn, xdr);
+        break;
+
     default:
         DEBUG("Unexpected event proc %d", hdr->proc);
         break;
index e022235cab6963017d19e2fe2f0b750a92c38d80..66fcea716615e030eb813a532abf6a4421da9693 100644 (file)
@@ -3081,6 +3081,21 @@ xdr_remote_domain_event_watchdog_msg (XDR *xdrs, remote_domain_event_watchdog_ms
         return TRUE;
 }
 
+bool_t
+xdr_remote_domain_event_io_error_msg (XDR *xdrs, remote_domain_event_io_error_msg *objp)
+{
+
+         if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+                 return FALSE;
+         if (!xdr_remote_nonnull_string (xdrs, &objp->srcPath))
+                 return FALSE;
+         if (!xdr_remote_nonnull_string (xdrs, &objp->devAlias))
+                 return FALSE;
+         if (!xdr_int (xdrs, &objp->action))
+                 return FALSE;
+        return TRUE;
+}
+
 bool_t
 xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
 {
index 0d7eec5a8ba0225b29ecf7afd454623033ba7329..d49e8dcbab8b34a5dd714f0135f937a99f12d4a9 100644 (file)
@@ -1744,6 +1744,14 @@ struct remote_domain_event_watchdog_msg {
         int action;
 };
 typedef struct remote_domain_event_watchdog_msg remote_domain_event_watchdog_msg;
+
+struct remote_domain_event_io_error_msg {
+        remote_nonnull_domain dom;
+        remote_nonnull_string srcPath;
+        remote_nonnull_string devAlias;
+        int action;
+};
+typedef struct remote_domain_event_io_error_msg remote_domain_event_io_error_msg;
 #define REMOTE_PROGRAM 0x20008086
 #define REMOTE_PROTOCOL_VERSION 1
 
@@ -1919,6 +1927,7 @@ enum remote_procedure {
         REMOTE_PROC_DOMAIN_EVENT_REBOOT = 169,
         REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE = 170,
         REMOTE_PROC_DOMAIN_EVENT_WATCHDOG = 171,
+        REMOTE_PROC_DOMAIN_EVENT_IO_ERROR = 172,
 };
 typedef enum remote_procedure remote_procedure;
 
@@ -2235,6 +2244,7 @@ extern  bool_t xdr_remote_domain_events_deregister_any_args (XDR *, remote_domai
 extern  bool_t xdr_remote_domain_event_reboot_msg (XDR *, remote_domain_event_reboot_msg*);
 extern  bool_t xdr_remote_domain_event_rtc_change_msg (XDR *, remote_domain_event_rtc_change_msg*);
 extern  bool_t xdr_remote_domain_event_watchdog_msg (XDR *, remote_domain_event_watchdog_msg*);
+extern  bool_t xdr_remote_domain_event_io_error_msg (XDR *, remote_domain_event_io_error_msg*);
 extern  bool_t xdr_remote_procedure (XDR *, remote_procedure*);
 extern  bool_t xdr_remote_message_type (XDR *, remote_message_type*);
 extern  bool_t xdr_remote_message_status (XDR *, remote_message_status*);
@@ -2525,6 +2535,7 @@ extern bool_t xdr_remote_domain_events_deregister_any_args ();
 extern bool_t xdr_remote_domain_event_reboot_msg ();
 extern bool_t xdr_remote_domain_event_rtc_change_msg ();
 extern bool_t xdr_remote_domain_event_watchdog_msg ();
+extern bool_t xdr_remote_domain_event_io_error_msg ();
 extern bool_t xdr_remote_procedure ();
 extern bool_t xdr_remote_message_type ();
 extern bool_t xdr_remote_message_status ();
index b3f622e1bd16281fbce0396039c3c450fe351fe2..24be558d997ed2005ab0dd73334f6e485773b5b5 100644 (file)
@@ -1550,6 +1550,13 @@ struct remote_domain_event_watchdog_msg {
     int action;
 };
 
+struct remote_domain_event_io_error_msg {
+    remote_nonnull_domain dom;
+    remote_nonnull_string srcPath;
+    remote_nonnull_string devAlias;
+    int action;
+};
+
 /*----- Protocol. -----*/
 
 /* Define the program number, protocol version and procedure numbers here. */
@@ -1744,7 +1751,8 @@ enum remote_procedure {
     REMOTE_PROC_DOMAIN_EVENT_REBOOT = 169,
     REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE = 170,
 
-    REMOTE_PROC_DOMAIN_EVENT_WATCHDOG = 171
+    REMOTE_PROC_DOMAIN_EVENT_WATCHDOG = 171,
+    REMOTE_PROC_DOMAIN_EVENT_IO_ERROR = 172
 
     /*
      * Notice how the entries are grouped in sets of 10 ?