[libvirt] [PATCHv2 5/6] event: convert remaining domain events to new style

Wednesday, 29 January 2014

Following the patterns established by lifecycle events, this
creates all the new RPC calls needed to pass callback IDs
for every domain event, and changes the limits in client and
server codes to use modern style when possible.

I've tested all combinations: both 'old client and new server'
and 'new client and old server' continue to work with the old
RPCs, and 'new client and new server' benefit from server-side
filtering with the new RPCs.

* src/remote/remote_protocol.x (REMOTE_PROC_DOMAIN_EVENT_*): Add
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_* counterparts.
* daemon/remote.c (remoteRelayDomainEvent*): Send callbackID via
newer RPC when used with new-style registration.
(remoteDispatchConnectDomainEventCallbackRegisterAny): Extend to
cover all domain events.
* src/remote/remote_driver.c (remoteDomainBuildEvent*): Add new
Callback and Helper functions.
(remoteEvents): Match order of RPC numbers, register new handlers.
(remoteConnectDomainEventRegisterAny)
(remoteConnectDomainEventDeregisterAny): Extend to cover all
domain events.
* src/remote_protocol-structs: Regenerate.

Signed-off-by: Eric Blake <eblake(a)redhat.com&gt;
---
 daemon/remote.c              | 240 ++++++++++++++----
 src/remote/remote_driver.c   | 581 ++++++++++++++++++++++++++++++++++---------
 src/remote/remote_protocol.x | 155 +++++++++++-
 src/remote_protocol-structs  |  75 ++++++
 4 files changed, 886 insertions(+), 165 deletions(-)

diff --git a/daemon/remote.c b/daemon/remote.c
index 1dfcb65..48c707d 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -239,16 +239,25 @@ remoteRelayDomainEventReboot(virConnectPtr conn,
         !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
         return -1;

-    VIR_DEBUG("Relaying domain reboot event %s %d, callback %d",
-              dom->name, dom->id, callback->callbackID);
+    VIR_DEBUG("Relaying domain reboot event %s %d, callback %d legacy %d",
+              dom->name, dom->id, callback->callbackID, callback->legacy);

     /* build return data */
     memset(&data, 0, sizeof(data));
     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_REBOOT,
-                                  (xdrproc_t)xdr_remote_domain_event_reboot_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_REBOOT,
+                                      (xdrproc_t)xdr_remote_domain_event_reboot_msg,
&data);
+    } else {
+        remote_domain_event_callback_reboot_msg msg = { callback->callbackID,
+                                                        data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_reboot_msg, &msg);
+    }

     return 0;
 }
@@ -267,17 +276,27 @@ remoteRelayDomainEventRTCChange(virConnectPtr conn,
         !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
         return -1;

-    VIR_DEBUG("Relaying domain rtc change event %s %d %lld, callback %d",
-              dom->name, dom->id, offset, callback->callbackID);
+    VIR_DEBUG("Relaying domain rtc change event %s %d %lld, callback %d legacy
%d",
+              dom->name, dom->id, offset,
+              callback->callbackID, callback->legacy);

     /* build return data */
     memset(&data, 0, sizeof(data));
     make_nonnull_domain(&data.dom, dom);
     data.offset = offset;

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
-                                  (xdrproc_t)xdr_remote_domain_event_rtc_change_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
+                                      (xdrproc_t)xdr_remote_domain_event_rtc_change_msg,
&data);
+    } else {
+        remote_domain_event_callback_rtc_change_msg msg = { callback->callbackID,
+                                                            data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_rtc_change_msg, &msg);
+    }

     return 0;
 }
@@ -304,9 +323,18 @@ remoteRelayDomainEventWatchdog(virConnectPtr conn,
     make_nonnull_domain(&data.dom, dom);
     data.action = action;

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_WATCHDOG,
-                                  (xdrproc_t)xdr_remote_domain_event_watchdog_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_WATCHDOG,
+                                      (xdrproc_t)xdr_remote_domain_event_watchdog_msg,
&data);
+    } else {
+        remote_domain_event_callback_watchdog_msg msg = { callback->callbackID,
+                                                          data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_watchdog_msg, &msg);
+    }

     return 0;
 }
@@ -339,9 +367,18 @@ remoteRelayDomainEventIOError(virConnectPtr conn,
     make_nonnull_domain(&data.dom, dom);
     data.action = action;

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_IO_ERROR,
-                                  (xdrproc_t)xdr_remote_domain_event_io_error_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_IO_ERROR,
+                                      (xdrproc_t)xdr_remote_domain_event_io_error_msg,
&data);
+    } else {
+        remote_domain_event_callback_io_error_msg msg = { callback->callbackID,
+                                                          data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_io_error_msg, &msg);
+    }

     return 0;
 error:
@@ -381,9 +418,18 @@ remoteRelayDomainEventIOErrorReason(virConnectPtr conn,

     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
-                                  (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
+                                     
(xdrproc_t)xdr_remote_domain_event_io_error_reason_msg, &data);
+    } else {
+        remote_domain_event_callback_io_error_reason_msg msg = {
callback->callbackID,
+                                                                 data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_io_error_reason_msg, &msg);
+    }

     return 0;

@@ -447,9 +493,18 @@ remoteRelayDomainEventGraphics(virConnectPtr conn,
     }
     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_GRAPHICS,
-                                  (xdrproc_t)xdr_remote_domain_event_graphics_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_GRAPHICS,
+                                      (xdrproc_t)xdr_remote_domain_event_graphics_msg,
&data);
+    } else {
+        remote_domain_event_callback_graphics_msg msg = { callback->callbackID,
+                                                          data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_graphics_msg, &msg);
+    }

     return 0;

