Hide use of timers for domain event dispatch

Currently all drivers using domain events need to provide a callback
for handling a timer to dispatch events in a clean stack. There is
no technical reason for dispatch to go via driver specific code. It
could trivially be dispatched directly from the domain event code,
thus removing tedious boilerplate code from all drivers

Also fix the libxl & xen drivers to pass 'true' when creating the
virDomainEventState, since they run inside the daemon & thus always
expect events to be present.

* src/conf/domain_event.c, src/conf/domain_event.h: Internalize
  dispatch of events from timer callback
* src/libxl/libxl_driver.c, src/lxc/lxc_driver.c,
  src/qemu/qemu_domain.c, src/qemu/qemu_driver.c,
  src/remote/remote_driver.c, src/test/test_driver.c,
  src/uml/uml_driver.c, src/vbox/vbox_tmpl.c,
  src/xen/xen_driver.c: Remove all timer dispatch functions

diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c
index c49d9074624971b3188aff8fcb68a3a0d3ca299c..44fdf787d983add12cd2b5d623b0b492c74726c7 100644 (file)
--- a/src/conf/domain_event.c
+++ b/src/conf/domain_event.c
@@ -619,21 +619,26 @@ virDomainEventStateFree(virDomainEventStatePtr state)
     VIR_FREE(state);
 }
 
+
+static void virDomainEventStateFlush(virDomainEventStatePtr state);
+
+static void
+virDomainEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque)
+{
+    virDomainEventStatePtr state = opaque;
+
+    virDomainEventStateFlush(state);
+}
+
 /**
  * virDomainEventStateNew:
- * @timeout_cb: virEventTimeoutCallback to call when timer expires
- * @timeout_opaque: Data for timeout_cb
- * @timeout_free: Optional virFreeCallback for freeing timeout_opaque
  * @requireTimer: If true, return an error if registering the timer fails.
  *                This is fatal for drivers that sit behind the daemon
  *                (qemu, lxc), since there should always be a event impl
  *                registered.
  */
 virDomainEventStatePtr