@@ -495,9 +550,18 @@ remoteRelayDomainEventBlockJob(virConnectPtr conn,
     data.status = status;
     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB,
-                                  (xdrproc_t)xdr_remote_domain_event_block_job_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB,
+                                      (xdrproc_t)xdr_remote_domain_event_block_job_msg,
&data);
+    } else {
+        remote_domain_event_callback_block_job_msg msg = { callback->callbackID,
+                                                           data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_block_job_msg, &msg);
+    }

     return 0;
 error:
@@ -525,9 +589,18 @@ remoteRelayDomainEventControlError(virConnectPtr conn,
     memset(&data, 0, sizeof(data));
     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR,
-                                  (xdrproc_t)xdr_remote_domain_event_control_error_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR,
+                                     
(xdrproc_t)xdr_remote_domain_event_control_error_msg, &data);
+    } else {
+        remote_domain_event_callback_control_error_msg msg = { callback->callbackID,
+                                                               data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_control_error_msg, &msg);
+    }

     return 0;
 }
@@ -574,9 +647,18 @@ remoteRelayDomainEventDiskChange(virConnectPtr conn,

     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE,
-                                  (xdrproc_t)xdr_remote_domain_event_disk_change_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE,
+                                      (xdrproc_t)xdr_remote_domain_event_disk_change_msg,
&data);
+    } else {
+        remote_domain_event_callback_disk_change_msg msg = { callback->callbackID,
+                                                             data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_disk_change_msg, &msg);
+    }

     return 0;

@@ -613,9 +695,18 @@ remoteRelayDomainEventTrayChange(virConnectPtr conn,

     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE,
-                                  (xdrproc_t)xdr_remote_domain_event_tray_change_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE,
+                                      (xdrproc_t)xdr_remote_domain_event_tray_change_msg,
&data);
+    } else {
+        remote_domain_event_callback_tray_change_msg msg = { callback->callbackID,
+                                                             data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_tray_change_msg, &msg);
+    }

     return 0;
 }
@@ -640,9 +731,18 @@ remoteRelayDomainEventPMWakeup(virConnectPtr conn,
     memset(&data, 0, sizeof(data));
     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP,
-                                  (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP,
+                                      (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg,
&data);
+    } else {
+        remote_domain_event_callback_pmwakeup_msg msg = { callback->callbackID,
+                                                          data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_pmwakeup_msg, &msg);
+    }

     return 0;
 }
@@ -667,9 +767,18 @@ remoteRelayDomainEventPMSuspend(virConnectPtr conn,
     memset(&data, 0, sizeof(data));
     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND,
-                                  (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND,
+                                      (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg,
&data);
+    } else {
+        remote_domain_event_callback_pmsuspend_msg msg = { callback->callbackID,
+                                                           data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_pmsuspend_msg, &msg);
+    }

     return 0;
 }
@@ -695,9 +804,18 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn,
     make_nonnull_domain(&data.dom, dom);
     data.actual = actual;

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE,
-                                  (xdrproc_t)xdr_remote_domain_event_balloon_change_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE,
+                                     
(xdrproc_t)xdr_remote_domain_event_balloon_change_msg, &data);
+    } else {
+        remote_domain_event_callback_balloon_change_msg msg = { callback->callbackID,
+                                                                data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_balloon_change_msg, &msg);
+    }

     return 0;
 }
@@ -723,9 +841,18 @@ remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn,
     memset(&data, 0, sizeof(data));
     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK,
-                                  (xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg,
&data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK,
+                                     
(xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg, &data);
+    } else {
+        remote_domain_event_callback_pmsuspend_disk_msg msg = { callback->callbackID,
+                                                                data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_pmsuspend_disk_msg, &msg);
+    }

     return 0;
 }
@@ -754,10 +881,20 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn,

     make_nonnull_domain(&data.dom, dom);

-    remoteDispatchObjectEventSend(callback->client, remoteProgram,
-                                  REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED,
-                                  (xdrproc_t)xdr_remote_domain_event_device_removed_msg,
-                                  &data);
+    if (callback->legacy) {
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED,
+                                     
(xdrproc_t)xdr_remote_domain_event_device_removed_msg,
+                                      &data);
+    } else {
+        remote_domain_event_callback_device_removed_msg msg = { callback->callbackID,
+                                                                data };
+
+        remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                      REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED,
+                                     
(xdrproc_t)xdr_remote_domain_event_callback_device_removed_msg,
+                                      &msg);
+    }

     return 0;
 }
@@ -3589,8 +3726,7 @@ remoteDispatchConnectDomainEventCallbackRegisterAny(virNetServerPtr
server ATTRI
         !(dom = get_nonnull_domain(priv->conn, *args->dom)))
         goto cleanup;

-    /* FIXME: support all domain events */
-    if (args->eventID != VIR_DOMAIN_EVENT_ID_LIFECYCLE) {
+    if (args->eventID >= VIR_DOMAIN_EVENT_ID_LAST || args->eventID < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"),
                        args->eventID);
         goto cleanup;
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 35baaeb..4cdce81 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -218,67 +218,136 @@ remoteDomainBuildEventReboot(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
                              virNetClientPtr client ATTRIBUTE_UNUSED,
                              void *evdata, void *opaque);
 static void
+remoteDomainBuildEventCallbackReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                     virNetClientPtr client ATTRIBUTE_UNUSED,
+                                     void *evdata, void *opaque);
+
+static void
 remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog,
                                 virNetClientPtr client,
                                 void *evdata, void *opaque);
 static void
+remoteDomainBuildEventCallbackRTCChange(virNetClientProgramPtr prog,
+                                        virNetClientPtr client,
+                                        void *evdata, void *opaque);
+
+static void
 remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog,
                                virNetClientPtr client,
                                void *evdata, void *opaque);
 static void
+remoteDomainBuildEventCallbackWatchdog(virNetClientProgramPtr prog,
+                                       virNetClientPtr client,
+                                       void *evdata, void *opaque);
+
+static void
 remoteDomainBuildEventIOError(virNetClientProgramPtr prog,
                               virNetClientPtr client,
                               void *evdata, void *opaque);
 static void
+remoteDomainBuildEventCallbackIOError(virNetClientProgramPtr prog,
+                                      virNetClientPtr client,
+                                      void *evdata, void *opaque);
+
+static void
 remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog,
                                     virNetClientPtr client,
                                     void *evdata, void *opaque);
 static void
+remoteDomainBuildEventCallbackIOErrorReason(virNetClientProgramPtr prog,
+                                            virNetClientPtr client,
+                                            void *evdata, void *opaque);
+
+static void
 remoteDomainBuildEventGraphics(virNetClientProgramPtr prog,
                                virNetClientPtr client,
                                void *evdata, void *opaque);
 static void
+remoteDomainBuildEventCallbackGraphics(virNetClientProgramPtr prog,
+                                       virNetClientPtr client,
+                                       void *evdata, void *opaque);
+
+static void
 remoteDomainBuildEventControlError(virNetClientProgramPtr prog,
                                    virNetClientPtr client,
                                    void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackControlError(virNetClientProgramPtr prog,
+                                           virNetClientPtr client,
+                                           void *evdata, void *opaque);

 static void
 remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog,
                                virNetClientPtr client,
                                void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackBlockJob(virNetClientProgramPtr prog,
+                                       virNetClientPtr client,
+                                       void *evdata, void *opaque);
+

 static void
 remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog,
                                  virNetClientPtr client,
                                  void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackDiskChange(virNetClientProgramPtr prog,
+                                         virNetClientPtr client,
+                                         void *evdata, void *opaque);

 static void
 remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog,
                                  virNetClientPtr client,
                                  void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackTrayChange(virNetClientProgramPtr prog,
+                                         virNetClientPtr client,
+                                         void *evdata, void *opaque);

 static void
 remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog,
                                virNetClientPtr client,
                                void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackPMWakeup(virNetClientProgramPtr prog,
+                                       virNetClientPtr client,
+                                       void *evdata, void *opaque);

 static void
 remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog,
                                 virNetClientPtr client,
                                 void *evdata, void *opaque);
 static void
+remoteDomainBuildEventCallbackPMSuspend(virNetClientProgramPtr prog,
+                                        virNetClientPtr client,
+                                        void *evdata, void *opaque);
+
+static void
 remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog,
                                     virNetClientPtr client,
                                     void *evdata, void *opaque);
 static void
+remoteDomainBuildEventCallbackBalloonChange(virNetClientProgramPtr prog,
+                                            virNetClientPtr client,
+                                            void *evdata, void *opaque);
+
+static void
 remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog,
                                   virNetClientPtr client,
                                   void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgramPtr prog,
+                                            virNetClientPtr client,
+                                            void *evdata, void *opaque);

 static void
 remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog,
                                     virNetClientPtr client,
                                     void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackDeviceRemoved(virNetClientProgramPtr prog,
+                                            virNetClientPtr client,
+                                            void *evdata, void *opaque);

 static void
 remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