-virDomainEventStateNew(virEventTimeoutCallback timeout_cb,
-                       void *timeout_opaque,
-                       virFreeCallback timeout_free,
-                       bool requireTimer)
+virDomainEventStateNew(bool requireTimer)
 {
     virDomainEventStatePtr state = NULL;
 
@@ -659,9 +664,9 @@ virDomainEventStateNew(virEventTimeoutCallback timeout_cb,
     }
 
     if ((state->timer = virEventAddTimeout(-1,
-                                           timeout_cb,
-                                           timeout_opaque,
-                                           timeout_free)) < 0) {
+                                           virDomainEventTimer,
+                                           state,
+                                           NULL)) < 0) {
         if (requireTimer == false) {
             VIR_DEBUG("virEventAddTimeout failed: No addTimeoutImpl defined. "
                       "continuing without events.");
@@ -1086,11 +1091,19 @@ virDomainEventQueuePush(virDomainEventQueuePtr evtQueue,
 }
 
 
-void virDomainEventDispatchDefaultFunc(virConnectPtr conn,
-                                       virDomainEventPtr event,
-                                       virConnectDomainEventGenericCallback cb,
-                                       void *cbopaque,
-                                       void *opaque ATTRIBUTE_UNUSED)
+typedef void (*virDomainEventDispatchFunc)(virConnectPtr conn,
+                                           virDomainEventPtr event,
+                                           virConnectDomainEventGenericCallback cb,
+                                           void *cbopaque,
+                                           void *opaque);
+
+
+static void
+virDomainEventDispatchDefaultFunc(virConnectPtr conn,
+                                  virDomainEventPtr event,
+                                  virConnectDomainEventGenericCallback cb,
+                                  void *cbopaque,
+                                  void *opaque ATTRIBUTE_UNUSED)
 {
     virDomainPtr dom = virGetDomain(conn, event->dom.name, event->dom.uuid);
     if (!dom)
@@ -1206,10 +1219,12 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event,
     }
 }
 
-void virDomainEventDispatch(virDomainEventPtr event,
-                            virDomainEventCallbackListPtr callbacks,
-                            virDomainEventDispatchFunc dispatch,
-                            void *opaque)
+
+static void
+virDomainEventDispatch(virDomainEventPtr event,
+                       virDomainEventCallbackListPtr callbacks,
+                       virDomainEventDispatchFunc dispatch,
+                       void *opaque)
 {
     int i;
     /* Cache this now, since we may be dropping the lock,
@@ -1230,10 +1245,11 @@ void virDomainEventDispatch(virDomainEventPtr event,
 }
 
 
-void virDomainEventQueueDispatch(virDomainEventQueuePtr queue,
-                                 virDomainEventCallbackListPtr callbacks,
-                                 virDomainEventDispatchFunc dispatch,
-                                 void *opaque)
+static void
+virDomainEventQueueDispatch(virDomainEventQueuePtr queue,
+                            virDomainEventCallbackListPtr callbacks,
+                            virDomainEventDispatchFunc dispatch,
+                            void *opaque)
 {
     int i;
 
@@ -1266,10 +1282,25 @@ virDomainEventStateQueue(virDomainEventStatePtr state,
     virDomainEventStateUnlock(state);
 }
 
-void
-virDomainEventStateFlush(virDomainEventStatePtr state,
-                         virDomainEventDispatchFunc dispatchFunc,
-                         void *opaque)
+
+static void
+virDomainEventStateDispatchFunc(virConnectPtr conn,
+                                virDomainEventPtr event,
+                                virConnectDomainEventGenericCallback cb,
+                                void *cbopaque,
+                                void *opaque)
+{
+    virDomainEventStatePtr state = opaque;
+
+    /* Drop the lock whle dispatching, for sake of re-entrancy */
+    virDomainEventStateUnlock(state);
+    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
+    virDomainEventStateLock(state);
+}
+
+
+static void
+virDomainEventStateFlush(virDomainEventStatePtr state)
 {
     virDomainEventQueue tempQueue;
 
@@ -1287,8 +1318,8 @@ virDomainEventStateFlush(virDomainEventStatePtr state,
 
     virDomainEventQueueDispatch(&tempQueue,
                                 state->callbacks,
-                                dispatchFunc,
-                                opaque);
+                                virDomainEventStateDispatchFunc,
+                                state);
 
     /* Purge any deleted callbacks */
     virDomainEventStateLock(state);
@@ -1312,11 +1343,12 @@ virDomainEventStateFlush(virDomainEventStatePtr state,
  *
  * Returns: the number of lifecycle callbacks now registered, or -1 on error
  */
-int virDomainEventStateRegister(virConnectPtr conn,
-                                virDomainEventStatePtr state,
-                                virConnectDomainEventCallback callback,
-                                void *opaque,
-                                virFreeCallback freecb)
+int
+virDomainEventStateRegister(virConnectPtr conn,
+                            virDomainEventStatePtr state,
+                            virConnectDomainEventCallback callback,
+                            void *opaque,
+                            virFreeCallback freecb)
 {
     int ret;
     virDomainEventStateLock(state);
@@ -1342,14 +1374,15 @@ int virDomainEventStateRegister(virConnectPtr conn,
  *
  * Returns: the number of callbacks now registered, or -1 on error
  */
-int virDomainEventStateRegisterID(virConnectPtr conn,
-                                  virDomainEventStatePtr state,
-                                  virDomainPtr dom,
-                                  int eventID,
-                                  virConnectDomainEventGenericCallback cb,
-                                  void *opaque,
-                                  virFreeCallback freecb,
-                                  int *callbackID)
+int
+virDomainEventStateRegisterID(virConnectPtr conn,
+                              virDomainEventStatePtr state,
+                              virDomainPtr dom,
+                              int eventID,
+                              virConnectDomainEventGenericCallback cb,
+                              void *opaque,
+                              virFreeCallback freecb,
+                              int *callbackID)
 {
     int ret;
     virDomainEventStateLock(state);

diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h
index f37309ce7959c84e606250858e2cdc52d560e2de..a6c3562ba99220a40772602c151151a7f4eae255 100644 (file)
--- a/src/conf/domain_event.h
+++ b/src/conf/domain_event.h
@@ -119,42 +119,12 @@ void virDomainEventFree(virDomainEventPtr event);
 
 void virDomainEventStateFree(virDomainEventStatePtr state);
 virDomainEventStatePtr
-virDomainEventStateNew(virEventTimeoutCallback timeout_cb,
-                       void *timeout_opaque,
-                       virFreeCallback timeout_free,
-                       bool requireTimer)
-    ATTRIBUTE_NONNULL(1);
-
-typedef void (*virDomainEventDispatchFunc)(virConnectPtr conn,
-                                           virDomainEventPtr event,
-                                           virConnectDomainEventGenericCallback cb,
-                                           void *cbopaque,
-                                           void *opaque);
-void virDomainEventDispatchDefaultFunc(virConnectPtr conn,
-                                       virDomainEventPtr event,
-                                       virConnectDomainEventGenericCallback cb,
-                                       void *cbopaque,
-                                       void *opaque);
-
-void virDomainEventDispatch(virDomainEventPtr event,
-                            virDomainEventCallbackListPtr cbs,
-                            virDomainEventDispatchFunc dispatch,
-                            void *opaque);
-void virDomainEventQueueDispatch(virDomainEventQueuePtr queue,
-                                 virDomainEventCallbackListPtr cbs,
-                                 virDomainEventDispatchFunc dispatch,
-                                 void *opaque);
-
+virDomainEventStateNew(bool requireTimer);
 
 void
 virDomainEventStateQueue(virDomainEventStatePtr state,
                          virDomainEventPtr event)
     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void
-virDomainEventStateFlush(virDomainEventStatePtr state,
-                         virDomainEventDispatchFunc dispatchFunc,
-                         void *opaque)
-    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
 int virDomainEventStateRegister(virConnectPtr conn,
                                 virDomainEventStatePtr state,
                                 virConnectDomainEventCallback callback,

diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index a5e6b59a7f56fd4d62a8d8564b834e2d744b6697..a649054cc044dcf05a8e1b99304f8376bd5e5f20 100644 (file)
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -475,8 +475,6 @@ virDomainEventControlErrorNewFromDom;
 virDomainEventControlErrorNewFromObj;
 virDomainEventDiskChangeNewFromDom;
 virDomainEventDiskChangeNewFromObj;
-virDomainEventDispatch;
-virDomainEventDispatchDefaultFunc;
 virDomainEventFree;
 virDomainEventGraphicsNewFromDom;
 virDomainEventGraphicsNewFromObj;
@@ -499,7 +497,6 @@ virDomainEventStateDeregisterConn;
 virDomainEventStateEventID;
 virDomainEventStateRegister;
 virDomainEventStateRegisterID;
-virDomainEventStateFlush;
 virDomainEventStateFree;
 virDomainEventStateNew;
 virDomainEventStateQueue;

diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c
index b9382ee70212108bd8c0fde9ed09adf16d30209b..04392da981a5d6b0905c0530b52e612c87c5afd4 100644 (file)
--- a/src/libxl/libxl_driver.c
+++ b/src/libxl/libxl_driver.c
@@ -111,30 +111,6 @@ libxlDomainObjPrivateFree(void *data)
     VIR_FREE(priv);
 }
 
-static void
-libxlDomainEventDispatchFunc(virConnectPtr conn, virDomainEventPtr event,
-                             virConnectDomainEventGenericCallback cb,
-                             void *cbopaque, void *opaque)
-{
-    libxlDriverPrivatePtr driver = opaque;
-
-    /* Drop the lock whle dispatching, for sake of re-entrancy */
-    libxlDriverUnlock(driver);
-    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
-    libxlDriverLock(driver);
-}
-
-static void
-libxlDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    libxlDriverPrivatePtr driver = opaque;
-
-    libxlDriverLock(driver);
-    virDomainEventStateFlush(driver->domainEventState,
-                             libxlDomainEventDispatchFunc,
-                             driver);
-    libxlDriverUnlock(driver);
-}
 
 /* driver must be locked before calling */
 static void
@@ -952,11 +928,7 @@ libxlStartup(int privileged) {
     }
     VIR_FREE(log_file);
 
-    libxl_driver->domainEventState = virDomainEventStateNew(
-                                                        libxlDomainEventFlush,
-                                                        libxl_driver,
-                                                        NULL,
-                                                        false);
+    libxl_driver->domainEventState = virDomainEventStateNew(true);
     if (!libxl_driver->domainEventState)
         goto error;
 

diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c
index 6a9ebde823361049a9078ae23b81174438abf63f..6d32ed2ed4afe2c705c24608af1e9a98a825772b 100644 (file)
--- a/src/lxc/lxc_driver.c
+++ b/src/lxc/lxc_driver.c
@@ -109,7 +109,6 @@ static void lxcDomainObjPrivateFree(void *data)
 }
 
 
-static void lxcDomainEventFlush(int timer, void *opaque);
 static void lxcDomainEventQueue(lxc_driver_t *driver,
                                 virDomainEventPtr event);
 
@@ -2192,33 +2191,6 @@ lxcDomainEventDeregisterAny(virConnectPtr conn,
 }
 
 
-static void lxcDomainEventDispatchFunc(virConnectPtr conn,
-                                       virDomainEventPtr event,
-                                       virConnectDomainEventGenericCallback cb,
-                                       void *cbopaque,
-                                       void *opaque)
-{
-    lxc_driver_t *driver = opaque;
-
-    /* Drop the lock whle dispatching, for sake of re-entrancy */
-    lxcDriverUnlock(driver);
-    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
-    lxcDriverLock(driver);
-}
-
-
-static void lxcDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    lxc_driver_t *driver = opaque;
-
-    lxcDriverLock(driver);
-    virDomainEventStateFlush(driver->domainEventState,
-                             lxcDomainEventDispatchFunc,
-                             driver);
-    lxcDriverUnlock(driver);
-}
-
-
 /* driver must be locked before calling */
 static void lxcDomainEventQueue(lxc_driver_t *driver,
                                  virDomainEventPtr event)
@@ -2446,10 +2418,7 @@ static int lxcStartup(int privileged)
     if (virDomainObjListInit(&lxc_driver->domains) < 0)
         goto cleanup;
 
-    lxc_driver->domainEventState = virDomainEventStateNew(lxcDomainEventFlush,
-                                                          lxc_driver,
-                                                          NULL,
-                                                          true);
+    lxc_driver->domainEventState = virDomainEventStateNew(true);
     if (!lxc_driver->domainEventState)
         goto cleanup;
 

diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index b28c734ce77bed976b4fc8473b9278d9bafce445..2d612fe40dc140a40eca2074a637b40472d6532b 100644 (file)
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -114,31 +114,6 @@ qemuDomainAsyncJobPhaseFromString(enum qemuDomainAsyncJob job,
         return -1;
 }
 
-static void qemuDomainEventDispatchFunc(virConnectPtr conn,
-                                        virDomainEventPtr event,
-                                        virConnectDomainEventGenericCallback cb,
-                                        void *cbopaque,
-                                        void *opaque)
-{
-    struct qemud_driver *driver = opaque;
-
-    /* Drop the lock whle dispatching, for sake of re-entrancy */
-    qemuDriverUnlock(driver);
-    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
-    qemuDriverLock(driver);
-}
-
-void qemuDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    struct qemud_driver *driver = opaque;
-
-    qemuDriverLock(driver);
-    virDomainEventStateFlush(driver->domainEventState,
-                             qemuDomainEventDispatchFunc,
-                             driver);
-    qemuDriverUnlock(driver);
-}
-
 
 /* driver must be locked before calling */
 void qemuDomainEventQueue(struct qemud_driver *driver,

diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 662fd6d30d04602f5ad8bce9f28d0d6dfc76020e..36c61d7f241c87e0b5ffb1ee5a139e3775bcfb0d 100644 (file)
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -431,10 +431,7 @@ qemudStartup(int privileged) {
         goto out_of_memory;
 
     /* Init domain events */
-    qemu_driver->domainEventState = virDomainEventStateNew(qemuDomainEventFlush,
-                                                           qemu_driver,
-                                                           NULL,
-                                                           true);
+    qemu_driver->domainEventState = virDomainEventStateNew(true);
     if (!qemu_driver->domainEventState)
         goto error;
 

diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 84a371057c904e1bdfe2ef7d9a61e91f0315b0e1..3c0510b344d19bd99173294229b895ba1fa1b52d 100644 (file)
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -145,7 +145,6 @@ static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virSt
 static void make_nonnull_secret (remote_nonnull_secret *secret_dst, virSecretPtr secret_src);
 static void make_nonnull_nwfilter (remote_nonnull_nwfilter *nwfilter_dst, virNWFilterPtr nwfilter_src);
 static void make_nonnull_domain_snapshot (remote_nonnull_domain_snapshot *snapshot_dst, virDomainSnapshotPtr snapshot_src);
-static void remoteDomainEventQueueFlush(int timer, void *opaque);
 static void remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event);
 /*----------------------------------------------------------------------*/
 
@@ -727,10 +726,7 @@ doRemoteOpen (virConnectPtr conn,
         }
     }
 
-    if (!(priv->domainEventState = virDomainEventStateNew(remoteDomainEventQueueFlush,
-                                                          conn,
-                                                          NULL,
-                                                          false)))
+    if (!(priv->domainEventState = virDomainEventStateNew(false)))
         goto failed;
 
     /* Successful. */
@@ -4352,37 +4348,6 @@ call (virConnectPtr conn,
 }
 
 
-static void remoteDomainEventDispatchFunc(virConnectPtr conn,
-                                          virDomainEventPtr event,
-                                          virConnectDomainEventGenericCallback cb,
-                                          void *cbopaque,
-                                          void *opaque)
-{
-    struct private_data *priv = opaque;
-
-    /* Drop the lock whle dispatching, for sake of re-entrancy */
-    remoteDriverUnlock(priv);
-    VIR_DEBUG("Dispatch event %p %p", event, conn);
-    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
-    remoteDriverLock(priv);
-}
-
-static void
-remoteDomainEventQueueFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    virConnectPtr conn = opaque;
-    struct private_data *priv = conn->privateData;
-
-
-    remoteDriverLock(priv);
-    VIR_DEBUG("Event queue flush %p", conn);
-
-    virDomainEventStateFlush(priv->domainEventState,
-                             remoteDomainEventDispatchFunc,
-                             priv);
-    remoteDriverUnlock(priv);
-}
-
 static void
 remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event)
 {

diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 1c5bd8462cda950ef407a6a1b8f684febb0c1c18..33750b5a15086dd50c81687033176020130c95d8 100644 (file)
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -117,7 +117,6 @@ static const virNodeInfo defaultNodeInfo = {
                              __FUNCTION__, __LINE__, __VA_ARGS__)
 
 static int testClose(virConnectPtr conn);
-static void testDomainEventFlush(int timer, void *opaque);
 static void testDomainEventQueue(testConnPtr driver,
                                  virDomainEventPtr event);
 
@@ -1138,10 +1137,7 @@ static virDrvOpenStatus testOpen(virConnectPtr conn,
     privconn = conn->privateData;
     testDriverLock(privconn);
 
-    privconn->domainEventState = virDomainEventStateNew(testDomainEventFlush,
-                                                        privconn,
-                                                        NULL,
-                                                        false);
+    privconn->domainEventState = virDomainEventStateNew(false);
     if (!privconn->domainEventState) {
         testDriverUnlock(privconn);
         testClose(conn);
@@ -5469,32 +5465,6 @@ testDomainEventDeregisterAny(virConnectPtr conn,
 }
 
 
-static void testDomainEventDispatchFunc(virConnectPtr conn,
-                                        virDomainEventPtr event,
-                                        virConnectDomainEventGenericCallback cb,
-                                        void *cbopaque,
-                                        void *opaque)
-{
-    testConnPtr driver = opaque;
-
-    /* Drop the lock whle dispatching, for sake of re-entrancy */
-    testDriverUnlock(driver);
-    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
-    testDriverLock(driver);
-}
-
-static void testDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    testConnPtr driver = opaque;
-
-    testDriverLock(driver);
-    virDomainEventStateFlush(driver->domainEventState,
-                             testDomainEventDispatchFunc,
-                             driver);
-    testDriverUnlock(driver);
-}
-
-
 /* driver must be locked before calling */
 static void testDomainEventQueue(testConnPtr driver,
                                  virDomainEventPtr event)

diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c
index 4d875c8e35b9aed95aeee1a2ab3c90b0dc4ea87f..360f0ce4b9f1b8b4d716b77e5550b1e17d440591 100644 (file)
--- a/src/uml/uml_driver.c
+++ b/src/uml/uml_driver.c
@@ -124,7 +124,6 @@ static int umlOpenMonitor(struct uml_driver *driver,
                           virDomainObjPtr vm);
 static int umlReadPidFile(struct uml_driver *driver,
                           virDomainObjPtr vm);
-static void umlDomainEventFlush(int timer, void *opaque);
 static void umlDomainEventQueue(struct uml_driver *driver,
                                 virDomainEventPtr event);
 
@@ -414,10 +413,7 @@ umlStartup(int privileged)
     if (virDomainObjListInit(&uml_driver->domains) < 0)
         goto error;
 
-    uml_driver->domainEventState = virDomainEventStateNew(umlDomainEventFlush,
-                                                          uml_driver,
-                                                          NULL,
-                                                          true);
+    uml_driver->domainEventState = virDomainEventStateNew(true);
     if (!uml_driver->domainEventState)
         goto error;
 
@@ -2511,33 +2507,6 @@ umlDomainEventDeregisterAny(virConnectPtr conn,
 }
 
 
-static void umlDomainEventDispatchFunc(virConnectPtr conn,
-                                       virDomainEventPtr event,
-                                       virConnectDomainEventGenericCallback cb,
-                                       void *cbopaque,
-                                       void *opaque)
-{
-    struct uml_driver *driver = opaque;
-
-    /* Drop the lock whle dispatching, for sake of re-entrancy */
-    umlDriverUnlock(driver);
-    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
-    umlDriverLock(driver);
-}
-
-
-static void umlDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    struct uml_driver *driver = opaque;
-
-    umlDriverLock(driver);
-    virDomainEventStateFlush(driver->domainEventState,
-                             umlDomainEventDispatchFunc,
-                             driver);
-    umlDriverUnlock(driver);
-}
-
-
 /* driver must be locked before calling */
 static void umlDomainEventQueue(struct uml_driver *driver,
                                 virDomainEventPtr event)

diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index 1c6456fc4418fdb29a3423704abd77f5a70dcaac..3b02d5ab0db718c9738d81fa313eaee79efb0e2e 100644 (file)
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -970,46 +970,6 @@ static void vboxUninitialize(vboxGlobalData *data) {
 }
 
 
-#if VBOX_API_VERSION == 2002
-    /* No domainEventCallbacks in 2.2.* version */
-#else  /* !(VBOX_API_VERSION == 2002) */
-
-static void
-vboxDomainEventDispatchFunc(virConnectPtr conn,
-                            virDomainEventPtr event,
-                            virConnectDomainEventGenericCallback cb,
-                            void *cbopaque,
-                            void *opaque)
-{
-    vboxGlobalData *data = opaque;
-
-    /*
-     * Release the lock while the callback is running so that
-     * we're re-entrant safe for callback work - the callback
-     * may want to invoke other virt functions & we have already
-     * protected the one piece of state we have - the callback
-     * list
-     */
-    vboxDriverUnlock(data);
-    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
-    vboxDriverLock(data);
-}
-
-
-static void vboxDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    virConnectPtr conn = opaque;
-    vboxGlobalData *data = conn->privateData;
-
-    vboxDriverLock(data);
-    virDomainEventStateFlush(data->domainEvents,
-                             vboxDomainEventDispatchFunc,
-                             data);
-    vboxDriverUnlock(data);
-}
-#endif /* !(VBOX_API_VERSION == 2002) */
-
-
 static virDrvOpenStatus vboxOpen(virConnectPtr conn,
                                  virConnectAuthPtr auth ATTRIBUTE_UNUSED,
                                  unsigned int flags)
@@ -1074,10 +1034,7 @@ static virDrvOpenStatus vboxOpen(virConnectPtr conn,
 
 #else  /* !(VBOX_API_VERSION == 2002) */
 
-    if (!(data->domainEvents = virDomainEventStateNew(vboxDomainEventFlush,
-                                                      data,
-                                                      NULL,
-                                                      true))) {
+    if (!(data->domainEvents = virDomainEventStateNew(true))) {
         vboxUninitialize(data);
         return VIR_DRV_OPEN_ERROR;
     }

diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c
index 2fc0c2882d835199cc3f7150adeba55d0c8ba04f..ab49c2b34ac7c0190ea65c63bee8be44e6767732 100644 (file)
--- a/src/xen/xen_driver.c
+++ b/src/xen/xen_driver.c
@@ -63,7 +63,6 @@ static int
 xenUnifiedDomainGetVcpus (virDomainPtr dom,
                           virVcpuInfoPtr info, int maxinfo,
                           unsigned char *cpumaps, int maplen);
-static void xenDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque);
 
 
 /* The five Xen drivers below us. */
@@ -326,10 +325,7 @@ xenUnifiedOpen (virConnectPtr conn, virConnectAuthPtr auth, unsigned int flags)
         return VIR_DRV_OPEN_ERROR;
     }
 