@@ -286,18 +355,18 @@ remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
                                  void *evdata, void *opaque);

 static virNetClientProgramEvent remoteEvents[] = {
-    { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
-      remoteDomainBuildEventRTCChange,
-      sizeof(remote_domain_event_rtc_change_msg),
-      (xdrproc_t)xdr_remote_domain_event_rtc_change_msg },
-    { REMOTE_PROC_DOMAIN_EVENT_REBOOT,
-      remoteDomainBuildEventReboot,
-      sizeof(remote_domain_event_reboot_msg),
-      (xdrproc_t)xdr_remote_domain_event_reboot_msg },
     { REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE,
       remoteDomainBuildEventLifecycle,
       sizeof(remote_domain_event_lifecycle_msg),
       (xdrproc_t)xdr_remote_domain_event_lifecycle_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_REBOOT,
+      remoteDomainBuildEventReboot,
+      sizeof(remote_domain_event_reboot_msg),
+      (xdrproc_t)xdr_remote_domain_event_reboot_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
+      remoteDomainBuildEventRTCChange,
+      sizeof(remote_domain_event_rtc_change_msg),
+      (xdrproc_t)xdr_remote_domain_event_rtc_change_msg },
     { REMOTE_PROC_DOMAIN_EVENT_WATCHDOG,
       remoteDomainBuildEventWatchdog,
       sizeof(remote_domain_event_watchdog_msg),
@@ -306,14 +375,14 @@ static virNetClientProgramEvent remoteEvents[] = {
       remoteDomainBuildEventIOError,
       sizeof(remote_domain_event_io_error_msg),
       (xdrproc_t)xdr_remote_domain_event_io_error_msg },
-    { REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
-      remoteDomainBuildEventIOErrorReason,
-      sizeof(remote_domain_event_io_error_reason_msg),
-      (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg },
     { REMOTE_PROC_DOMAIN_EVENT_GRAPHICS,
       remoteDomainBuildEventGraphics,
       sizeof(remote_domain_event_graphics_msg),
       (xdrproc_t)xdr_remote_domain_event_graphics_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
+      remoteDomainBuildEventIOErrorReason,
+      sizeof(remote_domain_event_io_error_reason_msg),
+      (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg },
     { REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR,
       remoteDomainBuildEventControlError,
       sizeof(remote_domain_event_control_error_msg),
@@ -367,6 +436,66 @@ static virNetClientProgramEvent remoteEvents[] = {
       remoteDomainBuildEventCallbackLifecycle,
       sizeof(remote_domain_event_callback_lifecycle_msg),
       (xdrproc_t)xdr_remote_domain_event_callback_lifecycle_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT,
+      remoteDomainBuildEventCallbackReboot,
+      sizeof(remote_domain_event_callback_reboot_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_reboot_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE,
+      remoteDomainBuildEventCallbackRTCChange,
+      sizeof(remote_domain_event_callback_rtc_change_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_rtc_change_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG,
+      remoteDomainBuildEventCallbackWatchdog,
+      sizeof(remote_domain_event_callback_watchdog_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_watchdog_msg},
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR,
+      remoteDomainBuildEventCallbackIOError,
+      sizeof(remote_domain_event_callback_io_error_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_io_error_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS,
+      remoteDomainBuildEventCallbackGraphics,
+      sizeof(remote_domain_event_callback_graphics_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_graphics_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON,
+      remoteDomainBuildEventCallbackIOErrorReason,
+      sizeof(remote_domain_event_callback_io_error_reason_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_io_error_reason_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR,
+      remoteDomainBuildEventCallbackControlError,
+      sizeof(remote_domain_event_callback_control_error_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_control_error_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB,
+      remoteDomainBuildEventCallbackBlockJob,
+      sizeof(remote_domain_event_callback_block_job_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_block_job_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE,
+      remoteDomainBuildEventCallbackDiskChange,
+      sizeof(remote_domain_event_callback_disk_change_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_disk_change_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE,
+      remoteDomainBuildEventCallbackTrayChange,
+      sizeof(remote_domain_event_callback_tray_change_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_tray_change_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP,
+      remoteDomainBuildEventCallbackPMWakeup,
+      sizeof(remote_domain_event_callback_pmwakeup_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_pmwakeup_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND,
+      remoteDomainBuildEventCallbackPMSuspend,
+      sizeof(remote_domain_event_callback_pmsuspend_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_pmsuspend_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE,
+      remoteDomainBuildEventCallbackBalloonChange,
+      sizeof(remote_domain_event_callback_balloon_change_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_balloon_change_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK,
+      remoteDomainBuildEventCallbackPMSuspendDisk,
+      sizeof(remote_domain_event_callback_pmsuspend_disk_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_pmsuspend_disk_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED,
+      remoteDomainBuildEventCallbackDeviceRemoved,
+      sizeof(remote_domain_event_callback_device_removed_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_device_removed_msg },
 };

 enum virDrvOpenRemoteFlags {
@@ -4609,13 +4738,11 @@ remoteDomainBuildEventCallbackLifecycle(virNetClientProgramPtr
prog ATTRIBUTE_UN


 static void
-remoteDomainBuildEventReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                             virNetClientPtr client ATTRIBUTE_UNUSED,
-                             void *evdata, void *opaque)
+remoteDomainBuildEventRebootHelper(virConnectPtr conn,
+                                   remote_domain_event_reboot_msg *msg,
+                                   int callbackID)
 {
-    virConnectPtr conn = opaque;
     struct private_data *priv = conn->privateData;
-    remote_domain_event_reboot_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4626,18 +4753,33 @@ remoteDomainBuildEventReboot(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
     event = virDomainEventRebootNewFromDom(dom);
     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
-
 static void
-remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                                virNetClientPtr client ATTRIBUTE_UNUSED,
-                                void *evdata, void *opaque)
+remoteDomainBuildEventReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                             virNetClientPtr client ATTRIBUTE_UNUSED,
+                             void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_reboot_msg *msg = evdata;
+    remoteDomainBuildEventRebootHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                     virNetClientPtr client ATTRIBUTE_UNUSED,
+                                     void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_callback_reboot_msg *msg = evdata;
+    remoteDomainBuildEventRebootHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventRTCChangeHelper(virConnectPtr conn,
+                                      remote_domain_event_rtc_change_msg *msg,
+                                      int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_rtc_change_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4648,18 +4790,33 @@ remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
     event = virDomainEventRTCChangeNewFromDom(dom, msg->offset);
     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
-
 static void
-remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                               virNetClientPtr client ATTRIBUTE_UNUSED,
-                               void *evdata, void *opaque)
+remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                virNetClientPtr client ATTRIBUTE_UNUSED,
+                                void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_rtc_change_msg *msg = evdata;
+    remoteDomainBuildEventRTCChangeHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackRTCChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                        virNetClientPtr client ATTRIBUTE_UNUSED,
+                                        void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_rtc_change_msg *msg = evdata;
+    remoteDomainBuildEventRTCChangeHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventWatchdogHelper(virConnectPtr conn,
+                                     remote_domain_event_watchdog_msg *msg,
+                                     int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_watchdog_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4670,18 +4827,33 @@ remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
     event = virDomainEventWatchdogNewFromDom(dom, msg->action);
     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
-
 static void
-remoteDomainBuildEventIOError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                              virNetClientPtr client ATTRIBUTE_UNUSED,
-                              void *evdata, void *opaque)
+remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                               virNetClientPtr client ATTRIBUTE_UNUSED,
+                               void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_watchdog_msg *msg = evdata;
+    remoteDomainBuildEventWatchdogHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackWatchdog(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                       virNetClientPtr client ATTRIBUTE_UNUSED,
+                                       void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_callback_watchdog_msg *msg = evdata;
+    remoteDomainBuildEventWatchdogHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventIOErrorHelper(virConnectPtr conn,
+                                    remote_domain_event_io_error_msg *msg,
+                                    int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_io_error_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4695,18 +4867,33 @@ remoteDomainBuildEventIOError(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
                                             msg->action);
     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
-
 static void
-remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                                    virNetClientPtr client ATTRIBUTE_UNUSED,
-                                    void *evdata, void *opaque)
+remoteDomainBuildEventIOError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                              virNetClientPtr client ATTRIBUTE_UNUSED,
+                              void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_io_error_msg *msg = evdata;
+    remoteDomainBuildEventIOErrorHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackIOError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                      virNetClientPtr client ATTRIBUTE_UNUSED,
+                                      void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_callback_io_error_msg *msg = evdata;
+    remoteDomainBuildEventIOErrorHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventIOErrorReasonHelper(virConnectPtr conn,
+                                          remote_domain_event_io_error_reason_msg *msg,
+                                          int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_io_error_reason_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4722,17 +4909,33 @@ remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
 static void
-remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                               virNetClientPtr client ATTRIBUTE_UNUSED,
-                               void *evdata, void *opaque)
+remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                    virNetClientPtr client ATTRIBUTE_UNUSED,
+                                    void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_io_error_reason_msg *msg = evdata;
+    remoteDomainBuildEventIOErrorReasonHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackIOErrorReason(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
+                                            virNetClientPtr client ATTRIBUTE_UNUSED,
+                                            void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_io_error_reason_msg *msg = evdata;
+    remoteDomainBuildEventIOErrorReasonHelper(conn, &msg->msg,
msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventBlockJobHelper(virConnectPtr conn,
+                                     remote_domain_event_block_job_msg *msg,
+                                     int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_block_job_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4745,17 +4948,33 @@ remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
 static void
-remoteDomainBuildEventGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
                                virNetClientPtr client ATTRIBUTE_UNUSED,
                                void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_block_job_msg *msg = evdata;
+    remoteDomainBuildEventBlockJobHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackBlockJob(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                       virNetClientPtr client ATTRIBUTE_UNUSED,
+                                       void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_block_job_msg *msg = evdata;
+    remoteDomainBuildEventBlockJobHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventGraphicsHelper(virConnectPtr conn,
+                                     remote_domain_event_graphics_msg *msg,
+                                     int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_graphics_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;
     virDomainEventGraphicsAddressPtr localAddr = NULL;
@@ -4801,7 +5020,7 @@ remoteDomainBuildEventGraphics(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
     return;

 error:
@@ -4826,16 +5045,31 @@ error:
     virDomainFree(dom);
     return;
 }
-
-
 static void
-remoteDomainBuildEventControlError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                                   virNetClientPtr client ATTRIBUTE_UNUSED,
-                                   void *evdata, void *opaque)
+remoteDomainBuildEventGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                               virNetClientPtr client ATTRIBUTE_UNUSED,
+                               void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_graphics_msg *msg = evdata;
+    remoteDomainBuildEventGraphicsHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                       virNetClientPtr client ATTRIBUTE_UNUSED,
+                                       void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_graphics_msg *msg = evdata;
+    remoteDomainBuildEventGraphicsHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventControlErrorHelper(virConnectPtr conn,
+                                         remote_domain_event_control_error_msg *msg,
+                                         int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_control_error_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4847,18 +5081,34 @@ remoteDomainBuildEventControlError(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
+}
+static void
+remoteDomainBuildEventControlError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                   virNetClientPtr client ATTRIBUTE_UNUSED,
+                                   void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_control_error_msg *msg = evdata;
+    remoteDomainBuildEventControlErrorHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackControlError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                           virNetClientPtr client ATTRIBUTE_UNUSED,
+                                           void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_control_error_msg *msg = evdata;
+    remoteDomainBuildEventControlErrorHelper(conn, &msg->msg,
msg->callbackID);
 }


 static void
-remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                                 virNetClientPtr client ATTRIBUTE_UNUSED,
-                                 void *evdata, void *opaque)
+remoteDomainBuildEventDiskChangeHelper(virConnectPtr conn,
+                                       remote_domain_event_disk_change_msg *msg,
+                                       int callbackID)
 {
-    virConnectPtr conn = opaque;
     struct private_data *priv = conn->privateData;
-    remote_domain_event_disk_change_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4874,18 +5124,34 @@ remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
-
 static void
-remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
                                  virNetClientPtr client ATTRIBUTE_UNUSED,
                                  void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_disk_change_msg *msg = evdata;
+    remoteDomainBuildEventDiskChangeHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackDiskChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                         virNetClientPtr client ATTRIBUTE_UNUSED,
+                                         void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_disk_change_msg *msg = evdata;
+    remoteDomainBuildEventDiskChangeHelper(conn, &msg->msg, msg->callbackID);
+}
+
+
+static void
+remoteDomainBuildEventTrayChangeHelper(virConnectPtr conn,
+                                       remote_domain_event_tray_change_msg *msg,
+                                       int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_tray_change_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4899,17 +5165,33 @@ remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
 static void
-remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                               virNetClientPtr client ATTRIBUTE_UNUSED,
-                               void *evdata, void *opaque)
+remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                 virNetClientPtr client ATTRIBUTE_UNUSED,
+                                 void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_tray_change_msg *msg = evdata;
+    remoteDomainBuildEventTrayChangeHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackTrayChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                         virNetClientPtr client ATTRIBUTE_UNUSED,
+                                         void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_callback_tray_change_msg *msg = evdata;
+    remoteDomainBuildEventTrayChangeHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventPMWakeupHelper(virConnectPtr conn,
+                                     remote_domain_event_pmwakeup_msg *msg,
+                                     int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_pmwakeup_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4921,17 +5203,33 @@ remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
 static void
-remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                                virNetClientPtr client ATTRIBUTE_UNUSED,
-                                void *evdata, void *opaque)
+remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                               virNetClientPtr client ATTRIBUTE_UNUSED,
+                               void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_pmwakeup_msg *msg = evdata;
+    remoteDomainBuildEventPMWakeupHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                       virNetClientPtr client ATTRIBUTE_UNUSED,
+                                       void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_callback_pmwakeup_msg *msg = evdata;
+    remoteDomainBuildEventPMWakeupHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventPMSuspendHelper(virConnectPtr conn,
+                                      remote_domain_event_pmsuspend_msg *msg,
+                                      int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_pmsuspend_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4943,18 +5241,34 @@ remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
+}
+static void
+remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                virNetClientPtr client ATTRIBUTE_UNUSED,
+                                void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_pmsuspend_msg *msg = evdata;
+    remoteDomainBuildEventPMSuspendHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                        virNetClientPtr client ATTRIBUTE_UNUSED,
+                                        void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_pmsuspend_msg *msg = evdata;
+    remoteDomainBuildEventPMSuspendHelper(conn, &msg->msg, msg->callbackID);
 }


 static void
-remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
-                                    virNetClientPtr client ATTRIBUTE_UNUSED,
-                                    void *evdata, void *opaque)
+remoteDomainBuildEventBalloonChangeHelper(virConnectPtr conn,
+                                          remote_domain_event_balloon_change_msg *msg,
+                                          int callbackID)
 {
-    virConnectPtr conn = opaque;
     struct private_data *priv = conn->privateData;
-    remote_domain_event_balloon_change_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4965,18 +5279,34 @@ remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED
     event = virDomainEventBalloonChangeNewFromDom(dom, msg->actual);
     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
-
 static void
-remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
                                     virNetClientPtr client ATTRIBUTE_UNUSED,
                                     void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_balloon_change_msg *msg = evdata;
+    remoteDomainBuildEventBalloonChangeHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackBalloonChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
+                                            virNetClientPtr client ATTRIBUTE_UNUSED,
+                                            void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_balloon_change_msg *msg = evdata;
+    remoteDomainBuildEventBalloonChangeHelper(conn, &msg->msg,
msg->callbackID);
+}
+
+
+static void
+remoteDomainBuildEventPMSuspendDiskHelper(virConnectPtr conn,
+                                          remote_domain_event_pmsuspend_disk_msg *msg,
+                                          int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_pmsuspend_disk_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -4988,18 +5318,34 @@ remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
 }
-
-
 static void
-remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
                                     virNetClientPtr client ATTRIBUTE_UNUSED,
                                     void *evdata, void *opaque)
 {
     virConnectPtr conn = opaque;
+    remote_domain_event_pmsuspend_disk_msg *msg = evdata;
+    remoteDomainBuildEventPMSuspendDiskHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
+                                            virNetClientPtr client ATTRIBUTE_UNUSED,
+                                            void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_pmsuspend_disk_msg *msg = evdata;
+    remoteDomainBuildEventPMSuspendDiskHelper(conn, &msg->msg,
msg->callbackID);
+}
+
+
+static void
+remoteDomainBuildEventDeviceRemovedHelper(virConnectPtr conn,
+                                          remote_domain_event_device_removed_msg *msg,
+                                          int callbackID)
+{
     struct private_data *priv = conn->privateData;
-    remote_domain_event_device_removed_msg *msg = evdata;
     virDomainPtr dom;
     virObjectEventPtr event = NULL;

@@ -5011,7 +5357,25 @@ remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED

     virDomainFree(dom);

-    remoteEventQueue(priv, event, -1);
+    remoteEventQueue(priv, event, callbackID);
+}
+static void
+remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                    virNetClientPtr client ATTRIBUTE_UNUSED,
+                                    void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_device_removed_msg *msg = evdata;
+    remoteDomainBuildEventDeviceRemovedHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackDeviceRemoved(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
+                                            virNetClientPtr client ATTRIBUTE_UNUSED,
+                                            void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_device_removed_msg *msg = evdata;
+    remoteDomainBuildEventDeviceRemovedHelper(conn, &msg->msg,
msg->callbackID);
 }


@@ -5341,25 +5705,20 @@ remoteConnectDomainEventRegisterAny(virConnectPtr conn,
     int callbackID;
     int count;
     remote_nonnull_domain domain;
-    bool serverFilter;

     remoteDriverLock(priv);

-    serverFilter = priv->serverEventFilter;
-    /* FIXME support more than just lifecycle events */
-    serverFilter &= eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE;
-
     if ((count = virDomainEventStateRegisterClient(conn, priv->eventState,
                                                    dom, eventID, callback,
                                                    opaque, freecb, false,
                                                    &callbackID,
-                                                   serverFilter)) < 0)
+                                                   priv->serverEventFilter)) < 0)
         goto done;

     /* If this is the first callback for this eventID, we need to enable
      * events on the server */
     if (count == 1) {
-        if (serverFilter) {
+        if (priv->serverEventFilter) {
             remote_connect_domain_event_callback_register_any_args args;
             remote_connect_domain_event_callback_register_any_ret ret;

@@ -5426,10 +5785,8 @@ remoteConnectDomainEventDeregisterAny(virConnectPtr conn,

     /* If that was the last callback for this eventID, we need to disable
      * events on the server */
-    /* FIXME support more than just lifecycle events */
     if (count == 0) {
-        if (priv->serverEventFilter &&
-            eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE) {
+        if (priv->serverEventFilter) {
             remote_connect_domain_event_callback_deregister_any_args args;

             args.callbackID = remoteID;
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 982ab1f..8238405 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -2268,16 +2268,28 @@ struct remote_connect_domain_event_callback_deregister_any_args {
 struct remote_domain_event_reboot_msg {
     remote_nonnull_domain dom;
 };
+struct remote_domain_event_callback_reboot_msg {
+    int callbackID;
+    remote_domain_event_reboot_msg msg;
+};

 struct remote_domain_event_rtc_change_msg {
     remote_nonnull_domain dom;
     hyper offset;
 };
+struct remote_domain_event_callback_rtc_change_msg {
+    int callbackID;
+    remote_domain_event_rtc_change_msg msg;
+};

 struct remote_domain_event_watchdog_msg {
     remote_nonnull_domain dom;
     int action;
 };
+struct remote_domain_event_callback_watchdog_msg {
+    int callbackID;
+    remote_domain_event_watchdog_msg msg;
+};

 struct remote_domain_event_io_error_msg {
     remote_nonnull_domain dom;
@@ -2285,6 +2297,10 @@ struct remote_domain_event_io_error_msg {
     remote_nonnull_string devAlias;
     int action;
 };
+struct remote_domain_event_callback_io_error_msg {
+    int callbackID;
+    remote_domain_event_io_error_msg msg;
+};

 struct remote_domain_event_io_error_reason_msg {
     remote_nonnull_domain dom;
@@ -2293,6 +2309,10 @@ struct remote_domain_event_io_error_reason_msg {
     int action;
     remote_nonnull_string reason;
 };
+struct remote_domain_event_callback_io_error_reason_msg {
+    int callbackID;
+    remote_domain_event_io_error_reason_msg msg;
+};

 struct remote_domain_event_graphics_address {
     int family;
@@ -2315,6 +2335,10 @@ struct remote_domain_event_graphics_msg {
     remote_nonnull_string authScheme;
     remote_domain_event_graphics_identity
subject<REMOTE_DOMAIN_EVENT_GRAPHICS_IDENTITY_MAX>;
 };
+struct remote_domain_event_callback_graphics_msg {
+    int callbackID;
+    remote_domain_event_graphics_msg msg;
+};

 struct remote_domain_event_block_job_msg {
     remote_nonnull_domain dom;
@@ -2322,6 +2346,10 @@ struct remote_domain_event_block_job_msg {
     int type;
     int status;
 };
+struct remote_domain_event_callback_block_job_msg {
+    int callbackID;
+    remote_domain_event_block_job_msg msg;
+};

 struct remote_domain_event_disk_change_msg {
     remote_nonnull_domain dom;
@@ -2330,29 +2358,53 @@ struct remote_domain_event_disk_change_msg {
     remote_nonnull_string devAlias;
     int reason;
 };
+struct remote_domain_event_callback_disk_change_msg {
+    int callbackID;
+    remote_domain_event_disk_change_msg msg;
+};

 struct remote_domain_event_tray_change_msg {
     remote_nonnull_domain dom;
     remote_nonnull_string devAlias;
     int reason;
 };
+struct remote_domain_event_callback_tray_change_msg {
+    int callbackID;
+    remote_domain_event_tray_change_msg msg;
+};

 struct remote_domain_event_pmwakeup_msg {
     remote_nonnull_domain dom;
 };
+struct remote_domain_event_callback_pmwakeup_msg {
+    int callbackID;
+    remote_domain_event_pmwakeup_msg msg;
+};

 struct remote_domain_event_pmsuspend_msg {
     remote_nonnull_domain dom;
 };
+struct remote_domain_event_callback_pmsuspend_msg {
+    int callbackID;
+    remote_domain_event_pmsuspend_msg msg;
+};

 struct remote_domain_event_balloon_change_msg {
     remote_nonnull_domain dom;
     unsigned hyper actual;
 };
+struct remote_domain_event_callback_balloon_change_msg {
+    int callbackID;
+    remote_domain_event_balloon_change_msg msg;
+};

 struct remote_domain_event_pmsuspend_disk_msg {
     remote_nonnull_domain dom;
 };
+struct remote_domain_event_callback_pmsuspend_disk_msg {
+    int callbackID;
+    remote_domain_event_pmsuspend_disk_msg msg;
+};

 struct remote_domain_managed_save_args {
     remote_nonnull_domain dom;
@@ -2631,6 +2683,10 @@ struct remote_domain_migrate_confirm3_args {
 struct remote_domain_event_control_error_msg {
     remote_nonnull_domain dom;
 };
+struct remote_domain_event_callback_control_error_msg {
+    int callbackID;
+    remote_domain_event_control_error_msg msg;
+};

 struct remote_domain_get_control_info_args {
     remote_nonnull_domain dom;
@@ -2850,10 +2906,17 @@ struct remote_domain_migrate_confirm3_params_args {
     int cancelled;
 };

+/* The device removed event is the last event where we have to support
+ * dual forms for back-compat to older clients; all future events can
+ * use just the modern form with callbackID.  */
 struct remote_domain_event_device_removed_msg {
     remote_nonnull_domain dom;
     remote_nonnull_string devAlias;
 };
+struct remote_domain_event_callback_device_removed_msg {
+    int callbackID;
+    remote_domain_event_device_removed_msg msg;
+};

 struct remote_connect_get_cpu_model_names_args {
     remote_nonnull_string arch;
@@ -5105,5 +5168,95 @@ enum remote_procedure {
      * @generate: both
      * @acl: none
      */
-    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE = 318
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE = 318,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT = 319,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE = 320,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG = 321,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR = 322,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS = 323,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON = 324,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR = 325,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB = 326,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE = 327,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE = 328,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP = 329,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND = 330,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE = 331,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK = 332,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED = 333
 };
diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
index 39d3981..fdff787 100644
--- a/src/remote_protocol-structs
+++ b/src/remote_protocol-structs
@@ -1724,20 +1724,36 @@ struct remote_connect_domain_event_callback_deregister_any_args {
 struct remote_domain_event_reboot_msg {
         remote_nonnull_domain      dom;
 };
+struct remote_domain_event_callback_reboot_msg {
+        int                        callbackID;
+        remote_domain_event_reboot_msg msg;
+};
 struct remote_domain_event_rtc_change_msg {
         remote_nonnull_domain      dom;
         int64_t                    offset;
 };
+struct remote_domain_event_callback_rtc_change_msg {
+        int                        callbackID;
+        remote_domain_event_rtc_change_msg msg;
+};
 struct remote_domain_event_watchdog_msg {
         remote_nonnull_domain      dom;
         int                        action;
 };
+struct remote_domain_event_callback_watchdog_msg {
+        int                        callbackID;
+        remote_domain_event_watchdog_msg msg;
+};
 struct remote_domain_event_io_error_msg {
         remote_nonnull_domain      dom;
         remote_nonnull_string      srcPath;
         remote_nonnull_string      devAlias;
         int                        action;
 };
+struct remote_domain_event_callback_io_error_msg {
+        int                        callbackID;
+        remote_domain_event_io_error_msg msg;
+};
 struct remote_domain_event_io_error_reason_msg {
         remote_nonnull_domain      dom;
         remote_nonnull_string      srcPath;
@@ -1745,6 +1761,10 @@ struct remote_domain_event_io_error_reason_msg {
         int                        action;
         remote_nonnull_string      reason;
 };
+struct remote_domain_event_callback_io_error_reason_msg {
+        int                        callbackID;
+        remote_domain_event_io_error_reason_msg msg;
+};
 struct remote_domain_event_graphics_address {
         int                        family;
         remote_nonnull_string      node;
@@ -1765,12 +1785,20 @@ struct remote_domain_event_graphics_msg {
                 remote_domain_event_graphics_identity * subject_val;
         } subject;
 };
+struct remote_domain_event_callback_graphics_msg {
+        int                        callbackID;
+        remote_domain_event_graphics_msg msg;
+};
 struct remote_domain_event_block_job_msg {
         remote_nonnull_domain      dom;
         remote_nonnull_string      path;
         int                        type;
         int                        status;
 };
+struct remote_domain_event_callback_block_job_msg {
+        int                        callbackID;
+        remote_domain_event_block_job_msg msg;
+};
 struct remote_domain_event_disk_change_msg {
         remote_nonnull_domain      dom;
         remote_string              oldSrcPath;
@@ -1778,24 +1806,48 @@ struct remote_domain_event_disk_change_msg {
         remote_nonnull_string      devAlias;
         int                        reason;
 };
+struct remote_domain_event_callback_disk_change_msg {
+        int                        callbackID;
+        remote_domain_event_disk_change_msg msg;
+};
 struct remote_domain_event_tray_change_msg {
         remote_nonnull_domain      dom;
         remote_nonnull_string      devAlias;
         int                        reason;
 };
+struct remote_domain_event_callback_tray_change_msg {
+        int                        callbackID;
+        remote_domain_event_tray_change_msg msg;
+};
 struct remote_domain_event_pmwakeup_msg {
         remote_nonnull_domain      dom;
 };
+struct remote_domain_event_callback_pmwakeup_msg {
+        int                        callbackID;
+        remote_domain_event_pmwakeup_msg msg;
+};
 struct remote_domain_event_pmsuspend_msg {
         remote_nonnull_domain      dom;
 };
+struct remote_domain_event_callback_pmsuspend_msg {
+        int                        callbackID;
+        remote_domain_event_pmsuspend_msg msg;
+};
 struct remote_domain_event_balloon_change_msg {
         remote_nonnull_domain      dom;
         uint64_t                   actual;
 };
+struct remote_domain_event_callback_balloon_change_msg {
+        int                        callbackID;
+        remote_domain_event_balloon_change_msg msg;
+};
 struct remote_domain_event_pmsuspend_disk_msg {
         remote_nonnull_domain      dom;
 };
+struct remote_domain_event_callback_pmsuspend_disk_msg {
+        int                        callbackID;
+        remote_domain_event_pmsuspend_disk_msg msg;
+};
 struct remote_domain_managed_save_args {
         remote_nonnull_domain      dom;
         u_int                      flags;
@@ -2064,6 +2116,10 @@ struct remote_domain_migrate_confirm3_args {
 struct remote_domain_event_control_error_msg {
         remote_nonnull_domain      dom;
 };
+struct remote_domain_event_callback_control_error_msg {
+        int                        callbackID;
+        remote_domain_event_control_error_msg msg;
+};
 struct remote_domain_get_control_info_args {
         remote_nonnull_domain      dom;
         u_int                      flags;
@@ -2330,6 +2386,10 @@ struct remote_domain_event_device_removed_msg {
         remote_nonnull_domain      dom;
         remote_nonnull_string      devAlias;
 };
+struct remote_domain_event_callback_device_removed_msg {
+        int                        callbackID;
+        remote_domain_event_device_removed_msg msg;
+};
 struct remote_connect_get_cpu_model_names_args {
         remote_nonnull_string      arch;
         int                        need_results;
@@ -2677,4 +2737,19 @@ enum remote_procedure {
         REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY = 316,
         REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY = 317,
         REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE = 318,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT = 319,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE = 320,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG = 321,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR = 322,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS = 323,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON = 324,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR = 325,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB = 326,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE = 327,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE = 328,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP = 329,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND = 330,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE = 331,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK = 332,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED = 333,
 };
-- 
1.8.5.3


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

[libvirt] [PATCHv2 5/6] event: convert remaining domain events to new style