-    if (!(priv->domainEvents = virDomainEventStateNew(xenDomainEventFlush,
-                                                      priv,
-                                                      NULL,
-                                                      false))) {
+    if (!(priv->domainEvents = virDomainEventStateNew(true))) {
         virMutexDestroy(&priv->lock);
         VIR_FREE(priv);
         return VIR_DRV_OPEN_ERROR;
@@ -2388,40 +2384,6 @@ xenUnifiedRemoveDomainInfo(xenUnifiedDomainInfoListPtr list,
 }
 
 
-static void
-xenUnifiedDomainEventDispatchFunc(virConnectPtr conn,
-                                  virDomainEventPtr event,
-                                  virConnectDomainEventGenericCallback cb,
-                                  void *cbopaque,
-                                  void *opaque)
-{
-    xenUnifiedPrivatePtr priv = opaque;
-
-    /*
-     * Release the lock while the callback is running so that
-     * we're re-entrant safe for callback work - the callback
-     * may want to invoke other virt functions & we have already
-     * protected the one piece of state we have - the callback
-     * list
-     */
-    xenUnifiedUnlock(priv);
-    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
-    xenUnifiedLock(priv);
-}
-
-static void xenDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    virConnectPtr conn = opaque;
-    xenUnifiedPrivatePtr priv = conn->privateData;
-
-    xenUnifiedLock(priv);
-    virDomainEventStateFlush(priv->domainEvents,
-                             xenUnifiedDomainEventDispatchFunc,
-                             priv);
-    xenUnifiedUnlock(priv);
-}
-
-
 /**
  * xenUnifiedDomainEventDispatch:
  * @priv: the connection to dispatch events on