[PATCH 1/2] virDomainEvent refactoring to separate generic things from domain ones

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



The idea behind this commit is to make use of the Domain event
mechanism for other events like network ones. This introduces some
renaming from virDomainEvent* to virOjbectEvent*.
---
 .gitignore                      |    1 +
 include/libvirt/libvirt.h.in    |    8 +
 src/Makefile.am                 |    6 +
 src/conf/domain_event.c         | 1431 +++++++--------------------------------
 src/conf/domain_event.h         |  134 ++--
 src/conf/object_event.c         |  918 +++++++++++++++++++++++++
 src/conf/object_event.h         |   93 +++
 src/conf/object_event_private.h |  160 +++++
 src/libvirt_private.syms        |   15 +-
 src/libxl/libxl_conf.h          |    2 +-
 src/libxl/libxl_driver.c        |   28 +-
 src/lxc/lxc_conf.h              |    2 +-
 src/lxc/lxc_driver.c            |   38 +-
 src/lxc/lxc_process.c           |   12 +-
 src/parallels/parallels_utils.h |    2 +-
 src/qemu/qemu_conf.h            |    2 +-
 src/qemu/qemu_domain.c          |    6 +-
 src/qemu/qemu_domain.h          |    2 +-
 src/qemu/qemu_driver.c          |   50 +-
 src/qemu/qemu_hotplug.c         |   10 +-
 src/qemu/qemu_migration.c       |   12 +-
 src/qemu/qemu_process.c         |   48 +-
 src/remote/remote_driver.c      |   50 +-
 src/test/test_driver.c          |   50 +-
 src/uml/uml_conf.h              |    2 +-
 src/uml/uml_driver.c            |   26 +-
 src/vbox/vbox_tmpl.c            |   20 +-
 src/xen/xen_driver.c            |   10 +-
 src/xen/xen_driver.h            |    4 +-
 src/xen/xen_inotify.c           |    8 +-
 src/xen/xs_internal.c           |    4 +-
 tests/qemuhotplugtest.c         |    2 +-
 32 files changed, 1687 insertions(+), 1469 deletions(-)
 create mode 100644 src/conf/object_event.c
 create mode 100644 src/conf/object_event.h
 create mode 100644 src/conf/object_event_private.h

diff --git a/.gitignore b/.gitignore
index 6b024e7..05be8a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -170,6 +170,7 @@
 /tests/networkxml2argvtest
 /tests/nodeinfotest
 /tests/nwfilterxml2xmltest
+/tests/objecteventtest
 /tests/object-locking
 /tests/object-locking-files.txt
 /tests/object-locking.cm[ix]
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index 146a59b..b13118d 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -4959,6 +4959,14 @@ typedef enum {
 } virDomainEventID;
 
 
+/** Event IDs are computed in the following way:
+    virEventNamespaceID << 8 + vir*EventId
+  */
+typedef enum {
+    VIR_EVENT_NAMESPACE_DOMAIN = 0, /* 0 to keep value of virDomainEventId unchanged */
+} virEventNamespaceID;
+
+
 /* Use VIR_DOMAIN_EVENT_CALLBACK() to cast the 'cb' parameter  */
 int virConnectDomainEventRegisterAny(virConnectPtr conn,
                                      virDomainPtr dom, /* Optional, to filter */
diff --git a/src/Makefile.am b/src/Makefile.am
index ad39b74..8507b55 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -241,6 +241,10 @@ DOMAIN_CONF_SOURCES =						\
 		conf/domain_nwfilter.c conf/domain_nwfilter.h	\
 		conf/snapshot_conf.c conf/snapshot_conf.h
 
+OBJECT_EVENT_SOURCES =						\
+		conf/object_event.h conf/object_event.c \
+		conf/objec_event_private.h
+
 DOMAIN_EVENT_SOURCES =						\
 		conf/domain_event.c conf/domain_event.h
 
@@ -292,6 +296,7 @@ DEVICE_CONF_SOURCES =                                           \
 CONF_SOURCES =							\
 		$(NETDEV_CONF_SOURCES)				\
 		$(DOMAIN_CONF_SOURCES)				\
+		$(OBJECT_EVENT_SOURCES)				\
 		$(DOMAIN_EVENT_SOURCES)				\
 		$(NETWORK_CONF_SOURCES)				\
 		$(NWFILTER_CONF_SOURCES)			\
@@ -2010,6 +2015,7 @@ libvirt_setuid_rpc_client_la_SOURCES = 		\
 		util/virutil.c			\
 		util/viruuid.c			\
 		conf/domain_event.c		\
+		conf/object_event.c		\
 		rpc/virnetsocket.c		\
 		rpc/virnetsocket.h		\
 		rpc/virnetmessage.h		\
diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c
index 19e3920..4a6038a 100644
--- a/src/conf/domain_event.c
+++ b/src/conf/domain_event.c
@@ -23,6 +23,8 @@
 
 #include <config.h>
 
+#include "object_event.h"
+#include "object_event_private.h"
 #include "domain_event.h"
 #include "virlog.h"
 #include "datatypes.h"
@@ -32,163 +34,93 @@
 
 #define VIR_FROM_THIS VIR_FROM_NONE
 
-struct _virDomainMeta {
-    int id;
-    char *name;
-    unsigned char uuid[VIR_UUID_BUFLEN];
-};
-typedef struct _virDomainMeta virDomainMeta;
-typedef virDomainMeta *virDomainMetaPtr;
-
-struct _virDomainEventCallbackList {
-    unsigned int nextID;
-    unsigned int count;
-    virDomainEventCallbackPtr *callbacks;
-};
-
-struct _virDomainEventQueue {
-    unsigned int count;
-    virDomainEventPtr *events;
-};
-
-struct _virDomainEventState {
-    /* The list of domain event callbacks */
-    virDomainEventCallbackListPtr callbacks;
-    /* The queue of domain events */
-    virDomainEventQueuePtr queue;
-    /* Timer for flushing events queue */
-    int timer;
-    /* Flag if we're in process of dispatching */
-    bool isDispatching;
-    virMutex lock;
-};
-
-struct _virDomainEventCallback {
-    int callbackID;
-    int eventID;
-    virConnectPtr conn;
-    virDomainMetaPtr dom;
-    virConnectDomainEventGenericCallback cb;
-    void *opaque;
-    virFreeCallback freecb;
-    int deleted;
-};
-
-struct _virDomainEvent {
-    int eventID;
-
-    virDomainMeta dom;
-
-    union {
-        struct {
-            int type;
-            int detail;
-        } lifecycle;
-        struct {
-            long long offset;
-        } rtcChange;
-        struct {
-            int action;
-        } watchdog;
-        struct {
-            char *srcPath;
-            char *devAlias;
-            int action;
-            char *reason;
-        } ioError;
-        struct {
-            int phase;
-            virDomainEventGraphicsAddressPtr local;
-            virDomainEventGraphicsAddressPtr remote;
-            char *authScheme;
-            virDomainEventGraphicsSubjectPtr subject;
-        } graphics;
-        struct {
-            char *path;
-            int type;
-            int status;
-        } blockJob;
-        struct {
-            char *oldSrcPath;
-            char *newSrcPath;
-            char *devAlias;
-            int reason;
-        } diskChange;
-        struct {
-            char *devAlias;
-            int reason;
-        } trayChange;
-        struct {
-            /* In unit of 1024 bytes */
-            unsigned long long actual;
-        } balloonChange;
-        struct {
-            char *devAlias;
-        } deviceRemoved;
-    } data;
-};
 
 /**
- * virDomainEventCallbackListFree:
- * @list: event callback list head
+ * virDomainEventCallbackListAdd:
+ * @conn: pointer to the connection
+ * @cbList: the list
+ * @callback: the callback to add
+ * @opaque: opaque data tio pass to callback
  *
- * Free the memory in the domain event callback list
+ * Internal function to add a callback from a virObjectEventCallbackListPtr
  */
-static void
-virDomainEventCallbackListFree(virDomainEventCallbackListPtr list)
+static int
+virDomainEventCallbackListAdd(virConnectPtr conn,
+                              virObjectEventCallbackListPtr cbList,
+                              virConnectDomainEventCallback callback,
+                              void *opaque,
+                              virFreeCallback freecb)
 {
-    size_t i;
-    if (!list)
-        return;
-
-    for (i=0; i<list->count; i++) {
-        virFreeCallback freecb = list->callbacks[i]->freecb;
-        if (freecb)
-            (*freecb)(list->callbacks[i]->opaque);
-        VIR_FREE(list->callbacks[i]);
-    }
-    VIR_FREE(list->callbacks);
-    VIR_FREE(list);
+    return virObjectEventCallbackListAddID(conn, cbList, NULL, NULL, 0,
+                                           VIR_DOMAIN_EVENT_ID_LIFECYCLE,
+                                           VIR_OBJECT_EVENT_CALLBACK(callback),
+                                           opaque, freecb, NULL);
 }
 
 
 /**
- * virDomainEventCallbackListRemove:
- * @conn: pointer to the connection
- * @cbList: the list
- * @callback: the callback to remove
+ * virDomainEventStateRegister:
+ * @conn: connection to associate with callback
+ * @state: object event state
+ * @callback: function to remove from event
+ * @opaque: data blob to pass to callback
+ * @freecb: callback to free @opaque
  *
- * Internal function to remove a callback from a virDomainEventCallbackListPtr
+ * Register the function @callback with connection @conn,
+ * from @state, for lifecycle events.
+ *
+ * Returns: the number of lifecycle callbacks now registered, or -1 on error
  */
+int
+virDomainEventStateRegister(virConnectPtr conn,
+                            virObjectEventStatePtr state,
+                            virConnectDomainEventCallback callback,
+                            void *opaque,
+                            virFreeCallback freecb)
+{
+    int ret = -1;
+
+    virObjectEventStateLock(state);
+
+    if ((state->callbacks->count == 0) &&
+        (state->timer == -1) &&
+        (state->timer = virEventAddTimeout(-1,
+                                           virObjectEventTimer,
+                                           state,
+                                           NULL)) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("could not initialize domain event timer"));
+        goto cleanup;
+    }
+
+    ret = virDomainEventCallbackListAdd(conn, state->callbacks,
+                                        callback, opaque, freecb);
+
+    if (ret == -1 &&
+        state->callbacks->count == 0 &&
+        state->timer != -1) {
+        virEventRemoveTimeout(state->timer);
+        state->timer = -1;
+    }
+
+cleanup:
+    virObjectEventStateUnlock(state);
+    return ret;
+}
+
+
 static int
-virDomainEventCallbackListRemove(virConnectPtr conn,
-                                 virDomainEventCallbackListPtr cbList,
-                                 virConnectDomainEventCallback callback)
+virDomainEventCallbackListMarkDelete(virConnectPtr conn,
+                                     virObjectEventCallbackListPtr cbList,
+                                     virConnectDomainEventCallback callback)
 {
     int ret = 0;
     size_t i;
     for (i = 0; i < cbList->count; i++) {
-        if (cbList->callbacks[i]->cb == VIR_DOMAIN_EVENT_CALLBACK(callback) &&
+        if (cbList->callbacks[i]->cb == VIR_OBJECT_EVENT_CALLBACK(callback) &&
             cbList->callbacks[i]->eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE &&
             cbList->callbacks[i]->conn == conn) {
-            virFreeCallback freecb = cbList->callbacks[i]->freecb;
-            if (freecb)
-                (*freecb)(cbList->callbacks[i]->opaque);
-            virObjectUnref(cbList->callbacks[i]->conn);
-            VIR_FREE(cbList->callbacks[i]);
-
-            if (i < (cbList->count - 1))
-                memmove(cbList->callbacks + i,
-                        cbList->callbacks + i + 1,
-                        sizeof(*(cbList->callbacks)) *
-                                (cbList->count - (i + 1)));
-
-            if (VIR_REALLOC_N(cbList->callbacks,
-                              cbList->count - 1) < 0) {
-                ; /* Failure to reduce memory allocation isn't fatal */
-            }
-            cbList->count--;
-
+            cbList->callbacks[i]->deleted = 1;
             for (i = 0; i < cbList->count; i++) {
                 if (!cbList->callbacks[i]->deleted)
                     ret++;
@@ -198,28 +130,29 @@ virDomainEventCallbackListRemove(virConnectPtr conn,
     }
 
     virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                   _("could not find event callback for removal"));
+                   _("could not find event callback for deletion"));
     return -1;
 }
 
 
 /**
- * virDomainEventCallbackListRemoveID:
+ * virDomainEventCallbackListRemove:
  * @conn: pointer to the connection
  * @cbList: the list
  * @callback: the callback to remove
  *
- * Internal function to remove a callback from a virDomainEventCallbackListPtr
+ * Internal function to remove a callback from a virObjectEventCallbackListPtr
  */
 static int
-virDomainEventCallbackListRemoveID(virConnectPtr conn,
-                                   virDomainEventCallbackListPtr cbList,
-                                   int callbackID)
+virDomainEventCallbackListRemove(virConnectPtr conn,
+                                 virObjectEventCallbackListPtr cbList,
+                                 virConnectDomainEventCallback callback)
 {
     int ret = 0;
     size_t i;
     for (i = 0; i < cbList->count; i++) {
-        if (cbList->callbacks[i]->callbackID == callbackID &&
+        if (cbList->callbacks[i]->cb == VIR_OBJECT_EVENT_CALLBACK(callback) &&
+            cbList->callbacks[i]->eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE &&
             cbList->callbacks[i]->conn == conn) {
             virFreeCallback freecb = cbList->callbacks[i]->freecb;
             if (freecb)
@@ -253,543 +186,159 @@ virDomainEventCallbackListRemoveID(virConnectPtr conn,
 }
 
 
-static int
-virDomainEventCallbackListMarkDelete(virConnectPtr conn,
-                                     virDomainEventCallbackListPtr cbList,
-                                     virConnectDomainEventCallback callback)
-{
-    int ret = 0;
-    size_t i;
-    for (i = 0; i < cbList->count; i++) {
-        if (cbList->callbacks[i]->cb == VIR_DOMAIN_EVENT_CALLBACK(callback) &&
-            cbList->callbacks[i]->eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE &&
-            cbList->callbacks[i]->conn == conn) {
-            cbList->callbacks[i]->deleted = 1;
-            for (i = 0; i < cbList->count; i++) {
-                if (!cbList->callbacks[i]->deleted)
-                    ret++;
-            }
-            return ret;
-        }
-    }
-
-    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                   _("could not find event callback for deletion"));
-    return -1;
-}
-
-
-static int
-virDomainEventCallbackListMarkDeleteID(virConnectPtr conn,
-                                       virDomainEventCallbackListPtr cbList,
-                                       int callbackID)
-{
-    int ret = 0;
-    size_t i;
-    for (i = 0; i < cbList->count; i++) {
-        if (cbList->callbacks[i]->callbackID == callbackID &&
-            cbList->callbacks[i]->conn == conn) {
-            cbList->callbacks[i]->deleted = 1;
-            for (i = 0; i < cbList->count; i++) {
-                if (!cbList->callbacks[i]->deleted)
-                    ret++;
-            }
-            return ret;
-        }
-    }
-
-    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                   _("could not find event callback for deletion"));
-    return -1;
-}
-
-
-static int
-virDomainEventCallbackListPurgeMarked(virDomainEventCallbackListPtr cbList)
-{
-    int old_count = cbList->count;
-    int n;
-    for (n = 0; n < cbList->count; n++) {
-        if (cbList->callbacks[n]->deleted) {
-            virFreeCallback freecb = cbList->callbacks[n]->freecb;
-            if (freecb)
-                (*freecb)(cbList->callbacks[n]->opaque);
-            virObjectUnref(cbList->callbacks[n]->conn);
-            VIR_FREE(cbList->callbacks[n]);
-
-            if (n < (cbList->count - 1))
-                memmove(cbList->callbacks + n,
-                        cbList->callbacks + n + 1,
-                        sizeof(*(cbList->callbacks)) *
-                                (cbList->count - (n + 1)));
-            cbList->count--;
-            n--;
-        }
-    }
-    if (cbList->count < old_count &&
-        VIR_REALLOC_N(cbList->callbacks, cbList->count) < 0) {
-        ; /* Failure to reduce memory allocation isn't fatal */
-    }
-    return 0;
-}
-
-
-/**
- * virDomainEventCallbackListAddID:
- * @conn: pointer to the connection
- * @cbList: the list
- * @eventID: the event ID
- * @callback: the callback to add
- * @opaque: opaque data tio pass to callback
- * @callbackID: filled with callback ID
- *
- * Internal function to add a callback from a virDomainEventCallbackListPtr
- */
-static int
-virDomainEventCallbackListAddID(virConnectPtr conn,
-                                virDomainEventCallbackListPtr cbList,
-                                virDomainPtr dom,
-                                int eventID,
-                                virConnectDomainEventGenericCallback callback,
-                                void *opaque,
-                                virFreeCallback freecb,
-                                int *callbackID)
-{
-    virDomainEventCallbackPtr event;
-    size_t i;
-    int ret = 0;
-
-    /* Check incoming */
-    if (!cbList) {
-        return -1;
-    }
-
-    /* check if we already have this callback on our list */
-    for (i = 0; i < cbList->count; i++) {
-        if (cbList->callbacks[i]->cb == VIR_DOMAIN_EVENT_CALLBACK(callback) &&
-            cbList->callbacks[i]->eventID == eventID &&
-            cbList->callbacks[i]->conn == conn &&
-            ((dom && cbList->callbacks[i]->dom &&
-              memcmp(cbList->callbacks[i]->dom->uuid,
-                     dom->uuid, VIR_UUID_BUFLEN) == 0) ||
-             (!dom && !cbList->callbacks[i]->dom))) {
-            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("event callback already tracked"));
-            return -1;
-        }
-    }
-    /* Allocate new event */
-    if (VIR_ALLOC(event) < 0)
-        goto error;
-    event->conn = conn;
-    event->cb = callback;
-    event->eventID = eventID;
-    event->opaque = opaque;
-    event->freecb = freecb;
-
-    if (dom) {
-        if (VIR_ALLOC(event->dom) < 0)
-            goto error;
-        if (VIR_STRDUP(event->dom->name, dom->name) < 0)
-            goto error;
-        memcpy(event->dom->uuid, dom->uuid, VIR_UUID_BUFLEN);
-        event->dom->id = dom->id;
-    }
-
-    /* Make space on list */
-    if (VIR_REALLOC_N(cbList->callbacks, cbList->count + 1) < 0)
-        goto error;
-
-    virObjectRef(event->conn);
-
-    cbList->callbacks[cbList->count] = event;
-    cbList->count++;
-
-    event->callbackID = cbList->nextID++;
-
-    for (i = 0; i < cbList->count; i++) {
-        if (cbList->callbacks[i]->eventID == eventID &&
-            cbList->callbacks[i]->conn == conn &&
-            !cbList->callbacks[i]->deleted)
-            ret++;
-    }
-
-    if (callbackID)
-        *callbackID = event->callbackID;
-
-    return ret;
-
-error:
-    if (event) {
-        if (event->dom)
-            VIR_FREE(event->dom->name);
-        VIR_FREE(event->dom);
-    }
-    VIR_FREE(event);
-    return -1;
-}
-
-
 /**
- * virDomainEventCallbackListAdd:
- * @conn: pointer to the connection
- * @cbList: the list
- * @callback: the callback to add
- * @opaque: opaque data tio pass to callback
- *
- * Internal function to add a callback from a virDomainEventCallbackListPtr
- */
-static int
-virDomainEventCallbackListAdd(virConnectPtr conn,
-                              virDomainEventCallbackListPtr cbList,
-                              virConnectDomainEventCallback callback,
-                              void *opaque,
-                              virFreeCallback freecb)
-{
-    return virDomainEventCallbackListAddID(conn, cbList, NULL,
-                                           VIR_DOMAIN_EVENT_ID_LIFECYCLE,
-                                           VIR_DOMAIN_EVENT_CALLBACK(callback),
-                                           opaque, freecb, NULL);
-}
-
-
-
-static int
-virDomainEventCallbackListEventID(virConnectPtr conn,
-                                  virDomainEventCallbackListPtr cbList,
-                                  int callbackID)
-{
-    size_t i;
-
-    for (i = 0; i < cbList->count; i++) {
-        if (cbList->callbacks[i]->deleted)
-            continue;
-
-        if (cbList->callbacks[i]->callbackID == callbackID &&
-            cbList->callbacks[i]->conn == conn)
-            return cbList->callbacks[i]->eventID;
-    }
-
-    return -1;
-}
-
-
-void virDomainEventFree(virDomainEventPtr event)
-{
-    if (!event)
-        return;
-
-    switch (event->eventID) {
-    case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON:
-    case VIR_DOMAIN_EVENT_ID_IO_ERROR:
-        VIR_FREE(event->data.ioError.srcPath);
-        VIR_FREE(event->data.ioError.devAlias);
-        VIR_FREE(event->data.ioError.reason);
-        break;
-
-    case VIR_DOMAIN_EVENT_ID_GRAPHICS:
-        if (event->data.graphics.local) {
-            VIR_FREE(event->data.graphics.local->node);
-            VIR_FREE(event->data.graphics.local->service);
-            VIR_FREE(event->data.graphics.local);
-        }
-        if (event->data.graphics.remote) {
-            VIR_FREE(event->data.graphics.remote->node);
-            VIR_FREE(event->data.graphics.remote->service);
-            VIR_FREE(event->data.graphics.remote);
-        }
-        VIR_FREE(event->data.graphics.authScheme);
-        if (event->data.graphics.subject) {
-            size_t i;
-            for (i = 0; i < event->data.graphics.subject->nidentity; i++) {
-                VIR_FREE(event->data.graphics.subject->identities[i].type);
-                VIR_FREE(event->data.graphics.subject->identities[i].name);
-            }
-            VIR_FREE(event->data.graphics.subject);
-        }
-        break;
-
-    case VIR_DOMAIN_EVENT_ID_BLOCK_JOB:
-        VIR_FREE(event->data.blockJob.path);
-        break;
-
-    case VIR_DOMAIN_EVENT_ID_DISK_CHANGE:
-        VIR_FREE(event->data.diskChange.oldSrcPath);
-        VIR_FREE(event->data.diskChange.newSrcPath);
-        VIR_FREE(event->data.diskChange.devAlias);
-        break;
-    case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE:
-        VIR_FREE(event->data.trayChange.devAlias);
-        break;
-    case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED:
-        VIR_FREE(event->data.deviceRemoved.devAlias);
-        break;
-    }
-
-    VIR_FREE(event->dom.name);
-    VIR_FREE(event);
-}
-
-/**
- * virDomainEventQueueClear:
- * @queue: pointer to the queue
- *
- * Removes all elements from the queue
- */
-static void
-virDomainEventQueueClear(virDomainEventQueuePtr queue)
-{
-    size_t i;
-    if (!queue)
-        return;
-
-    for (i = 0; i < queue->count; i++) {
-        virDomainEventFree(queue->events[i]);
-    }
-    VIR_FREE(queue->events);
-    queue->count = 0;
-}
-
-/**
- * virDomainEventQueueFree:
- * @queue: pointer to the queue
- *
- * Free the memory in the queue. We process this like a list here
- */
-static void
-virDomainEventQueueFree(virDomainEventQueuePtr queue)
-{
-    if (!queue)
-        return;
-
-    virDomainEventQueueClear(queue);
-    VIR_FREE(queue);
-}
-
-static virDomainEventQueuePtr
-virDomainEventQueueNew(void)
-{
-    virDomainEventQueuePtr ret;
-
-    ignore_value(VIR_ALLOC(ret));
-    return ret;
-}
-
-static void
-virDomainEventStateLock(virDomainEventStatePtr state)
-{
-    virMutexLock(&state->lock);
-}
-
-static void
-virDomainEventStateUnlock(virDomainEventStatePtr state)
-{
-    virMutexUnlock(&state->lock);
-}
-
-/**
- * virDomainEventStateFree:
- * @list: virDomainEventStatePtr to free
- *
- * Free a virDomainEventStatePtr and its members, and unregister the timer.
- */
-void
-virDomainEventStateFree(virDomainEventStatePtr state)
-{
-    if (!state)
-        return;
-
-    virDomainEventCallbackListFree(state->callbacks);
-    virDomainEventQueueFree(state->queue);
-
-    if (state->timer != -1)
-        virEventRemoveTimeout(state->timer);
-
-    virMutexDestroy(&state->lock);
-    VIR_FREE(state);
-}
-
-
-static void virDomainEventStateFlush(virDomainEventStatePtr state);
-
-static void
-virDomainEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque)
-{
-    virDomainEventStatePtr state = opaque;
-
-    virDomainEventStateFlush(state);
-}
-
-/**
- * virDomainEventStateNew:
- */
-virDomainEventStatePtr
-virDomainEventStateNew(void)
-{
-    virDomainEventStatePtr state = NULL;
-
-    if (VIR_ALLOC(state) < 0)
-        goto error;
-
-    if (virMutexInit(&state->lock) < 0) {
-        virReportSystemError(errno, "%s",
-                             _("unable to initialize state mutex"));
-        VIR_FREE(state);
-        goto error;
-    }
-
-    if (VIR_ALLOC(state->callbacks) < 0)
-        goto error;
-
-    if (!(state->queue = virDomainEventQueueNew()))
-        goto error;
-
-    state->timer = -1;
-
-    return state;
-
-error:
-    virDomainEventStateFree(state);
-    return NULL;
-}
-
-static virDomainEventPtr virDomainEventNewInternal(int eventID,
-                                                   int id,
-                                                   const char *name,
-                                                   const unsigned char *uuid)
+ * virDomainEventStateDeregister:
+ * @conn: connection to associate with callback
+ * @state: object event state
+ * @callback: function to remove from event
+ *
+ * Unregister the function @callback with connection @conn,
+ * from @state, for lifecycle events.
+ *
+ * Returns: the number of lifecycle callbacks still registered, or -1 on error
+ */
+int
+virDomainEventStateDeregister(virConnectPtr conn,
+                              virObjectEventStatePtr state,
+                              virConnectDomainEventCallback callback)
 {
-    virDomainEventPtr event;
+    int ret;
 
-    if (VIR_ALLOC(event) < 0)
-        return NULL;
+    virObjectEventStateLock(state);
+    if (state->isDispatching)
+        ret = virDomainEventCallbackListMarkDelete(conn,
+                                                   state->callbacks, callback);
+    else
+        ret = virDomainEventCallbackListRemove(conn, state->callbacks, callback);
 
-    event->eventID = eventID;
-    if (VIR_STRDUP(event->dom.name, name) < 0) {
-        VIR_FREE(event);
-        return NULL;
+    if (state->callbacks->count == 0 &&
+        state->timer != -1) {
+        virEventRemoveTimeout(state->timer);
+        state->timer = -1;
+        virObjectEventQueueClear(state->queue);
     }
-    event->dom.id = id;
-    memcpy(event->dom.uuid, uuid, VIR_UUID_BUFLEN);
 
-    return event;
+    virObjectEventStateUnlock(state);
+    return ret;
 }
 
-virDomainEventPtr virDomainEventNew(int id, const char *name,
+
+virObjectEventPtr virDomainEventNew(int id, const char *name,
                                     const unsigned char *uuid,
                                     int type, int detail)
 {
-    virDomainEventPtr event = virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_LIFECYCLE,
+    virObjectEventPtr event = virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_LIFECYCLE,
                                                         id, name, uuid);
 
     if (event) {
-        event->data.lifecycle.type = type;
-        event->data.lifecycle.detail = detail;
+        event->data.domainData.lifecycle.type = type;
+        event->data.domainData.lifecycle.detail = detail;
     }
 
     return event;
 }
 
-virDomainEventPtr virDomainEventNewFromDom(virDomainPtr dom, int type, int detail)
+virObjectEventPtr virDomainEventNewFromDom(virDomainPtr dom, int type, int detail)
 {
     return virDomainEventNew(dom->id, dom->name, dom->uuid, type, detail);
 }
 
-virDomainEventPtr virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail)
+virObjectEventPtr virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail)
 {
     return virDomainEventNewFromDef(obj->def, type, detail);
 }
 
-virDomainEventPtr virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail)
+virObjectEventPtr virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail)
 {
     return virDomainEventNew(def->id, def->name, def->uuid, type, detail);
 }
 
-virDomainEventPtr virDomainEventRebootNew(int id, const char *name,
+virObjectEventPtr virDomainEventRebootNew(int id, const char *name,
                                           const unsigned char *uuid)
 {
-    return virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT,
+    return virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT,
                                      id, name, uuid);
 }
 
-virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom)
+virObjectEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom)
 {
-    return virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT,
+    return virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT,
                                      dom->id, dom->name, dom->uuid);
 }
 
-virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj)
+virObjectEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj)
 {
-    return virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT,
+    return virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT,
                                      obj->def->id, obj->def->name, obj->def->uuid);
 }
 
-virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom,
                                                     long long offset)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_RTC_CHANGE,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_RTC_CHANGE,
                                   dom->id, dom->name, dom->uuid);
 
     if (ev)
-        ev->data.rtcChange.offset = offset;
+        ev->data.domainData.rtcChange.offset = offset;
 
     return ev;
 }
-virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj,
                                                     long long offset)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_RTC_CHANGE,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_RTC_CHANGE,
                                   obj->def->id, obj->def->name, obj->def->uuid);
 
     if (ev)
-        ev->data.rtcChange.offset = offset;
+        ev->data.domainData.rtcChange.offset = offset;
 
     return ev;
 }
 
-virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom,
                                                    int action)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_WATCHDOG,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_WATCHDOG,
                                   dom->id, dom->name, dom->uuid);
 
     if (ev)
-        ev->data.watchdog.action = action;
+        ev->data.domainData.watchdog.action = action;
 
     return ev;
 }
-virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj,
                                                    int action)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_WATCHDOG,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_WATCHDOG,
                                   obj->def->id, obj->def->name, obj->def->uuid);
 
     if (ev)
-        ev->data.watchdog.action = action;
+        ev->data.domainData.watchdog.action = action;
 
     return ev;
 }
 
-static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event,
+static virObjectEventPtr virDomainEventIOErrorNewFromDomImpl(int event,
                                                              virDomainPtr dom,
                                                              const char *srcPath,
                                                              const char *devAlias,
                                                              int action,
                                                              const char *reason)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(event,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(event,
                                   dom->id, dom->name, dom->uuid);
 
     if (ev) {
-        ev->data.ioError.action = action;
-        if (VIR_STRDUP(ev->data.ioError.srcPath, srcPath) < 0 ||
-            VIR_STRDUP(ev->data.ioError.devAlias, devAlias) < 0 ||
-            VIR_STRDUP(ev->data.ioError.reason, reason) < 0) {
-            virDomainEventFree(ev);
+        ev->data.domainData.ioError.action = action;
+        if (VIR_STRDUP(ev->data.domainData.ioError.srcPath, srcPath) < 0 ||
+            VIR_STRDUP(ev->data.domainData.ioError.devAlias, devAlias) < 0 ||
+            VIR_STRDUP(ev->data.domainData.ioError.reason, reason) < 0) {
+            virObjectEventFree(ev);
             ev = NULL;
         }
     }
@@ -797,23 +346,23 @@ static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event,
     return ev;
 }
 
-static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event,
+static virObjectEventPtr virDomainEventIOErrorNewFromObjImpl(int event,
                                                              virDomainObjPtr obj,
                                                              const char *srcPath,
                                                              const char *devAlias,
                                                              int action,
                                                              const char *reason)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(event,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(event,
                                   obj->def->id, obj->def->name, obj->def->uuid);
 
     if (ev) {
-        ev->data.ioError.action = action;
-        if (VIR_STRDUP(ev->data.ioError.srcPath, srcPath) < 0 ||
-            VIR_STRDUP(ev->data.ioError.devAlias, devAlias) < 0 ||
-            VIR_STRDUP(ev->data.ioError.reason, reason) < 0) {
-            virDomainEventFree(ev);
+        ev->data.domainData.ioError.action = action;
+        if (VIR_STRDUP(ev->data.domainData.ioError.srcPath, srcPath) < 0 ||
+            VIR_STRDUP(ev->data.domainData.ioError.devAlias, devAlias) < 0 ||
+            VIR_STRDUP(ev->data.domainData.ioError.reason, reason) < 0) {
+            virObjectEventFree(ev);
             ev = NULL;
         }
     }
@@ -821,7 +370,7 @@ static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event,
     return ev;
 }
 
-virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
                                                   const char *srcPath,
                                                   const char *devAlias,
                                                   int action)
@@ -831,7 +380,7 @@ virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
                                                action, NULL);
 }
 
-virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
                                                   const char *srcPath,
                                                   const char *devAlias,
                                                   int action)
@@ -841,7 +390,7 @@ virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
                                                action, NULL);
 }
 
-virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
                                                         const char *srcPath,
                                                         const char *devAlias,
                                                         int action,
@@ -852,7 +401,7 @@ virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
                                                action, reason);
 }
 
-virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
                                                         const char *srcPath,
                                                         const char *devAlias,
                                                         int action,
@@ -864,77 +413,77 @@ virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
 }
 
 
-virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom,
                                                    int phase,
                                                    virDomainEventGraphicsAddressPtr local,
                                                    virDomainEventGraphicsAddressPtr remote,
                                                    const char *authScheme,
                                                    virDomainEventGraphicsSubjectPtr subject)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_GRAPHICS,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_GRAPHICS,
                                   dom->id, dom->name, dom->uuid);
 
     if (ev) {
-        ev->data.graphics.phase = phase;
-        if (VIR_STRDUP(ev->data.graphics.authScheme, authScheme) < 0) {
-            virDomainEventFree(ev);
+        ev->data.domainData.graphics.phase = phase;
+        if (VIR_STRDUP(ev->data.domainData.graphics.authScheme, authScheme) < 0) {
+            virObjectEventFree(ev);
             return NULL;
         }
-        ev->data.graphics.local = local;
-        ev->data.graphics.remote = remote;
-        ev->data.graphics.subject = subject;
+        ev->data.domainData.graphics.local = local;
+        ev->data.domainData.graphics.remote = remote;
+        ev->data.domainData.graphics.subject = subject;
     }
 
     return ev;
 }
 
-virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
                                                    int phase,
                                                    virDomainEventGraphicsAddressPtr local,
                                                    virDomainEventGraphicsAddressPtr remote,
                                                    const char *authScheme,
                                                    virDomainEventGraphicsSubjectPtr subject)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_GRAPHICS,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_GRAPHICS,
                                   obj->def->id, obj->def->name, obj->def->uuid);
 
     if (ev) {
-        ev->data.graphics.phase = phase;
-        if (VIR_STRDUP(ev->data.graphics.authScheme, authScheme) < 0) {
-            virDomainEventFree(ev);
+        ev->data.domainData.graphics.phase = phase;
+        if (VIR_STRDUP(ev->data.domainData.graphics.authScheme, authScheme) < 0) {
+            virObjectEventFree(ev);
             return NULL;
         }
-        ev->data.graphics.local = local;
-        ev->data.graphics.remote = remote;
-        ev->data.graphics.subject = subject;
+        ev->data.domainData.graphics.local = local;
+        ev->data.domainData.graphics.remote = remote;
+        ev->data.domainData.graphics.subject = subject;
     }
 
     return ev;
 }
 
-static virDomainEventPtr
+static virObjectEventPtr
 virDomainEventBlockJobNew(int id, const char *name, unsigned char *uuid,
                           const char *path, int type, int status)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_BLOCK_JOB,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_BLOCK_JOB,
                                   id, name, uuid);
 
     if (ev) {
-        if (VIR_STRDUP(ev->data.blockJob.path, path) < 0) {
-            virDomainEventFree(ev);
+        if (VIR_STRDUP(ev->data.domainData.blockJob.path, path) < 0) {
+            virObjectEventFree(ev);
             return NULL;
         }
-        ev->data.blockJob.type = type;
-        ev->data.blockJob.status = status;
+        ev->data.domainData.blockJob.type = type;
+        ev->data.domainData.blockJob.status = status;
     }
 
     return ev;
 }
 
-virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
                                                    const char *path,
                                                    int type,
                                                    int status)
@@ -943,7 +492,7 @@ virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
                                      obj->def->uuid, path, type, status);
 }
 
-virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
                                                    const char *path,
                                                    int type,
                                                    int status)
@@ -952,55 +501,55 @@ virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
                                      path, type, status);
 }
 
-virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom)
+virObjectEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_CONTROL_ERROR,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_CONTROL_ERROR,
                                   dom->id, dom->name, dom->uuid);
     return ev;
 }
 
 
-virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj)
+virObjectEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_CONTROL_ERROR,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_CONTROL_ERROR,
                                   obj->def->id, obj->def->name, obj->def->uuid);
     return ev;
 }
 
-static virDomainEventPtr
+static virObjectEventPtr
 virDomainEventDiskChangeNew(int id, const char *name,
                             unsigned char *uuid,
                             const char *oldSrcPath,
                             const char *newSrcPath,
                             const char *devAlias, int reason)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_DISK_CHANGE,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_DISK_CHANGE,
                                   id, name, uuid);
 
     if (ev) {
-        if (VIR_STRDUP(ev->data.diskChange.devAlias, devAlias) < 0)
+        if (VIR_STRDUP(ev->data.domainData.diskChange.devAlias, devAlias) < 0)
             goto error;
 
-        if (VIR_STRDUP(ev->data.diskChange.oldSrcPath, oldSrcPath) < 0)
+        if (VIR_STRDUP(ev->data.domainData.diskChange.oldSrcPath, oldSrcPath) < 0)
             goto error;
 
-        if (VIR_STRDUP(ev->data.diskChange.newSrcPath, newSrcPath) < 0)
+        if (VIR_STRDUP(ev->data.domainData.diskChange.newSrcPath, newSrcPath) < 0)
             goto error;
 
-        ev->data.diskChange.reason = reason;
+        ev->data.domainData.diskChange.reason = reason;
     }
 
     return ev;
 
 error:
-    virDomainEventFree(ev);
+    virObjectEventFree(ev);
     return NULL;
 }
 
-virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
                                                      const char *oldSrcPath,
                                                      const char *newSrcPath,
                                                      const char *devAlias,
@@ -1011,7 +560,7 @@ virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
                                        newSrcPath, devAlias, reason);
 }
 
-virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
                                                      const char *oldSrcPath,
                                                      const char *newSrcPath,
                                                      const char *devAlias,
@@ -1022,31 +571,31 @@ virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
                                        devAlias, reason);
 }
 
-static virDomainEventPtr
+static virObjectEventPtr
 virDomainEventTrayChangeNew(int id, const char *name,
                             unsigned char *uuid,
                             const char *devAlias,
                             int reason)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_TRAY_CHANGE,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_TRAY_CHANGE,
                                   id, name, uuid);
 
     if (ev) {
-        if (VIR_STRDUP(ev->data.trayChange.devAlias, devAlias) < 0)
+        if (VIR_STRDUP(ev->data.domainData.trayChange.devAlias, devAlias) < 0)
             goto error;
 
-        ev->data.trayChange.reason = reason;
+        ev->data.domainData.trayChange.reason = reason;
     }
 
     return ev;
 
 error:
-    virDomainEventFree(ev);
+    virObjectEventFree(ev);
     return NULL;
 }
 
-virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
                                                      const char *devAlias,
                                                      int reason)
 {
@@ -1057,7 +606,7 @@ virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
                                        reason);
 }
 
-virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
                                                      const char *devAlias,
                                                      int reason)
 {
@@ -1065,18 +614,18 @@ virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
                                        devAlias, reason);
 }
 
-static virDomainEventPtr
+static virObjectEventPtr
 virDomainEventPMWakeupNew(int id, const char *name,
                           unsigned char *uuid)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_PMWAKEUP,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_PMWAKEUP,
                                   id, name, uuid);
 
     return ev;
 }
 
-virDomainEventPtr
+virObjectEventPtr
 virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj)
 {
     return virDomainEventPMWakeupNew(obj->def->id,
@@ -1084,24 +633,24 @@ virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj)
                                      obj->def->uuid);
 }
 
-virDomainEventPtr
+virObjectEventPtr
 virDomainEventPMWakeupNewFromDom(virDomainPtr dom)
 {
     return virDomainEventPMWakeupNew(dom->id, dom->name, dom->uuid);
 }
 
-static virDomainEventPtr
+static virObjectEventPtr
 virDomainEventPMSuspendNew(int id, const char *name,
                            unsigned char *uuid)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_PMSUSPEND,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_PMSUSPEND,
                                   id, name, uuid);
 
     return ev;
 }
 
-virDomainEventPtr
+virObjectEventPtr
 virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj)
 {
     return virDomainEventPMSuspendNew(obj->def->id,
@@ -1109,23 +658,23 @@ virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj)
                                       obj->def->uuid);
 }
 
-virDomainEventPtr
+virObjectEventPtr
 virDomainEventPMSuspendNewFromDom(virDomainPtr dom)
 {
     return virDomainEventPMSuspendNew(dom->id, dom->name, dom->uuid);
 }
 
-static virDomainEventPtr
+static virObjectEventPtr
 virDomainEventPMSuspendDiskNew(int id, const char *name,
                                unsigned char *uuid)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK,
                                   id, name, uuid);
     return ev;
 }
 
-virDomainEventPtr
+virObjectEventPtr
 virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj)
 {
     return virDomainEventPMSuspendDiskNew(obj->def->id,
@@ -1133,60 +682,60 @@ virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj)
                                           obj->def->uuid);
 }
 
-virDomainEventPtr
+virObjectEventPtr
 virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom)
 {
     return virDomainEventPMSuspendDiskNew(dom->id, dom->name, dom->uuid);
 }
 
-virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom,
                                                         unsigned long long actual)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE,
                                   dom->id, dom->name, dom->uuid);
 
     if (ev)
-        ev->data.balloonChange.actual = actual;
+        ev->data.domainData.balloonChange.actual = actual;
 
     return ev;
 }
-virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj,
                                                         unsigned long long actual)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE,
                                   obj->def->id, obj->def->name, obj->def->uuid);
 
     if (ev)
-        ev->data.balloonChange.actual = actual;
+        ev->data.domainData.balloonChange.actual = actual;
 
     return ev;
 }
 
-static virDomainEventPtr
+static virObjectEventPtr
 virDomainEventDeviceRemovedNew(int id,
                                const char *name,
                                unsigned char *uuid,
                                const char *devAlias)
 {
-    virDomainEventPtr ev =
-        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED,
+    virObjectEventPtr ev =
+        virObjectEventNewInternal(VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED,
                                   id, name, uuid);
 
     if (ev) {
-        if (VIR_STRDUP(ev->data.deviceRemoved.devAlias, devAlias) < 0)
+        if (VIR_STRDUP(ev->data.domainData.deviceRemoved.devAlias, devAlias) < 0)
             goto error;
     }
 
     return ev;
 
 error:
-    virDomainEventFree(ev);
+    virObjectEventFree(ev);
     return NULL;
 }
 
-virDomainEventPtr
+virObjectEventPtr
 virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
                                       const char *devAlias)
 {
@@ -1194,7 +743,7 @@ virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
                                           obj->def->uuid, devAlias);
 }
 
-virDomainEventPtr
+virObjectEventPtr
 virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
                                       const char *devAlias)
 {
@@ -1202,373 +751,11 @@ virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
                                           devAlias);
 }
 
-/**
- * virDomainEventQueuePush:
- * @evtQueue: the dom event queue
- * @event: the event to add
- *
- * Internal function to push to the back of a virDomainEventQueue
- *
- * Returns: 0 on success, -1 on failure
- */
-static int
-virDomainEventQueuePush(virDomainEventQueuePtr evtQueue,
-                        virDomainEventPtr event)
-{
-    if (!evtQueue) {
-        return -1;
-    }
-
-    /* Make space on queue */
-    if (VIR_REALLOC_N(evtQueue->events,
-                      evtQueue->count + 1) < 0)
-        return -1;
-
-    evtQueue->events[evtQueue->count] = event;
-    evtQueue->count++;
-    return 0;
-}
-
-
-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)
-        return;
-    dom->id = event->dom.id;
-
-    switch ((virDomainEventID) event->eventID) {
-    case VIR_DOMAIN_EVENT_ID_LIFECYCLE:
-        ((virConnectDomainEventCallback)cb)(conn, dom,
-                                            event->data.lifecycle.type,
-                                            event->data.lifecycle.detail,
-                                            cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_REBOOT:
-        (cb)(conn, dom,
-             cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_RTC_CHANGE:
-        ((virConnectDomainEventRTCChangeCallback)cb)(conn, dom,
-                                                     event->data.rtcChange.offset,
-                                                     cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_WATCHDOG:
-        ((virConnectDomainEventWatchdogCallback)cb)(conn, dom,
-                                                    event->data.watchdog.action,
-                                                    cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_IO_ERROR:
-        ((virConnectDomainEventIOErrorCallback)cb)(conn, dom,
-                                                   event->data.ioError.srcPath,
-                                                   event->data.ioError.devAlias,
-                                                   event->data.ioError.action,
-                                                   cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON:
-        ((virConnectDomainEventIOErrorReasonCallback)cb)(conn, dom,
-                                                         event->data.ioError.srcPath,
-                                                         event->data.ioError.devAlias,
-                                                         event->data.ioError.action,
-                                                         event->data.ioError.reason,
-                                                         cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_GRAPHICS:
-        ((virConnectDomainEventGraphicsCallback)cb)(conn, dom,
-                                                    event->data.graphics.phase,
-                                                    event->data.graphics.local,
-                                                    event->data.graphics.remote,
-                                                    event->data.graphics.authScheme,
-                                                    event->data.graphics.subject,
-                                                    cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_CONTROL_ERROR:
-        (cb)(conn, dom,
-             cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_BLOCK_JOB:
-        ((virConnectDomainEventBlockJobCallback)cb)(conn, dom,
-                                                    event->data.blockJob.path,
-                                                    event->data.blockJob.type,
-                                                    event->data.blockJob.status,
-                                                    cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_DISK_CHANGE:
-        ((virConnectDomainEventDiskChangeCallback)cb)(conn, dom,
-                                                      event->data.diskChange.oldSrcPath,
-                                                      event->data.diskChange.newSrcPath,
-                                                      event->data.diskChange.devAlias,
-                                                      event->data.diskChange.reason,
-                                                      cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE:
-        ((virConnectDomainEventTrayChangeCallback)cb)(conn, dom,
-                                                      event->data.trayChange.devAlias,
-                                                      event->data.trayChange.reason,
-                                                      cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_PMWAKEUP:
-        ((virConnectDomainEventPMWakeupCallback)cb)(conn, dom, 0, cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_PMSUSPEND:
-        ((virConnectDomainEventPMSuspendCallback)cb)(conn, dom, 0, cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE:
-        ((virConnectDomainEventBalloonChangeCallback)cb)(conn, dom,
-                                                         event->data.balloonChange.actual,
-                                                         cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK:
-        ((virConnectDomainEventPMSuspendDiskCallback)cb)(conn, dom, 0, cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED:
-        ((virConnectDomainEventDeviceRemovedCallback)cb)(conn, dom,
-                                                         event->data.deviceRemoved.devAlias,
-                                                         cbopaque);
-        goto cleanup;
-
-    case VIR_DOMAIN_EVENT_ID_LAST:
-        break;
-    }
-
-    VIR_WARN("Unexpected event ID %d", event->eventID);
-
-cleanup:
-    virDomainFree(dom);
-}
-
-
-static int virDomainEventDispatchMatchCallback(virDomainEventPtr event,
-                                               virDomainEventCallbackPtr cb)
-{
-    if (!cb)
-        return 0;
-    if (cb->deleted)
-        return 0;
-    if (cb->eventID != event->eventID)
-        return 0;
-
-    if (cb->dom) {
-        /* Deliberately ignoring 'id' for matching, since that
-         * will cause problems when a domain switches between
-         * running & shutoff states & ignoring 'name' since
-         * Xen sometimes renames guests during migration, thus
-         * leaving 'uuid' as the only truly reliable ID we can use*/
-
-        if (memcmp(event->dom.uuid, cb->dom->uuid, VIR_UUID_BUFLEN) == 0)
-            return 1;
-
-        return 0;
-    } else {
-        return 1;
-    }
-}
-
-
-static void
-virDomainEventDispatch(virDomainEventPtr event,
-                       virDomainEventCallbackListPtr callbacks,
-                       virDomainEventDispatchFunc dispatch,
-                       void *opaque)
-{
-    size_t i;
-    /* Cache this now, since we may be dropping the lock,
-       and have more callbacks added. We're guaranteed not
-       to have any removed */
-    int cbCount = callbacks->count;
-
-    for (i = 0; i < cbCount; i++) {
-        if (!virDomainEventDispatchMatchCallback(event, callbacks->callbacks[i]))
-            continue;
-
-        (*dispatch)(callbacks->callbacks[i]->conn,
-                    event,
-                    callbacks->callbacks[i]->cb,
-                    callbacks->callbacks[i]->opaque,
-                    opaque);
-    }
-}
-
-
-static void
-virDomainEventQueueDispatch(virDomainEventQueuePtr queue,
-                            virDomainEventCallbackListPtr callbacks,
-                            virDomainEventDispatchFunc dispatch,
-                            void *opaque)
-{
-    size_t i;
-
-    for (i = 0; i < queue->count; i++) {
-        virDomainEventDispatch(queue->events[i], callbacks, dispatch, opaque);
-        virDomainEventFree(queue->events[i]);
-    }
-    VIR_FREE(queue->events);
-    queue->count = 0;
-}
-
-void
-virDomainEventStateQueue(virDomainEventStatePtr state,
-                         virDomainEventPtr event)
-{
-    if (state->timer < 0) {
-        virDomainEventFree(event);
-        return;
-    }
-
-    virDomainEventStateLock(state);
-
-    if (virDomainEventQueuePush(state->queue, event) < 0) {
-        VIR_DEBUG("Error adding event to queue");
-        virDomainEventFree(event);
-    }
-
-    if (state->queue->count == 1)
-        virEventUpdateTimeout(state->timer, 0);
-    virDomainEventStateUnlock(state);
-}
-
-
-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;
-
-    virDomainEventStateLock(state);
-    state->isDispatching = true;
-
-    /* Copy the queue, so we're reentrant safe when dispatchFunc drops the
-     * driver lock */
-    tempQueue.count = state->queue->count;
-    tempQueue.events = state->queue->events;
-    state->queue->count = 0;
-    state->queue->events = NULL;
-    virEventUpdateTimeout(state->timer, -1);
-
-    virDomainEventQueueDispatch(&tempQueue,
-                                state->callbacks,
-                                virDomainEventStateDispatchFunc,
-                                state);
-
-    /* Purge any deleted callbacks */
-    virDomainEventCallbackListPurgeMarked(state->callbacks);
-
-    state->isDispatching = false;
-    virDomainEventStateUnlock(state);
-}
-
-
-/**
- * virDomainEventStateRegister:
- * @conn: connection to associate with callback
- * @state: domain event state
- * @callback: function to remove from event
- * @opaque: data blob to pass to callback
- * @freecb: callback to free @opaque
- *
- * Register the function @callback with connection @conn,
- * from @state, for lifecycle events.
- *
- * 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 ret = -1;
-
-    virDomainEventStateLock(state);
-
-    if ((state->callbacks->count == 0) &&
-        (state->timer == -1) &&
-        (state->timer = virEventAddTimeout(-1,
-                                           virDomainEventTimer,
-                                           state,
-                                           NULL)) < 0) {
-        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("could not initialize domain event timer"));
-        goto cleanup;
-    }
-
-    ret = virDomainEventCallbackListAdd(conn, state->callbacks,
-                                        callback, opaque, freecb);
-
-    if (ret == -1 &&
-        state->callbacks->count == 0 &&
-        state->timer != -1) {
-        virEventRemoveTimeout(state->timer);
-        state->timer = -1;
-    }
-
-cleanup:
-    virDomainEventStateUnlock(state);
-    return ret;
-}
-
 
-/**
- * virDomainEventStateRegisterID:
- * @conn: connection to associate with callback
- * @state: domain event state
- * @eventID: ID of the event type to register for
- * @cb: function to remove from event
- * @opaque: data blob to pass to callback
- * @freecb: callback to free @opaque
- * @callbackID: filled with callback ID
- *
- * Register the function @callbackID with connection @conn,
- * from @state, for events of type @eventID.
- *
- * Returns: the number of callbacks now registered, or -1 on error
- */
+/* Kept for compatibility reasons */
 int
 virDomainEventStateRegisterID(virConnectPtr conn,
-                              virDomainEventStatePtr state,
+                              virObjectEventStatePtr state,
                               virDomainPtr dom,
                               int eventID,
                               virConnectDomainEventGenericCallback cb,
@@ -1576,134 +763,14 @@ virDomainEventStateRegisterID(virConnectPtr conn,
                               virFreeCallback freecb,
                               int *callbackID)
 {
-    int ret = -1;
-
-    virDomainEventStateLock(state);
-
-    if ((state->callbacks->count == 0) &&
-        (state->timer == -1) &&
-        (state->timer = virEventAddTimeout(-1,
-                                           virDomainEventTimer,
-                                           state,
-                                           NULL)) < 0) {
-        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("could not initialize domain event timer"));
-        goto cleanup;
-    }
-
-    ret = virDomainEventCallbackListAddID(conn, state->callbacks,
-                                          dom, eventID, cb, opaque, freecb,
-                                          callbackID);
-
-    if (ret == -1 &&
-        state->callbacks->count == 0 &&
-        state->timer != -1) {
-        virEventRemoveTimeout(state->timer);
-        state->timer = -1;
-    }
-
-cleanup:
-    virDomainEventStateUnlock(state);
-    return ret;
-}
-
-
-/**
- * virDomainEventStateDeregister:
- * @conn: connection to associate with callback
- * @state: domain event state
- * @callback: function to remove from event
- *
- * Unregister the function @callback with connection @conn,
- * from @state, for lifecycle events.
- *
- * Returns: the number of lifecycle callbacks still registered, or -1 on error
- */
-int
-virDomainEventStateDeregister(virConnectPtr conn,
-                              virDomainEventStatePtr state,
-                              virConnectDomainEventCallback callback)
-{
-    int ret;
-
-    virDomainEventStateLock(state);
-    if (state->isDispatching)
-        ret = virDomainEventCallbackListMarkDelete(conn,
-                                                   state->callbacks, callback);
-    else
-        ret = virDomainEventCallbackListRemove(conn, state->callbacks, callback);
-
-    if (state->callbacks->count == 0 &&
-        state->timer != -1) {
-        virEventRemoveTimeout(state->timer);
-        state->timer = -1;
-        virDomainEventQueueClear(state->queue);
-    }
-
-    virDomainEventStateUnlock(state);
-    return ret;
-}
-
-
-/**
- * virDomainEventStateDeregisterID:
- * @conn: connection to associate with callback
- * @state: domain event state
- * @callbackID: ID of the function to remove from event
- *
- * Unregister the function @callbackID with connection @conn,
- * from @state, for events.
- *
- * Returns: the number of callbacks still registered, or -1 on error
- */
-int
-virDomainEventStateDeregisterID(virConnectPtr conn,
-                                virDomainEventStatePtr state,
-                                int callbackID)
-{
-    int ret;
-
-    virDomainEventStateLock(state);
-    if (state->isDispatching)
-        ret = virDomainEventCallbackListMarkDeleteID(conn,
-                                                     state->callbacks, callbackID);
+    if (dom)
+        return virObjectEventStateRegisterID(conn, state, dom->uuid, dom->name,
+                                             dom->id, eventID,
+                                             VIR_OBJECT_EVENT_CALLBACK(cb),
+                                             opaque, freecb, callbackID);
     else
-        ret = virDomainEventCallbackListRemoveID(conn,
-                                                 state->callbacks, callbackID);
-
-    if (state->callbacks->count == 0 &&
-        state->timer != -1) {
-        virEventRemoveTimeout(state->timer);
-        state->timer = -1;
-        virDomainEventQueueClear(state->queue);
-    }
-
-    virDomainEventStateUnlock(state);
-    return ret;
-}
-
-
-/**
- * virDomainEventStateEventID:
- * @conn: connection associated with the callback
- * @state: domain event state
- * @callbackID: the callback to query
- *
- * Query what event ID type is associated with the
- * callback @callbackID for connection @conn
- *
- * Returns 0 on success, -1 on error
- */
-int
-virDomainEventStateEventID(virConnectPtr conn,
-                           virDomainEventStatePtr state,
-                           int callbackID)
-{
-    int ret;
-
-    virDomainEventStateLock(state);
-    ret = virDomainEventCallbackListEventID(conn,
-                                            state->callbacks, callbackID);
-    virDomainEventStateUnlock(state);
-    return ret;
+        return virObjectEventStateRegisterID(conn, state, NULL, NULL, 0,
+                                             eventID,
+                                             VIR_OBJECT_EVENT_CALLBACK(cb),
+                                             opaque, freecb, callbackID);
 }
diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h
index f6b957d..c8928c7 100644
--- a/src/conf/domain_event.h
+++ b/src/conf/domain_event.h
@@ -26,135 +26,112 @@
 #ifndef __DOMAIN_EVENT_H__
 # define __DOMAIN_EVENT_H__
 
+# include "object_event.h"
 # include "domain_conf.h"
 
-typedef struct _virDomainEventCallback virDomainEventCallback;
-typedef virDomainEventCallback *virDomainEventCallbackPtr;
-
-typedef struct _virDomainEventCallbackList virDomainEventCallbackList;
-typedef virDomainEventCallbackList *virDomainEventCallbackListPtr;
-
-/**
- * Dispatching domain events that come in while
- * in a call / response rpc
- */
-typedef struct _virDomainEvent virDomainEvent;
-typedef virDomainEvent *virDomainEventPtr;
-
-typedef struct _virDomainEventQueue virDomainEventQueue;
-typedef virDomainEventQueue *virDomainEventQueuePtr;
-
-typedef struct _virDomainEventState virDomainEventState;
-typedef virDomainEventState *virDomainEventStatePtr;
+int virDomainEventStateRegister(virConnectPtr conn,
+                                virObjectEventStatePtr state,
+                                virConnectDomainEventCallback callback,
+                                void *opaque,
+                                virFreeCallback freecb)
+    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
+int
+virDomainEventStateDeregister(virConnectPtr conn,
+                              virObjectEventStatePtr state,
+                              virConnectDomainEventCallback callback)
+    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
 
-virDomainEventPtr virDomainEventNew(int id, const char *name, const unsigned char *uuid, int type, int detail);
-virDomainEventPtr virDomainEventNewFromDom(virDomainPtr dom, int type, int detail);
-virDomainEventPtr virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail);
-virDomainEventPtr virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail);
+virObjectEventPtr virDomainEventNew(int id, const char *name, const unsigned char *uuid, int type, int detail);
+virObjectEventPtr virDomainEventNewFromDom(virDomainPtr dom, int type, int detail);
+virObjectEventPtr virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail);
+virObjectEventPtr virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail);
 
-virDomainEventPtr virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid);
-virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom);
-virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid);
+virObjectEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj);
 
-virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset);
-virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset);
+virObjectEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset);
+virObjectEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset);
 
-virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action);
-virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action);
+virObjectEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action);
+virObjectEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action);
 
-virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
                                                   const char *srcPath,
                                                   const char *devAlias,
                                                   int action);
-virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
                                                   const char *srcPath,
                                                   const char *devAlias,
                                                   int action);
-virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
                                                         const char *srcPath,
                                                         const char *devAlias,
                                                         int action,
                                                         const char *reason);
-virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
                                                         const char *srcPath,
                                                         const char *devAlias,
                                                         int action,
                                                         const char *reason);
 
-virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom,
                                                    int phase,
                                                    virDomainEventGraphicsAddressPtr local,
                                                    virDomainEventGraphicsAddressPtr remote,
                                                    const char *authScheme,
                                                    virDomainEventGraphicsSubjectPtr subject);
-virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
                                                    int phase,
                                                    virDomainEventGraphicsAddressPtr local,
                                                    virDomainEventGraphicsAddressPtr remote,
                                                    const char *authScheme,
                                                    virDomainEventGraphicsSubjectPtr subject);
-virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom);
-virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj);
 
-virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
                                                     const char *path,
                                                     int type,
                                                     int status);
-virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
                                                     const char *path,
                                                     int type,
                                                     int status);
 
-virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
                                                      const char *oldSrcPath,
                                                      const char *newSrcPath,
                                                      const char *devAlias,
                                                      int reason);
-virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
                                                      const char *oldSrcPath,
                                                      const char *newSrcPath,
                                                      const char *devAlias,
                                                      int reason);
-virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
                                                      const char *devAlias,
                                                      int reason);
-virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
                                                      const char *devAlias,
                                                      int reason);
-virDomainEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventPMWakeupNewFromDom(virDomainPtr dom);
-virDomainEventPtr virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventPMSuspendNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventPMWakeupNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventPMSuspendNewFromDom(virDomainPtr dom);
 
-virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual);
-virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual);
+virObjectEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual);
+virObjectEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual);
 
-virDomainEventPtr virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom);
 
-virDomainEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
                                                         const char *devAlias);
-virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
                                                         const char *devAlias);
-
-void virDomainEventFree(virDomainEventPtr event);
-
-void virDomainEventStateFree(virDomainEventStatePtr state);
-virDomainEventStatePtr
-virDomainEventStateNew(void);
-
-void
-virDomainEventStateQueue(virDomainEventStatePtr state,
-                         virDomainEventPtr event)
-    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int virDomainEventStateRegister(virConnectPtr conn,
-                                virDomainEventStatePtr state,
-                                virConnectDomainEventCallback callback,
-                                void *opaque,
-                                virFreeCallback freecb)
-    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
 int virDomainEventStateRegisterID(virConnectPtr conn,
-                                  virDomainEventStatePtr state,
+                                  virObjectEventStatePtr state,
                                   virDomainPtr dom,
                                   int eventID,
                                   virConnectDomainEventGenericCallback cb,
@@ -162,20 +139,5 @@ int virDomainEventStateRegisterID(virConnectPtr conn,
                                   virFreeCallback freecb,
                                   int *callbackID)
     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5);
-int
-virDomainEventStateDeregister(virConnectPtr conn,
-                              virDomainEventStatePtr state,
-                              virConnectDomainEventCallback callback)
-    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
-int
-virDomainEventStateDeregisterID(virConnectPtr conn,
-                                virDomainEventStatePtr state,
-                                int callbackID)
-    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int
-virDomainEventStateEventID(virConnectPtr conn,
-                           virDomainEventStatePtr state,
-                           int callbackID)
-    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
 
 #endif
diff --git a/src/conf/object_event.c b/src/conf/object_event.c
new file mode 100644
index 0000000..46eb677
--- /dev/null
+++ b/src/conf/object_event.c
@@ -0,0 +1,918 @@
+/*
+ * domain_event.c: domain event queue processing helpers
+ *
+ * Copyright (C) 2010-2013 Red Hat, Inc.
+ * Copyright (C) 2008 VirtualIron
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Author: Ben Guthro
+ */
+
+#include <config.h>
+
+#include "object_event.h"
+#include "object_event_private.h"
+#include "virlog.h"
+#include "viralloc.h"
+#include "virerror.h"
+#include "virstring.h"
+
+#define VIR_FROM_THIS VIR_FROM_NONE
+
+
+/**
+ * virObjectEventCallbackListFree:
+ * @list: event callback list head
+ *
+ * Free the memory in the domain event callback list
+ */
+static void
+virObjectEventCallbackListFree(virObjectEventCallbackListPtr list)
+{
+    size_t i;
+    if (!list)
+        return;
+
+    for (i=0; i<list->count; i++) {
+        virFreeCallback freecb = list->callbacks[i]->freecb;
+        if (freecb)
+            (*freecb)(list->callbacks[i]->opaque);
+        VIR_FREE(list->callbacks[i]);
+    }
+    VIR_FREE(list->callbacks);
+    VIR_FREE(list);
+}
+
+
+/**
+ * virObjectEventCallbackListRemoveID:
+ * @conn: pointer to the connection
+ * @cbList: the list
+ * @callback: the callback to remove
+ *
+ * Internal function to remove a callback from a virObjectEventCallbackListPtr
+ */
+static int
+virObjectEventCallbackListRemoveID(virConnectPtr conn,
+                                   virObjectEventCallbackListPtr cbList,
+                                   int callbackID)
+{
+    int ret = 0;
+    size_t i;
+    for (i = 0; i < cbList->count; i++) {
+        if (cbList->callbacks[i]->callbackID == callbackID &&
+            cbList->callbacks[i]->conn == conn) {
+            virFreeCallback freecb = cbList->callbacks[i]->freecb;
+            if (freecb)
+                (*freecb)(cbList->callbacks[i]->opaque);
+            virObjectUnref(cbList->callbacks[i]->conn);
+            VIR_FREE(cbList->callbacks[i]);
+
+            if (i < (cbList->count - 1))
+                memmove(cbList->callbacks + i,
+                        cbList->callbacks + i + 1,
+                        sizeof(*(cbList->callbacks)) *
+                                (cbList->count - (i + 1)));
+
+            if (VIR_REALLOC_N(cbList->callbacks,
+                              cbList->count - 1) < 0) {
+                ; /* Failure to reduce memory allocation isn't fatal */
+            }
+            cbList->count--;
+
+            for (i = 0; i < cbList->count; i++) {
+                if (!cbList->callbacks[i]->deleted)
+                    ret++;
+            }
+            return ret;
+        }
+    }
+
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("could not find event callback for removal"));
+    return -1;
+}
+
+
+static int
+virObjectEventCallbackListMarkDeleteID(virConnectPtr conn,
+                                       virObjectEventCallbackListPtr cbList,
+                                       int callbackID)
+{
+    int ret = 0;
+    size_t i;
+    for (i = 0; i < cbList->count; i++) {
+        if (cbList->callbacks[i]->callbackID == callbackID &&
+            cbList->callbacks[i]->conn == conn) {
+            cbList->callbacks[i]->deleted = 1;
+            for (i = 0; i < cbList->count; i++) {
+                if (!cbList->callbacks[i]->deleted)
+                    ret++;
+            }
+            return ret;
+        }
+    }
+
+    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                   _("could not find event callback for deletion"));
+    return -1;
+}
+
+
+static int
+virObjectEventCallbackListPurgeMarked(virObjectEventCallbackListPtr cbList)
+{
+    int old_count = cbList->count;
+    int n;
+    for (n = 0; n < cbList->count; n++) {
+        if (cbList->callbacks[n]->deleted) {
+            virFreeCallback freecb = cbList->callbacks[n]->freecb;
+            if (freecb)
+                (*freecb)(cbList->callbacks[n]->opaque);
+            virObjectUnref(cbList->callbacks[n]->conn);
+            VIR_FREE(cbList->callbacks[n]);
+
+            if (n < (cbList->count - 1))
+                memmove(cbList->callbacks + n,
+                        cbList->callbacks + n + 1,
+                        sizeof(*(cbList->callbacks)) *
+                                (cbList->count - (n + 1)));
+            cbList->count--;
+            n--;
+        }
+    }
+    if (cbList->count < old_count &&
+        VIR_REALLOC_N(cbList->callbacks, cbList->count) < 0) {
+        ; /* Failure to reduce memory allocation isn't fatal */
+    }
+    return 0;
+}
+
+
+/**
+ * virObjectEventCallbackListAddID:
+ * @conn: pointer to the connection
+ * @cbList: the list
+ * @eventID: the event ID
+ * @callback: the callback to add
+ * @opaque: opaque data tio pass to callback
+ * @callbackID: filled with callback ID
+ *
+ * Internal function to add a callback from a virObjectEventCallbackListPtr
+ */
+int
+virObjectEventCallbackListAddID(virConnectPtr conn,
+                                virObjectEventCallbackListPtr cbList,
+                                unsigned char uuid[VIR_UUID_BUFLEN],
+                                const char *name,
+                                int id,
+                                int eventID,
+                                virConnectObjectEventGenericCallback callback,
+                                void *opaque,
+                                virFreeCallback freecb,
+                                int *callbackID)
+{
+    virObjectEventCallbackPtr event;
+    size_t i;
+    int ret = 0;
+
+    /* Check incoming */
+    if (!cbList) {
+        return -1;
+    }
+
+    /* check if we already have this callback on our list */
+    for (i = 0; i < cbList->count; i++) {
+        if (cbList->callbacks[i]->cb == VIR_OBJECT_EVENT_CALLBACK(callback) &&
+            cbList->callbacks[i]->eventID == eventID &&
+            cbList->callbacks[i]->conn == conn &&
+            ((uuid && cbList->callbacks[i]->dom &&
+              memcmp(cbList->callbacks[i]->dom->uuid,
+                     uuid, VIR_UUID_BUFLEN) == 0) ||
+             (!uuid && !cbList->callbacks[i]->dom))) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("event callback already tracked"));
+            return -1;
+        }
+    }
+    /* Allocate new event */
+    if (VIR_ALLOC(event) < 0)
+        goto error;
+    event->conn = conn;
+    event->cb = callback;
+    event->eventID = eventID;
+    event->opaque = opaque;
+    event->freecb = freecb;
+
+    if (name && uuid && id > 0) {
+        if (VIR_ALLOC(event->dom) < 0)
+            goto error;
+        if (VIR_STRDUP(event->dom->name, name) < 0)
+            goto error;
+        memcpy(event->dom->uuid, uuid, VIR_UUID_BUFLEN);
+        event->dom->id = id;
+    }
+
+    /* Make space on list */
+    if (VIR_REALLOC_N(cbList->callbacks, cbList->count + 1) < 0)
+        goto error;
+
+    virObjectRef(event->conn);
+
+    cbList->callbacks[cbList->count] = event;
+    cbList->count++;
+
+    event->callbackID = cbList->nextID++;
+
+    for (i = 0; i < cbList->count; i++) {
+        if (cbList->callbacks[i]->eventID == eventID &&
+            cbList->callbacks[i]->conn == conn &&
+            !cbList->callbacks[i]->deleted)
+            ret++;
+    }
+
+    if (callbackID)
+        *callbackID = event->callbackID;
+
+    return ret;
+
+error:
+    if (event) {
+        if (event->dom)
+            VIR_FREE(event->dom->name);
+        VIR_FREE(event->dom);
+    }
+    VIR_FREE(event);
+    return -1;
+}
+
+static int
+virObjectEventCallbackListEventID(virConnectPtr conn,
+                                  virObjectEventCallbackListPtr cbList,
+                                  int callbackID)
+{
+    size_t i;
+
+    for (i = 0; i < cbList->count; i++) {
+        if (cbList->callbacks[i]->deleted)
+            continue;
+
+        if (cbList->callbacks[i]->callbackID == callbackID &&
+            cbList->callbacks[i]->conn == conn)
+            return cbList->callbacks[i]->eventID;
+    }
+
+    return -1;
+}
+
+static void
+virDomainEventDataFree(virObjectEventPtr event)
+{
+    switch (event->eventID) {
+    case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON:
+    case VIR_DOMAIN_EVENT_ID_IO_ERROR:
+        VIR_FREE(event->data.domainData.ioError.srcPath);
+        VIR_FREE(event->data.domainData.ioError.devAlias);
+        VIR_FREE(event->data.domainData.ioError.reason);
+        break;
+
+    case VIR_DOMAIN_EVENT_ID_GRAPHICS:
+        if (event->data.domainData.graphics.local) {
+            VIR_FREE(event->data.domainData.graphics.local->node);
+            VIR_FREE(event->data.domainData.graphics.local->service);
+            VIR_FREE(event->data.domainData.graphics.local);
+        }
+        if (event->data.domainData.graphics.remote) {
+            VIR_FREE(event->data.domainData.graphics.remote->node);
+            VIR_FREE(event->data.domainData.graphics.remote->service);
+            VIR_FREE(event->data.domainData.graphics.remote);
+        }
+        VIR_FREE(event->data.domainData.graphics.authScheme);
+        if (event->data.domainData.graphics.subject) {
+            size_t i;
+            for (i = 0; i < event->data.domainData.graphics.subject->nidentity; i++) {
+                VIR_FREE(event->data.domainData.graphics.subject->identities[i].type);
+                VIR_FREE(event->data.domainData.graphics.subject->identities[i].name);
+            }
+            VIR_FREE(event->data.domainData.graphics.subject);
+        }
+        break;
+
+    case VIR_DOMAIN_EVENT_ID_BLOCK_JOB:
+        VIR_FREE(event->data.domainData.blockJob.path);
+        break;
+
+    case VIR_DOMAIN_EVENT_ID_DISK_CHANGE:
+        VIR_FREE(event->data.domainData.diskChange.oldSrcPath);
+        VIR_FREE(event->data.domainData.diskChange.newSrcPath);
+        VIR_FREE(event->data.domainData.diskChange.devAlias);
+        break;
+    case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE:
+        VIR_FREE(event->data.domainData.trayChange.devAlias);
+        break;
+    case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED:
+        VIR_FREE(event->data.domainData.deviceRemoved.devAlias);
+        break;
+    }
+}
+
+void virObjectEventFree(virObjectEventPtr event)
+{
+    if (!event)
+        return;
+
+    int namespace = (event->eventID & 0xFF00) >> 8;
+    switch (namespace)
+    {
+        case VIR_EVENT_NAMESPACE_DOMAIN:
+            virDomainEventDataFree(event);
+            break;
+    }
+
+    VIR_FREE(event->dom.name);
+    VIR_FREE(event);
+}
+
+/**
+ * virObjectEventQueueClear:
+ * @queue: pointer to the queue
+ *
+ * Removes all elements from the queue
+ */
+void
+virObjectEventQueueClear(virObjectEventQueuePtr queue)
+{
+    size_t i;
+    if (!queue)
+        return;
+
+    for (i = 0; i < queue->count; i++) {
+        virObjectEventFree(queue->events[i]);
+    }
+    VIR_FREE(queue->events);
+    queue->count = 0;
+}
+
+/**
+ * virObjectEventQueueFree:
+ * @queue: pointer to the queue
+ *
+ * Free the memory in the queue. We process this like a list here
+ */
+static void
+virObjectEventQueueFree(virObjectEventQueuePtr queue)
+{
+    if (!queue)
+        return;
+
+    virObjectEventQueueClear(queue);
+    VIR_FREE(queue);
+}
+
+static virObjectEventQueuePtr
+virObjectEventQueueNew(void)
+{
+    virObjectEventQueuePtr ret;
+
+    ignore_value(VIR_ALLOC(ret));
+    return ret;
+}
+
+void
+virObjectEventStateLock(virObjectEventStatePtr state)
+{
+    virMutexLock(&state->lock);
+}
+
+void
+virObjectEventStateUnlock(virObjectEventStatePtr state)
+{
+    virMutexUnlock(&state->lock);
+}
+
+/**
+ * virObjectEventStateFree:
+ * @list: virObjectEventStatePtr to free
+ *
+ * Free a virObjectEventStatePtr and its members, and unregister the timer.
+ */
+void
+virObjectEventStateFree(virObjectEventStatePtr state)
+{
+    if (!state)
+        return;
+
+    virObjectEventCallbackListFree(state->callbacks);
+    virObjectEventQueueFree(state->queue);
+
+    if (state->timer != -1)
+        virEventRemoveTimeout(state->timer);
+
+    virMutexDestroy(&state->lock);
+    VIR_FREE(state);
+}
+
+
+static void virObjectEventStateFlush(virObjectEventStatePtr state);
+
+void
+virObjectEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque)
+{
+    virObjectEventStatePtr state = opaque;
+
+    virObjectEventStateFlush(state);
+}
+
+/**
+ * virObjectEventStateNew:
+ */
+virObjectEventStatePtr
+virObjectEventStateNew(void)
+{
+    virObjectEventStatePtr state = NULL;
+
+    if (VIR_ALLOC(state) < 0)
+        goto error;
+
+    if (virMutexInit(&state->lock) < 0) {
+        virReportSystemError(errno, "%s",
+                             _("unable to initialize state mutex"));
+        VIR_FREE(state);
+        goto error;
+    }
+
+    if (VIR_ALLOC(state->callbacks) < 0)
+        goto error;
+
+    if (!(state->queue = virObjectEventQueueNew()))
+        goto error;
+
+    state->timer = -1;
+
+    return state;
+
+error:
+    virObjectEventStateFree(state);
+    return NULL;
+}
+
+virObjectEventPtr virObjectEventNewInternal(int eventID,
+                                            int id,
+                                            const char *name,
+                                            const unsigned char *uuid)
+{
+    virObjectEventPtr event;
+
+    if (VIR_ALLOC(event) < 0)
+        return NULL;
+
+    event->eventID = eventID;
+    if (VIR_STRDUP(event->dom.name, name) < 0) {
+        VIR_FREE(event);
+        return NULL;
+    }
+    event->dom.id = id;
+    memcpy(event->dom.uuid, uuid, VIR_UUID_BUFLEN);
+
+    return event;
+}
+
+
+/**
+ * virObjectEventQueuePush:
+ * @evtQueue: the dom event queue
+ * @event: the event to add
+ *
+ * Internal function to push to the back of a virObjectEventQueue
+ *
+ * Returns: 0 on success, -1 on failure
+ */
+static int
+virObjectEventQueuePush(virObjectEventQueuePtr evtQueue,
+                        virObjectEventPtr event)
+{
+    if (!evtQueue) {
+        return -1;
+    }
+
+    /* Make space on queue */
+    if (VIR_REALLOC_N(evtQueue->events,
+                      evtQueue->count + 1) < 0)
+        return -1;
+
+    evtQueue->events[evtQueue->count] = event;
+    evtQueue->count++;
+    return 0;
+}
+
+
+typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn,
+                                           virObjectEventPtr event,
+                                           virConnectObjectEventGenericCallback cb,
+                                           void *cbopaque,
+                                           void *opaque);
+
+
+static void
+virDomainEventDispatchDefaultFunc(virConnectPtr conn,
+                                  virObjectEventPtr event,
+                                  virConnectDomainEventGenericCallback cb,
+                                  void *cbopaque,
+                                  void *opaque ATTRIBUTE_UNUSED)
+{
+    virDomainPtr dom = virGetDomain(conn, event->dom.name, event->dom.uuid);
+    if (!dom)
+        return;
+    dom->id = event->dom.id;
+
+    switch ((virDomainEventID) event->eventID) {
+    case VIR_DOMAIN_EVENT_ID_LIFECYCLE:
+        ((virConnectDomainEventCallback)cb)(conn, dom,
+                                            event->data.domainData.lifecycle.type,
+                                            event->data.domainData.lifecycle.detail,
+                                            cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_REBOOT:
+        (cb)(conn, dom,
+             cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_RTC_CHANGE:
+        ((virConnectDomainEventRTCChangeCallback)cb)(conn, dom,
+                                                     event->data.domainData.rtcChange.offset,
+                                                     cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_WATCHDOG:
+        ((virConnectDomainEventWatchdogCallback)cb)(conn, dom,
+                                                    event->data.domainData.watchdog.action,
+                                                    cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_IO_ERROR:
+        ((virConnectDomainEventIOErrorCallback)cb)(conn, dom,
+                                                   event->data.domainData.ioError.srcPath,
+                                                   event->data.domainData.ioError.devAlias,
+                                                   event->data.domainData.ioError.action,
+                                                   cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON:
+        ((virConnectDomainEventIOErrorReasonCallback)cb)(conn, dom,
+                                                         event->data.domainData.ioError.srcPath,
+                                                         event->data.domainData.ioError.devAlias,
+                                                         event->data.domainData.ioError.action,
+                                                         event->data.domainData.ioError.reason,
+                                                         cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_GRAPHICS:
+        ((virConnectDomainEventGraphicsCallback)cb)(conn, dom,
+                                                    event->data.domainData.graphics.phase,
+                                                    event->data.domainData.graphics.local,
+                                                    event->data.domainData.graphics.remote,
+                                                    event->data.domainData.graphics.authScheme,
+                                                    event->data.domainData.graphics.subject,
+                                                    cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_CONTROL_ERROR:
+        (cb)(conn, dom,
+             cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_BLOCK_JOB:
+        ((virConnectDomainEventBlockJobCallback)cb)(conn, dom,
+                                                    event->data.domainData.blockJob.path,
+                                                    event->data.domainData.blockJob.type,
+                                                    event->data.domainData.blockJob.status,
+                                                    cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_DISK_CHANGE:
+        ((virConnectDomainEventDiskChangeCallback)cb)(conn, dom,
+                                                      event->data.domainData.diskChange.oldSrcPath,
+                                                      event->data.domainData.diskChange.newSrcPath,
+                                                      event->data.domainData.diskChange.devAlias,
+                                                      event->data.domainData.diskChange.reason,
+                                                      cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE:
+        ((virConnectDomainEventTrayChangeCallback)cb)(conn, dom,
+                                                      event->data.domainData.trayChange.devAlias,
+                                                      event->data.domainData.trayChange.reason,
+                                                      cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_PMWAKEUP:
+        ((virConnectDomainEventPMWakeupCallback)cb)(conn, dom, 0, cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_PMSUSPEND:
+        ((virConnectDomainEventPMSuspendCallback)cb)(conn, dom, 0, cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE:
+        ((virConnectDomainEventBalloonChangeCallback)cb)(conn, dom,
+                                                         event->data.domainData.balloonChange.actual,
+                                                         cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK:
+        ((virConnectDomainEventPMSuspendDiskCallback)cb)(conn, dom, 0, cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED:
+        ((virConnectDomainEventDeviceRemovedCallback)cb)(conn, dom,
+                                                         event->data.domainData.deviceRemoved.devAlias,
+                                                         cbopaque);
+        goto cleanup;
+
+    case VIR_DOMAIN_EVENT_ID_LAST:
+        break;
+    }
+    VIR_WARN("Unexpected event ID %d", event->eventID);
+
+cleanup:
+    virDomainFree(dom);
+}
+
+
+static int virObjectEventDispatchMatchCallback(virObjectEventPtr event,
+                                               virObjectEventCallbackPtr cb)
+{
+    if (!cb)
+        return 0;
+    if (cb->deleted)
+        return 0;
+    if (cb->eventID != event->eventID)
+        return 0;
+
+    if (cb->dom) {
+        /* Deliberately ignoring 'id' for matching, since that
+         * will cause problems when a domain switches between
+         * running & shutoff states & ignoring 'name' since
+         * Xen sometimes renames guests during migration, thus
+         * leaving 'uuid' as the only truly reliable ID we can use*/
+
+        if (memcmp(event->dom.uuid, cb->dom->uuid, VIR_UUID_BUFLEN) == 0)
+            return 1;
+
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+
+static void
+virObjectEventDispatch(virObjectEventPtr event,
+                       virObjectEventCallbackListPtr callbacks,
+                       virObjectEventDispatchFunc dispatch,
+                       void *opaque)
+{
+    size_t i;
+    /* Cache this now, since we may be dropping the lock,
+       and have more callbacks added. We're guaranteed not
+       to have any removed */
+    int cbCount = callbacks->count;
+
+    for (i = 0; i < cbCount; i++) {
+        if (!virObjectEventDispatchMatchCallback(event, callbacks->callbacks[i]))
+            continue;
+
+        (*dispatch)(callbacks->callbacks[i]->conn,
+                    event,
+                    callbacks->callbacks[i]->cb,
+                    callbacks->callbacks[i]->opaque,
+                    opaque);
+    }
+}
+
+
+static void
+virObjectEventQueueDispatch(virObjectEventQueuePtr queue,
+                            virObjectEventCallbackListPtr callbacks,
+                            virObjectEventDispatchFunc dispatch,
+                            void *opaque)
+{
+    size_t i;
+
+    for (i = 0; i < queue->count; i++) {
+        virObjectEventDispatch(queue->events[i], callbacks, dispatch, opaque);
+        virObjectEventFree(queue->events[i]);
+    }
+    VIR_FREE(queue->events);
+    queue->count = 0;
+}
+
+void
+virObjectEventStateQueue(virObjectEventStatePtr state,
+                         virObjectEventPtr event)
+{
+    if (state->timer < 0) {
+        virObjectEventFree(event);
+        return;
+    }
+
+    virObjectEventStateLock(state);
+
+    if (virObjectEventQueuePush(state->queue, event) < 0) {
+        VIR_DEBUG("Error adding event to queue");
+        virObjectEventFree(event);
+    }
+
+    if (state->queue->count == 1)
+        virEventUpdateTimeout(state->timer, 0);
+    virObjectEventStateUnlock(state);
+}
+
+
+static void
+virObjectEventStateDispatchFunc(virConnectPtr conn,
+                                virObjectEventPtr event,
+                                virConnectObjectEventGenericCallback cb,
+                                void *cbopaque,
+                                void *opaque)
+{
+    virObjectEventStatePtr state = opaque;
+    virEventNamespaceID namespace = (event->eventID & 0xFF00) >> 8;
+
+    /* Drop the lock whle dispatching, for sake of re-entrancy */
+    virObjectEventStateUnlock(state);
+    switch (namespace)
+    {
+        case VIR_EVENT_NAMESPACE_DOMAIN:
+            virDomainEventDispatchDefaultFunc(conn, event,
+                    VIR_DOMAIN_EVENT_CALLBACK(cb), cbopaque, NULL);
+            break;
+    }
+    virObjectEventStateLock(state);
+}
+
+
+static void
+virObjectEventStateFlush(virObjectEventStatePtr state)
+{
+    virObjectEventQueue tempQueue;
+
+    virObjectEventStateLock(state);
+    state->isDispatching = true;
+
+    /* Copy the queue, so we're reentrant safe when dispatchFunc drops the
+     * driver lock */
+    tempQueue.count = state->queue->count;
+    tempQueue.events = state->queue->events;
+    state->queue->count = 0;
+    state->queue->events = NULL;
+    virEventUpdateTimeout(state->timer, -1);
+
+    virObjectEventQueueDispatch(&tempQueue,
+                                state->callbacks,
+                                virObjectEventStateDispatchFunc,
+                                state);
+
+    /* Purge any deleted callbacks */
+    virObjectEventCallbackListPurgeMarked(state->callbacks);
+
+    state->isDispatching = false;
+    virObjectEventStateUnlock(state);
+}
+
+
+/**
+ * virObjectEventStateRegisterID:
+ * @conn: connection to associate with callback
+ * @state: domain event state
+ * @eventID: ID of the event type to register for
+ * @cb: function to remove from event
+ * @opaque: data blob to pass to callback
+ * @freecb: callback to free @opaque
+ * @callbackID: filled with callback ID
+ *
+ * Register the function @callbackID with connection @conn,
+ * from @state, for events of type @eventID.
+ *
+ * Returns: the number of callbacks now registered, or -1 on error
+ */
+int
+virObjectEventStateRegisterID(virConnectPtr conn,
+                              virObjectEventStatePtr state,
+                              unsigned char uuid[VIR_UUID_BUFLEN],
+                              const char *name,
+                              int id,
+                              int eventID,
+                              virConnectObjectEventGenericCallback cb,
+                              void *opaque,
+                              virFreeCallback freecb,
+                              int *callbackID)
+{
+    int ret = -1;
+
+    virObjectEventStateLock(state);
+
+    if ((state->callbacks->count == 0) &&
+        (state->timer == -1) &&
+        (state->timer = virEventAddTimeout(-1,
+                                           virObjectEventTimer,
+                                           state,
+                                           NULL)) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("could not initialize domain event timer"));
+        goto cleanup;
+    }
+
+    ret = virObjectEventCallbackListAddID(conn, state->callbacks,
+                                          uuid, name, id, eventID, cb, opaque, freecb,
+                                          callbackID);
+
+    if (ret == -1 &&
+        state->callbacks->count == 0 &&
+        state->timer != -1) {
+        virEventRemoveTimeout(state->timer);
+        state->timer = -1;
+    }
+
+cleanup:
+    virObjectEventStateUnlock(state);
+    return ret;
+}
+
+
+/**
+ * virObjectEventStateDeregisterID:
+ * @conn: connection to associate with callback
+ * @state: domain event state
+ * @callbackID: ID of the function to remove from event
+ *
+ * Unregister the function @callbackID with connection @conn,
+ * from @state, for events.
+ *
+ * Returns: the number of callbacks still registered, or -1 on error
+ */
+int
+virObjectEventStateDeregisterID(virConnectPtr conn,
+                                virObjectEventStatePtr state,
+                                int callbackID)
+{
+    int ret;
+
+    virObjectEventStateLock(state);
+    if (state->isDispatching)
+        ret = virObjectEventCallbackListMarkDeleteID(conn,
+                                                     state->callbacks, callbackID);
+    else
+        ret = virObjectEventCallbackListRemoveID(conn,
+                                                 state->callbacks, callbackID);
+
+    if (state->callbacks->count == 0 &&
+        state->timer != -1) {
+        virEventRemoveTimeout(state->timer);
+        state->timer = -1;
+        virObjectEventQueueClear(state->queue);
+    }
+
+    virObjectEventStateUnlock(state);
+    return ret;
+}
+
+
+/**
+ * virObjectEventStateEventID:
+ * @conn: connection associated with the callback
+ * @state: domain event state
+ * @callbackID: the callback to query
+ *
+ * Query what event ID type is associated with the
+ * callback @callbackID for connection @conn
+ *
+ * Returns 0 on success, -1 on error
+ */
+int
+virObjectEventStateEventID(virConnectPtr conn,
+                           virObjectEventStatePtr state,
+                           int callbackID)
+{
+    int ret;
+
+    virObjectEventStateLock(state);
+    ret = virObjectEventCallbackListEventID(conn,
+                                            state->callbacks, callbackID);
+    virObjectEventStateUnlock(state);
+    return ret;
+}
diff --git a/src/conf/object_event.h b/src/conf/object_event.h
new file mode 100644
index 0000000..bf5727f
--- /dev/null
+++ b/src/conf/object_event.h
@@ -0,0 +1,93 @@
+/*
+ * domain_event.h: domain event queue processing helpers
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ * Copyright (C) 2008 VirtualIron
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Author: Ben Guthro
+ */
+
+#include "internal.h"
+
+#ifndef __OBJECT_EVENT_H__
+# define __OBJECT_EVENT_H__
+
+typedef struct _virObjectEventCallback virObjectEventCallback;
+typedef virObjectEventCallback *virObjectEventCallbackPtr;
+
+typedef struct _virObjectEventCallbackList virObjectEventCallbackList;
+typedef virObjectEventCallbackList *virObjectEventCallbackListPtr;
+
+/**
+ * Dispatching domain events that come in while
+ * in a call / response rpc
+ */
+typedef struct _virObjectEvent virObjectEvent;
+typedef virObjectEvent *virObjectEventPtr;
+
+typedef struct _virObjectEventQueue virObjectEventQueue;
+typedef virObjectEventQueue *virObjectEventQueuePtr;
+
+typedef struct _virObjectEventState virObjectEventState;
+typedef virObjectEventState *virObjectEventStatePtr;
+
+void virObjectEventFree(virObjectEventPtr event);
+
+void virObjectEventStateFree(virObjectEventStatePtr state);
+virObjectEventStatePtr
+virObjectEventStateNew(void);
+
+/*
+ * virConnectObjectEventGenericCallback:
+ * @conn: the connection pointer
+ * @obj: the object pointer
+ * @opaque: application specified data
+ *
+ * A generic object event callback handler. Specific events usually
+ * have a customization with extra parameters
+ */
+typedef void (*virConnectObjectEventGenericCallback)(virConnectPtr conn,
+                                                     void *obj,
+                                                     void *opaque);
+
+void
+virObjectEventStateQueue(virObjectEventStatePtr state,
+                         virObjectEventPtr event)
+    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+int virObjectEventStateRegisterID(virConnectPtr conn,
+                                  virObjectEventStatePtr state,
+                                  unsigned char uuid[VIR_UUID_BUFLEN],
+                                  const char *name,
+                                  int id,
+                                  int eventID,
+                                  virConnectObjectEventGenericCallback cb,
+                                  void *opaque,
+                                  virFreeCallback freecb,
+                                  int *callbackID)
+    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(7);
+int
+virObjectEventStateDeregisterID(virConnectPtr conn,
+                                virObjectEventStatePtr state,
+                                int callbackID)
+    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+int
+virObjectEventStateEventID(virConnectPtr conn,
+                           virObjectEventStatePtr state,
+                           int callbackID)
+    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+
+#endif
diff --git a/src/conf/object_event_private.h b/src/conf/object_event_private.h
new file mode 100644
index 0000000..8089155
--- /dev/null
+++ b/src/conf/object_event_private.h
@@ -0,0 +1,160 @@
+/*
+ * domain_event.h: domain event queue processing helpers
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ * Copyright (C) 2008 VirtualIron
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Author: Ben Guthro
+ */
+
+#ifndef __OBJECT_EVENT_PRIVATE_H__
+# define __OBJECT_EVENT_PRIVATE_H__
+
+#include "datatypes.h"
+
+#define VIR_OBJECT_EVENT_CALLBACK(cb) ((virConnectObjectEventGenericCallback)(cb))
+
+struct _virObjectMeta {
+    int id;
+    char *name;
+    unsigned char uuid[VIR_UUID_BUFLEN];
+};
+typedef struct _virObjectMeta virObjectMeta;
+typedef virObjectMeta *virObjectMetaPtr;
+
+struct _virObjectEventCallbackList {
+    unsigned int nextID;
+    unsigned int count;
+    virObjectEventCallbackPtr *callbacks;
+};
+
+struct _virObjectEventQueue {
+    unsigned int count;
+    virObjectEventPtr *events;
+};
+
+struct _virObjectEventState {
+    /* The list of domain event callbacks */
+    virObjectEventCallbackListPtr callbacks;
+    /* The queue of domain events */
+    virObjectEventQueuePtr queue;
+    /* Timer for flushing events queue */
+    int timer;
+    /* Flag if we're in process of dispatching */
+    bool isDispatching;
+    virMutex lock;
+};
+
+struct _virObjectEventCallback {
+    int callbackID;
+    int eventID;
+    virConnectPtr conn;
+    virObjectMetaPtr dom;
+    virConnectObjectEventGenericCallback cb;
+    void *opaque;
+    virFreeCallback freecb;
+    int deleted;
+};
+
+union virDomainEventData {
+    struct {
+        int type;
+        int detail;
+    } lifecycle;
+    struct {
+        long long offset;
+    } rtcChange;
+    struct {
+        int action;
+    } watchdog;
+    struct {
+        char *srcPath;
+        char *devAlias;
+        int action;
+        char *reason;
+    } ioError;
+    struct {
+        int phase;
+        virDomainEventGraphicsAddressPtr local;
+        virDomainEventGraphicsAddressPtr remote;
+        char *authScheme;
+        virDomainEventGraphicsSubjectPtr subject;
+    } graphics;
+    struct {
+        char *path;
+        int type;
+        int status;
+    } blockJob;
+    struct {
+        char *oldSrcPath;
+        char *newSrcPath;
+        char *devAlias;
+        int reason;
+    } diskChange;
+    struct {
+        char *devAlias;
+        int reason;
+    } trayChange;
+    struct {
+        /* In unit of 1024 bytes */
+        unsigned long long actual;
+    } balloonChange;
+    struct {
+        char *devAlias;
+    } deviceRemoved;
+};
+
+struct _virObjectEvent {
+    int eventID;
+
+    virObjectMeta dom;
+
+    union {
+        union virDomainEventData domainData;
+    } data;
+};
+
+virObjectEventPtr virObjectEventNewInternal(int eventID,
+                                            int id,
+                                            const char *name,
+                                            const unsigned char *uuid);
+
+int
+virObjectEventCallbackListAddID(virConnectPtr conn,
+                                virObjectEventCallbackListPtr cbList,
+                                unsigned char uuid[VIR_UUID_BUFLEN],
+                                const char *name,
+                                int id,
+                                int eventID,
+                                virConnectObjectEventGenericCallback callback,
+                                void *opaque,
+                                virFreeCallback freecb,
+                                int *callbackID);
+
+void
+virObjectEventStateLock(virObjectEventStatePtr state);
+
+void
+virObjectEventStateUnlock(virObjectEventStatePtr state);
+
+void
+virObjectEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque);
+
+void
+virObjectEventQueueClear(virObjectEventQueuePtr queue);
+
+#endif
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index a705c56..dc3882b 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -421,7 +421,6 @@ virDomainEventDeviceRemovedNewFromDom;
 virDomainEventDeviceRemovedNewFromObj;
 virDomainEventDiskChangeNewFromDom;
 virDomainEventDiskChangeNewFromObj;
-virDomainEventFree;
 virDomainEventGraphicsNewFromDom;
 virDomainEventGraphicsNewFromObj;
 virDomainEventIOErrorNewFromDom;
@@ -444,11 +443,6 @@ virDomainEventRebootNewFromObj;
 virDomainEventRTCChangeNewFromDom;
 virDomainEventRTCChangeNewFromObj;
 virDomainEventStateDeregister;
-virDomainEventStateDeregisterID;
-virDomainEventStateEventID;
-virDomainEventStateFree;
-virDomainEventStateNew;
-virDomainEventStateQueue;
 virDomainEventStateRegister;
 virDomainEventStateRegisterID;
 virDomainEventTrayChangeNewFromDom;
@@ -625,6 +619,15 @@ virNWFilterVarValueGetCardinality;
 virNWFilterVarValueGetNthValue;
 virNWFilterVarValueGetSimple;
 
+# conf/object_event.h
+virObjectEventFree;
+virObjectEventStateDeregisterID;
+virObjectEventStateEventID;
+virObjectEventStateFree;
+virObjectEventStateNew;
+virObjectEventStateQueue;
+virObjectEventStateRegisterID;
+
 
 # conf/secret_conf.h
 virSecretDefFormat;
diff --git a/src/libxl/libxl_conf.h b/src/libxl/libxl_conf.h
index 8ba0ee4..ffa93bd 100644
--- a/src/libxl/libxl_conf.h
+++ b/src/libxl/libxl_conf.h
@@ -105,7 +105,7 @@ struct _libxlDriverPrivate {
     virDomainXMLOptionPtr xmlopt;
 
     /* Immutable pointer, self-locking APIs */
-    virDomainEventStatePtr domainEventState;
+    virObjectEventStatePtr domainEventState;
 
     /* Immutable pointer, self-locking APIs */
     virPortAllocatorPtr reservedVNCPorts;
diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c
index 7a75a04..8ead663 100644
--- a/src/libxl/libxl_driver.c
+++ b/src/libxl/libxl_driver.c
@@ -100,9 +100,9 @@ libxlDomObjFromDomain(virDomainPtr dom)
 }
 
 static void
-libxlDomainEventQueue(libxlDriverPrivatePtr driver, virDomainEventPtr event)
+libxlDomainEventQueue(libxlDriverPrivatePtr driver, virObjectEventPtr event)
 {
-    virDomainEventStateQueue(driver->domainEventState, event);
+    virObjectEventStateQueue(driver->domainEventState, event);
 }
 
 static int
@@ -359,7 +359,7 @@ libxlEventHandler(void *data, VIR_LIBXL_EVENT_CONST libxl_event *event)
     libxlDriverPrivatePtr driver = libxl_driver;
     libxlDomainObjPrivatePtr priv = ((virDomainObjPtr)data)->privateData;
     virDomainObjPtr vm = NULL;
-    virDomainEventPtr dom_event = NULL;
+    virObjectEventPtr dom_event = NULL;
     libxl_shutdown_reason xl_reason = event->u.domain_shutdown.shutdown_reason;
 
     if (event->type == LIBXL_EVENT_TYPE_DOMAIN_SHUTDOWN) {
@@ -546,7 +546,7 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm,
 {
     libxl_domain_config d_config;
     virDomainDefPtr def = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     libxlSavefileHeader hdr;
     int ret;
     uint32_t domid = 0;
@@ -778,7 +778,7 @@ libxlStateCleanup(void)
     virObjectUnref(libxl_driver->domains);
     virObjectUnref(libxl_driver->reservedVNCPorts);
 
-    virDomainEventStateFree(libxl_driver->domainEventState);
+    virObjectEventStateFree(libxl_driver->domainEventState);
     virSysinfoDefFree(libxl_driver->hostsysinfo);
 
     virMutexDestroy(&libxl_driver->lock);
@@ -888,7 +888,7 @@ libxlStateInitialize(bool privileged,
     /* read the host sysinfo */
     libxl_driver->hostsysinfo = virSysinfoRead();
 
-    libxl_driver->domainEventState = virDomainEventStateNew();
+    libxl_driver->domainEventState = virObjectEventStateNew();
     if (!libxl_driver->domainEventState)
         goto error;
 
@@ -1298,7 +1298,7 @@ libxlDomainSuspend(virDomainPtr dom)
     libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
     virDomainObjPtr vm;
     libxlDomainObjPrivatePtr priv;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     if (!(vm = libxlDomObjFromDomain(dom)))
@@ -1350,7 +1350,7 @@ libxlDomainResume(virDomainPtr dom)
     libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
     virDomainObjPtr vm;
     libxlDomainObjPrivatePtr priv;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     if (!(vm = libxlDomObjFromDomain(dom)))
@@ -1485,7 +1485,7 @@ libxlDomainDestroyFlags(virDomainPtr dom,
     libxlDriverPrivatePtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
     int ret = -1;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     virCheckFlags(0, -1);
 
@@ -1773,7 +1773,7 @@ libxlDoDomainSave(libxlDriverPrivatePtr driver, virDomainObjPtr vm,
 {
     libxlDomainObjPrivatePtr priv = vm->privateData;
     libxlSavefileHeader hdr;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     char *xml = NULL;
     uint32_t xml_len;
     int fd = -1;
@@ -1963,7 +1963,7 @@ libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags)
     libxlDriverPrivatePtr driver = dom->conn->privateData;
     libxlDomainObjPrivatePtr priv;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     bool paused = false;
     int ret = -1;
 
@@ -2665,7 +2665,7 @@ libxlDomainDefineXML(virConnectPtr conn, const char *xml)
     virDomainDefPtr def = NULL;
     virDomainObjPtr vm = NULL;
     virDomainPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virDomainDefPtr oldDef = NULL;
 
     /* Lock the driver until the virDomainObj is created and locked */
@@ -2726,7 +2726,7 @@ libxlDomainUndefineFlags(virDomainPtr dom,
     libxlDriverPrivatePtr driver = dom->conn->privateData;
     libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     char *name = NULL;
     int ret = -1;
 
@@ -4145,7 +4145,7 @@ libxlConnectDomainEventDeregisterAny(virConnectPtr conn, int callbackID)
     if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
         return -1;
 
-    ret = virDomainEventStateDeregisterID(conn,
+    ret = virObjectEventStateDeregisterID(conn,
                                           driver->domainEventState,
                                           callbackID);
 
diff --git a/src/lxc/lxc_conf.h b/src/lxc/lxc_conf.h
index a6208a2..f6cbfc9 100644
--- a/src/lxc/lxc_conf.h
+++ b/src/lxc/lxc_conf.h
@@ -97,7 +97,7 @@ struct _virLXCDriver {
     virUSBDeviceListPtr activeUsbHostdevs;
 
     /* Immutable pointer, self-locking APIs */
-    virDomainEventStatePtr domainEventState;
+    virObjectEventStatePtr domainEventState;
 
     /* Immutable pointer. self-locking APIs */
     virSecurityManagerPtr securityManager;
diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c
index 61a90ca..f65e7d6 100644
--- a/src/lxc/lxc_driver.c
+++ b/src/lxc/lxc_driver.c
@@ -441,7 +441,7 @@ static virDomainPtr lxcDomainDefineXML(virConnectPtr conn, const char *xml)
     virDomainDefPtr def = NULL;
     virDomainObjPtr vm = NULL;
     virDomainPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virDomainDefPtr oldDef = NULL;
     virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
     virCapsPtr caps = NULL;
@@ -496,7 +496,7 @@ cleanup:
     if (vm)
         virObjectUnlock(vm);
     if (event)
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
     virObjectUnref(caps);
     virObjectUnref(cfg);
     return dom;
@@ -507,7 +507,7 @@ static int lxcDomainUndefineFlags(virDomainPtr dom,
 {
     virLXCDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
 
@@ -547,7 +547,7 @@ cleanup:
     if (vm)
         virObjectUnlock(vm);
     if (event)
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
     virObjectUnref(cfg);
     return ret;
 }
@@ -902,7 +902,7 @@ static int lxcDomainCreateWithFiles(virDomainPtr dom,
 {
     virLXCDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
 
@@ -944,7 +944,7 @@ cleanup:
     if (vm)
         virObjectUnlock(vm);
     if (event)
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
     virObjectUnref(cfg);
     return ret;
 }
@@ -996,7 +996,7 @@ lxcDomainCreateXMLWithFiles(virConnectPtr conn,
     virDomainObjPtr vm = NULL;
     virDomainDefPtr def = NULL;
     virDomainPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
     virCapsPtr caps = NULL;
 
@@ -1054,7 +1054,7 @@ cleanup:
     if (vm)
         virObjectUnlock(vm);
     if (event)
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
     virObjectUnref(caps);
     virObjectUnref(cfg);
     return dom;
@@ -1245,7 +1245,7 @@ lxcConnectDomainEventDeregisterAny(virConnectPtr conn,
     if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
         return -1;
 
-    ret = virDomainEventStateDeregisterID(conn,
+    ret = virObjectEventStateDeregisterID(conn,
                                           driver->domainEventState,
                                           callbackID);
 
@@ -1268,7 +1268,7 @@ lxcDomainDestroyFlags(virDomainPtr dom,
 {
     virLXCDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     virLXCDomainObjPrivatePtr priv;
 
@@ -1302,7 +1302,7 @@ cleanup:
     if (vm)
         virObjectUnlock(vm);
     if (event)
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
     return ret;
 }
 
@@ -1398,7 +1398,7 @@ static int lxcStateInitialize(bool privileged,
     if (!(lxc_driver->domains = virDomainObjListNew()))
         goto cleanup;
 
-    lxc_driver->domainEventState = virDomainEventStateNew();
+    lxc_driver->domainEventState = virObjectEventStateNew();
     if (!lxc_driver->domainEventState)
         goto cleanup;
 
@@ -1481,12 +1481,12 @@ static void lxcNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
     virLXCDriverPtr driver = opaque;
 
     if (newVM) {
-        virDomainEventPtr event =
+        virObjectEventPtr event =
             virDomainEventNewFromObj(vm,
                                      VIR_DOMAIN_EVENT_DEFINED,
                                      VIR_DOMAIN_EVENT_DEFINED_ADDED);
         if (event)
-            virDomainEventStateQueue(driver->domainEventState, event);
+            virObjectEventStateQueue(driver->domainEventState, event);
     }
 }
 
@@ -1528,7 +1528,7 @@ static int lxcStateCleanup(void)
 
     virNWFilterUnRegisterCallbackDriver(&lxcCallbackDriver);
     virObjectUnref(lxc_driver->domains);
-    virDomainEventStateFree(lxc_driver->domainEventState);
+    virObjectEventStateFree(lxc_driver->domainEventState);
 
     virObjectUnref(lxc_driver->closeCallbacks);
 
@@ -2337,7 +2337,7 @@ static int lxcDomainSuspend(virDomainPtr dom)
 {
     virLXCDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
 
@@ -2372,7 +2372,7 @@ static int lxcDomainSuspend(virDomainPtr dom)
 
 cleanup:
     if (event)
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
     if (vm)
         virObjectUnlock(vm);
     virObjectUnref(cfg);
@@ -2383,7 +2383,7 @@ static int lxcDomainResume(virDomainPtr dom)
 {
     virLXCDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     virLXCDomainObjPrivatePtr priv;
     virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
@@ -2422,7 +2422,7 @@ static int lxcDomainResume(virDomainPtr dom)
 
 cleanup:
     if (event)
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
     if (vm)
         virObjectUnlock(vm);
     virObjectUnref(cfg);
diff --git a/src/lxc/lxc_process.c b/src/lxc/lxc_process.c
index c51c4d5..db85863 100644
--- a/src/lxc/lxc_process.c
+++ b/src/lxc/lxc_process.c
@@ -62,7 +62,7 @@ lxcProcessAutoDestroy(virDomainObjPtr dom,
                       void *opaque)
 {
     virLXCDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virLXCDomainObjPrivatePtr priv;
 
     VIR_DEBUG("driver=%p dom=%s conn=%p", driver, dom->def->name, conn);
@@ -82,7 +82,7 @@ lxcProcessAutoDestroy(virDomainObjPtr dom,
     }
 
     if (event)
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
 
     return dom;
 }
@@ -490,7 +490,7 @@ static void virLXCProcessMonitorEOFNotify(virLXCMonitorPtr mon,
                                           virDomainObjPtr vm)
 {
     virLXCDriverPtr driver = lxc_driver;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virLXCDomainObjPrivatePtr priv;
 
     VIR_DEBUG("mon=%p vm=%p", mon, vm);
@@ -533,7 +533,7 @@ static void virLXCProcessMonitorEOFNotify(virLXCMonitorPtr mon,
     if (vm)
         virObjectUnlock(vm);
     if (event) {
-        virDomainEventStateQueue(driver->domainEventState, event);
+        virObjectEventStateQueue(driver->domainEventState, event);
     }
 }
 
@@ -1394,12 +1394,12 @@ virLXCProcessAutostartDomain(virDomainObjPtr vm,
                       vm->def->name,
                       err ? err->message : "");
         } else {
-            virDomainEventPtr event =
+            virObjectEventPtr event =
                 virDomainEventNewFromObj(vm,
                                          VIR_DOMAIN_EVENT_STARTED,
                                          VIR_DOMAIN_EVENT_STARTED_BOOTED);
             if (event)
-                virDomainEventStateQueue(data->driver->domainEventState, event);
+                virObjectEventStateQueue(data->driver->domainEventState, event);
         }
     }
     virObjectUnlock(vm);
diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h
index 12403ea..6215553 100644
--- a/src/parallels/parallels_utils.h
+++ b/src/parallels/parallels_utils.h
@@ -44,7 +44,7 @@ struct _parallelsConn {
     virNetworkObjList networks;
     virCapsPtr caps;
     virDomainXMLOptionPtr xmlopt;
-    virDomainEventStatePtr domainEventState;
+    virObjectEventStatePtr domainEventState;
 };
 
 typedef struct _parallelsConn parallelsConn;
diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h
index f9ff7af..f26f7b9 100644
--- a/src/qemu/qemu_conf.h
+++ b/src/qemu/qemu_conf.h
@@ -207,7 +207,7 @@ struct _virQEMUDriver {
     virQEMUCapsCachePtr qemuCapsCache;
 
     /* Immutable pointer, self-locking APIs */
-    virDomainEventStatePtr domainEventState;
+    virObjectEventStatePtr domainEventState;
 
     /* Immutable pointer. self-locking APIs */
     virSecurityManagerPtr securityManager;
diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index 81d0ba9..d4fd6d1 100644
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -118,9 +118,9 @@ qemuDomainAsyncJobPhaseFromString(enum qemuDomainAsyncJob job,
 
 
 void qemuDomainEventQueue(virQEMUDriverPtr driver,
-                          virDomainEventPtr event)
+                          virObjectEventPtr event)
 {
-    virDomainEventStateQueue(driver->domainEventState, event);
+    virObjectEventStateQueue(driver->domainEventState, event);
 }
 
 
@@ -2114,7 +2114,7 @@ qemuDomainCheckRemoveOptionalDisk(virQEMUDriverPtr driver,
                                   virDomainDiskDefPtr disk)
 {
     char uuid[VIR_UUID_STRING_BUFLEN];
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virDomainDiskDefPtr del_disk = NULL;
 
     virUUIDFormat(vm->def->uuid, uuid);
diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h
index 77e0c20..6a92351 100644
--- a/src/qemu/qemu_domain.h
+++ b/src/qemu/qemu_domain.h
@@ -196,7 +196,7 @@ int qemuDomainAsyncJobPhaseFromString(enum qemuDomainAsyncJob job,
 void qemuDomainEventFlush(int timer, void *opaque);
 
 void qemuDomainEventQueue(virQEMUDriverPtr driver,
-                          virDomainEventPtr event);
+                          virObjectEventPtr event);
 
 int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
                           virDomainObjPtr obj,
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 378b542..6292cf2 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -597,7 +597,7 @@ qemuStateInitialize(bool privileged,
         goto error;
 
     /* Init domain events */
-    qemu_driver->domainEventState = virDomainEventStateNew();
+    qemu_driver->domainEventState = virObjectEventStateNew();
     if (!qemu_driver->domainEventState)
         goto error;
 
@@ -878,7 +878,7 @@ static void qemuNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
     virQEMUDriverPtr driver = opaque;
 
     if (newVM) {
-        virDomainEventPtr event =
+        virObjectEventPtr event =
             virDomainEventNewFromObj(vm,
                                      VIR_DOMAIN_EVENT_DEFINED,
                                      VIR_DOMAIN_EVENT_DEFINED_ADDED);
@@ -1015,7 +1015,7 @@ qemuStateCleanup(void) {
     ebtablesContextFree(qemu_driver->ebtables);
 
     /* Free domain callback list */
-    virDomainEventStateFree(qemu_driver->domainEventState);
+    virObjectEventStateFree(qemu_driver->domainEventState);
 
     virLockManagerPluginUnref(qemu_driver->lockManager);
 
@@ -1566,8 +1566,8 @@ static virDomainPtr qemuDomainCreateXML(virConnectPtr conn,
     virDomainDefPtr def = NULL;
     virDomainObjPtr vm = NULL;
     virDomainPtr dom = NULL;
-    virDomainEventPtr event = NULL;
-    virDomainEventPtr event2 = NULL;
+    virObjectEventPtr event = NULL;
+    virObjectEventPtr event2 = NULL;
     unsigned int start_flags = VIR_QEMU_PROCESS_START_COLD;
     virQEMUCapsPtr qemuCaps = NULL;
     virCapsPtr caps = NULL;
@@ -1668,7 +1668,7 @@ static int qemuDomainSuspend(virDomainPtr dom) {
     virQEMUDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
     int ret = -1;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     qemuDomainObjPrivatePtr priv;
     virDomainPausedReason reason;
     int eventDetail;
@@ -1749,7 +1749,7 @@ static int qemuDomainResume(virDomainPtr dom) {
     virQEMUDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
     int ret = -1;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int state;
     virQEMUDriverConfigPtr cfg = NULL;
     virCapsPtr caps = NULL;
@@ -2074,7 +2074,7 @@ qemuDomainDestroyFlags(virDomainPtr dom,
     virQEMUDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
     int ret = -1;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     qemuDomainObjPrivatePtr priv;
 
     virCheckFlags(VIR_DOMAIN_DESTROY_GRACEFUL, -1);
@@ -3037,7 +3037,7 @@ qemuDomainSaveInternal(virQEMUDriverPtr driver, virDomainPtr dom,
     bool was_running = false;
     int ret = -1;
     int rc;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     qemuDomainObjPrivatePtr priv = vm->privateData;
     virCapsPtr caps;
 
@@ -3517,7 +3517,7 @@ static int qemuDomainCoreDump(virDomainPtr dom,
     qemuDomainObjPrivatePtr priv;
     bool resume = false, paused = false;
     int ret = -1;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     virCheckFlags(VIR_DUMP_LIVE | VIR_DUMP_CRASH |
                   VIR_DUMP_BYPASS_CACHE | VIR_DUMP_RESET |
@@ -3822,7 +3822,7 @@ processGuestPanicEvent(virQEMUDriverPtr driver,
                        int action)
 {
     qemuDomainObjPrivatePtr priv = vm->privateData;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     if (!virDomainObjIsActive(vm)) {
@@ -5336,7 +5336,7 @@ qemuDomainSaveImageStartVM(virConnectPtr conn,
                            bool start_paused)
 {
     int ret = -1;
-    virDomainEventPtr event;
+    virObjectEventPtr event;
     int intermediatefd = -1;
     virCommandPtr cmd = NULL;
     char *errbuf = NULL;
@@ -6056,7 +6056,7 @@ qemuDomainObjStart(virConnectPtr conn,
                            VIR_NETDEV_VPORT_PROFILE_OP_CREATE, start_flags);
     virDomainAuditStart(vm, "booted", ret >= 0);
     if (ret >= 0) {
-        virDomainEventPtr event =
+        virObjectEventPtr event =
             virDomainEventNewFromObj(vm,
                                      VIR_DOMAIN_EVENT_STARTED,
                                      VIR_DOMAIN_EVENT_STARTED_BOOTED);
@@ -6131,7 +6131,7 @@ static virDomainPtr qemuDomainDefineXML(virConnectPtr conn, const char *xml) {
     virDomainDefPtr oldDef = NULL;
     virDomainObjPtr vm = NULL;
     virDomainPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virQEMUCapsPtr qemuCaps = NULL;
     virQEMUDriverConfigPtr cfg;
     virCapsPtr caps = NULL;
@@ -6224,7 +6224,7 @@ qemuDomainUndefineFlags(virDomainPtr dom,
 {
     virQEMUDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     char *name = NULL;
     int ret = -1;
     int nsnapshots;
@@ -9949,7 +9949,7 @@ qemuConnectDomainEventDeregisterAny(virConnectPtr conn,
     if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
         goto cleanup;
 
-    if (virDomainEventStateDeregisterID(conn,
+    if (virObjectEventStateDeregisterID(conn,
                                         driver->domainEventState,
                                         callbackID) < 0)
         goto cleanup;
@@ -11661,7 +11661,7 @@ qemuDomainSnapshotCreateActiveInternal(virConnectPtr conn,
 {
     virDomainObjPtr vm = *vmptr;
     qemuDomainObjPrivatePtr priv = vm->privateData;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     bool resume = false;
     int ret = -1;
 
@@ -12247,7 +12247,7 @@ qemuDomainSnapshotCreateActiveExternal(virConnectPtr conn,
 
     /* the snapshot is complete now */
     if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) {
-        virDomainEventPtr event;
+        virObjectEventPtr event;
 
         event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED,
                                          VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT);
@@ -12265,7 +12265,7 @@ qemuDomainSnapshotCreateActiveExternal(virConnectPtr conn,
         /* qemu 1.3 is unable to save a domain in pm-suspended (S3)
          * state; so we must emit an event stating that it was
          * converted to paused.  */
-        virDomainEventPtr event;
+        virObjectEventPtr event;
 
         virDomainObjSetState(vm, VIR_DOMAIN_PAUSED,
                              VIR_DOMAIN_PAUSED_FROM_SNAPSHOT);
@@ -12282,7 +12282,7 @@ endjob:
         qemuProcessStartCPUs(driver, vm, conn,
                              VIR_DOMAIN_RUNNING_UNPAUSED,
                              QEMU_ASYNC_JOB_SNAPSHOT) < 0) {
-        virDomainEventPtr event = NULL;
+        virObjectEventPtr event = NULL;
         event = virDomainEventNewFromObj(vm,
                                          VIR_DOMAIN_EVENT_SUSPENDED,
                                          VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR);
@@ -12942,8 +12942,8 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
     virDomainObjPtr vm = NULL;
     int ret = -1;
     virDomainSnapshotObjPtr snap = NULL;
-    virDomainEventPtr event = NULL;
-    virDomainEventPtr event2 = NULL;
+    virObjectEventPtr event = NULL;
+    virObjectEventPtr event2 = NULL;
     int detail;
     qemuDomainObjPrivatePtr priv;
     int rc;
@@ -13164,7 +13164,7 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
                                       QEMU_ASYNC_JOB_NONE);
             if (rc < 0)
                 goto endjob;
-            virDomainEventFree(event);
+            virObjectEventFree(event);
             event = NULL;
             if (was_stopped) {
                 /* Transition 2 */
@@ -13898,7 +13898,7 @@ cleanup:
         qemuProcessStartCPUs(driver, vm, conn,
                              VIR_DOMAIN_RUNNING_UNPAUSED,
                              QEMU_ASYNC_JOB_NONE) < 0) {
-        virDomainEventPtr event = NULL;
+        virObjectEventPtr event = NULL;
         event = virDomainEventNewFromObj(vm,
                                          VIR_DOMAIN_EVENT_SUSPENDED,
                                          VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR);
@@ -13925,7 +13925,7 @@ qemuDomainBlockJobImpl(virDomainObjPtr vm,
     char *device = NULL;
     int ret = -1;
     bool async = false;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int idx;
     virDomainDiskDefPtr disk;
 
diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c
index 0d9a3aa..84c2055 100644
--- a/src/qemu/qemu_hotplug.c
+++ b/src/qemu/qemu_hotplug.c
@@ -2406,7 +2406,7 @@ qemuDomainRemoveDiskDevice(virQEMUDriverPtr driver,
                            virDomainDiskDefPtr disk)
 {
     virDomainDeviceDef dev;
-    virDomainEventPtr event;
+    virObjectEventPtr event;
     size_t i;
 
     VIR_DEBUG("Removing disk %s from domain %p %s",
@@ -2450,7 +2450,7 @@ qemuDomainRemoveControllerDevice(virQEMUDriverPtr driver,
                                  virDomainObjPtr vm,
                                  virDomainControllerDefPtr controller)
 {
-    virDomainEventPtr event;
+    virObjectEventPtr event;
     size_t i;
 
     VIR_DEBUG("Removing controller %s from domain %p %s",
@@ -2538,7 +2538,7 @@ qemuDomainRemoveHostDevice(virQEMUDriverPtr driver,
 {
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
     virDomainNetDefPtr net = NULL;
-    virDomainEventPtr event;
+    virObjectEventPtr event;
     size_t i;
 
     VIR_DEBUG("Removing host device %s from domain %p %s",
@@ -2609,7 +2609,7 @@ qemuDomainRemoveNetDevice(virQEMUDriverPtr driver,
 {
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
     virNetDevVPortProfilePtr vport;
-    virDomainEventPtr event;
+    virObjectEventPtr event;
     size_t i;
 
     if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
@@ -2674,7 +2674,7 @@ qemuDomainRemoveChrDevice(virQEMUDriverPtr driver,
                           virDomainObjPtr vm,
                           virDomainChrDefPtr chr)
 {
-    virDomainEventPtr event;
+    virObjectEventPtr event;
 
     VIR_DEBUG("Removing character device %s from domain %p %s",
               chr->info.alias, vm, vm->def->name);
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index e87ea85..b998667 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -1511,7 +1511,7 @@ qemuMigrationSetOffline(virQEMUDriverPtr driver,
     ret = qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_MIGRATION,
                               QEMU_ASYNC_JOB_MIGRATION_OUT);
     if (ret == 0) {
-        virDomainEventPtr event;
+        virObjectEventPtr event;
 
         event = virDomainEventNewFromObj(vm,
                                          VIR_DOMAIN_EVENT_SUSPENDED,
@@ -2169,7 +2169,7 @@ qemuMigrationPrepareAny(virQEMUDriverPtr driver,
                         unsigned long flags)
 {
     virDomainObjPtr vm = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     int dataFD[2] = { -1, -1 };
     qemuDomainObjPrivatePtr priv = NULL;
@@ -2708,7 +2708,7 @@ qemuMigrationConfirmPhase(virQEMUDriverPtr driver,
                           int retcode)
 {
     qemuMigrationCookiePtr mig;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int rv = -1;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
@@ -4061,7 +4061,7 @@ qemuMigrationPerformJob(virQEMUDriverPtr driver,
                         unsigned long resource,
                         bool v3proto)
 {
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     int resume = 0;
     virErrorPtr orig_err = NULL;
@@ -4175,7 +4175,7 @@ qemuMigrationPerformPhase(virQEMUDriverPtr driver,
                           unsigned long flags,
                           unsigned long resource)
 {
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     bool resume;
     bool hasrefs;
@@ -4371,7 +4371,7 @@ qemuMigrationFinish(virQEMUDriverPtr driver,
                     bool v3proto)
 {
     virDomainPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     bool newVM = true;
     qemuMigrationCookiePtr mig = NULL;
     virErrorPtr orig_err = NULL;
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index a26c079..e9b1246 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -286,7 +286,7 @@ qemuProcessHandleMonitorEOF(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                             void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     qemuDomainObjPrivatePtr priv;
     int eventReason = VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN;
     int stopReason = VIR_DOMAIN_SHUTOFF_SHUTDOWN;
@@ -348,7 +348,7 @@ qemuProcessHandleMonitorError(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                               void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name);
 
@@ -516,7 +516,7 @@ qemuProcessHandleReset(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                        void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event;
+    virObjectEventPtr event;
     qemuDomainObjPrivatePtr priv;
 
     virObjectLock(vm);
@@ -549,7 +549,7 @@ qemuProcessFakeReboot(void *opaque)
     virQEMUDriverPtr driver = qemu_driver;
     virDomainObjPtr vm = opaque;
     qemuDomainObjPrivatePtr priv = vm->privateData;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
     virDomainRunningReason reason = VIR_DOMAIN_RUNNING_BOOTED;
     int ret = -1;
@@ -648,7 +648,7 @@ qemuProcessHandleShutdown(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
 {
     virQEMUDriverPtr driver = opaque;
     qemuDomainObjPrivatePtr priv;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     VIR_DEBUG("vm=%p", vm);
@@ -702,7 +702,7 @@ qemuProcessHandleStop(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                       void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     virObjectLock(vm);
@@ -749,7 +749,7 @@ qemuProcessHandleResume(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                         void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     virObjectLock(vm);
@@ -803,7 +803,7 @@ qemuProcessHandleRTCChange(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                            void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     virObjectLock(vm);
@@ -844,8 +844,8 @@ qemuProcessHandleWatchdog(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                           void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr watchdogEvent = NULL;
-    virDomainEventPtr lifecycleEvent = NULL;
+    virObjectEventPtr watchdogEvent = NULL;
+    virObjectEventPtr lifecycleEvent = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     virObjectLock(vm);
@@ -911,9 +911,9 @@ qemuProcessHandleIOError(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                          void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr ioErrorEvent = NULL;
-    virDomainEventPtr ioErrorEvent2 = NULL;
-    virDomainEventPtr lifecycleEvent = NULL;
+    virObjectEventPtr ioErrorEvent = NULL;
+    virObjectEventPtr ioErrorEvent2 = NULL;
+    virObjectEventPtr lifecycleEvent = NULL;
     const char *srcPath;
     const char *devAlias;
     virDomainDiskDefPtr disk;
@@ -972,7 +972,7 @@ qemuProcessHandleBlockJob(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                           void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     const char *path;
     virDomainDiskDefPtr disk;
 
@@ -1025,7 +1025,7 @@ qemuProcessHandleGraphics(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                           void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event;
+    virObjectEventPtr event;
     virDomainEventGraphicsAddressPtr localAddr = NULL;
     virDomainEventGraphicsAddressPtr remoteAddr = NULL;
     virDomainEventGraphicsSubjectPtr subject = NULL;
@@ -1104,7 +1104,7 @@ qemuProcessHandleTrayChange(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                             void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virDomainDiskDefPtr disk;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
@@ -1140,8 +1140,8 @@ qemuProcessHandlePMWakeup(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                           void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
-    virDomainEventPtr lifecycleEvent = NULL;
+    virObjectEventPtr event = NULL;
+    virObjectEventPtr lifecycleEvent = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     virObjectLock(vm);
@@ -1181,8 +1181,8 @@ qemuProcessHandlePMSuspend(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                            void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
-    virDomainEventPtr lifecycleEvent = NULL;
+    virObjectEventPtr event = NULL;
+    virObjectEventPtr lifecycleEvent = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     virObjectLock(vm);
@@ -1226,7 +1226,7 @@ qemuProcessHandleBalloonChange(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     virObjectLock(vm);
@@ -1253,8 +1253,8 @@ qemuProcessHandlePMSuspendDisk(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                void *opaque)
 {
     virQEMUDriverPtr driver = opaque;
-    virDomainEventPtr event = NULL;
-    virDomainEventPtr lifecycleEvent = NULL;
+    virObjectEventPtr event = NULL;
+    virObjectEventPtr lifecycleEvent = NULL;
     virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
 
     virObjectLock(vm);
@@ -4628,7 +4628,7 @@ qemuProcessAutoDestroy(virDomainObjPtr dom,
 {
     virQEMUDriverPtr driver = opaque;
     qemuDomainObjPrivatePtr priv = dom->privateData;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     VIR_DEBUG("vm=%s, conn=%p", dom->def->name, conn);
 
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 7181949..0074f46 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -92,7 +92,7 @@ struct private_data {
     char *hostname;             /* Original hostname */
     bool serverKeepAlive;       /* Does server support keepalive protocol? */
 
-    virDomainEventStatePtr domainEventState;
+    virObjectEventStatePtr domainEventState;
 };
 
 enum {
@@ -150,7 +150,7 @@ static void make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virSto
 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 remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event);
+static void remoteDomainEventQueue(struct private_data *priv, virObjectEventPtr event);
 /*----------------------------------------------------------------------*/
 
 /* Helper functions for remoteOpen. */
@@ -880,7 +880,7 @@ doRemoteOpen(virConnectPtr conn,
             goto failed;
     }
 
-    if (!(priv->domainEventState = virDomainEventStateNew()))
+    if (!(priv->domainEventState = virObjectEventStateNew()))
         goto failed;
 
     /* Successful. */
@@ -1081,7 +1081,7 @@ doRemoteClose(virConnectPtr conn, struct private_data *priv)
     /* See comment for remoteType. */
     VIR_FREE(priv->type);
 
-    virDomainEventStateFree(priv->domainEventState);
+    virObjectEventStateFree(priv->domainEventState);
     priv->domainEventState = NULL;
 
     return ret;
@@ -4369,7 +4369,7 @@ remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_lifecycle_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4391,7 +4391,7 @@ remoteDomainBuildEventReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_reboot_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4413,7 +4413,7 @@ remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_rtc_change_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4435,7 +4435,7 @@ remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_watchdog_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4457,7 +4457,7 @@ remoteDomainBuildEventIOError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_io_error_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4482,7 +4482,7 @@ remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog ATTRIBUTE_UNUSED
     struct private_data *priv = conn->privateData;
     remote_domain_event_io_error_reason_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn,msg->dom);
     if (!dom)
@@ -4508,7 +4508,7 @@ remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_block_job_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4531,7 +4531,7 @@ remoteDomainBuildEventGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_graphics_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virDomainEventGraphicsAddressPtr localAddr = NULL;
     virDomainEventGraphicsAddressPtr remoteAddr = NULL;
     virDomainEventGraphicsSubjectPtr subject = NULL;
@@ -4611,7 +4611,7 @@ remoteDomainBuildEventControlError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_control_error_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4634,7 +4634,7 @@ remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_disk_change_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4661,7 +4661,7 @@ remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_tray_change_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4685,7 +4685,7 @@ remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_pmwakeup_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4707,7 +4707,7 @@ remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     struct private_data *priv = conn->privateData;
     remote_domain_event_pmsuspend_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4730,7 +4730,7 @@ remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED
     struct private_data *priv = conn->privateData;
     remote_domain_event_balloon_change_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4752,7 +4752,7 @@ remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog ATTRIBUTE_UNUSED
     struct private_data *priv = conn->privateData;
     remote_domain_event_pmsuspend_disk_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -4775,7 +4775,7 @@ remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog ATTRIBUTE_UNUSED
     struct private_data *priv = conn->privateData;
     remote_domain_event_device_removed_msg *msg = evdata;
     virDomainPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     dom = get_nonnull_domain(conn, msg->dom);
     if (!dom)
@@ -5111,7 +5111,7 @@ static int remoteConnectDomainEventRegisterAny(virConnectPtr conn,
         if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER_ANY,
                  (xdrproc_t) xdr_remote_connect_domain_event_register_any_args, (char *) &args,
                  (xdrproc_t) xdr_void, (char *)NULL) == -1) {
-            virDomainEventStateDeregisterID(conn,
+            virObjectEventStateDeregisterID(conn,
                                             priv->domainEventState,
                                             callbackID);
             goto done;
@@ -5137,14 +5137,14 @@ static int remoteConnectDomainEventDeregisterAny(virConnectPtr conn,
 
     remoteDriverLock(priv);
 
-    if ((eventID = virDomainEventStateEventID(conn,
+    if ((eventID = virObjectEventStateEventID(conn,
                                               priv->domainEventState,
                                               callbackID)) < 0) {
         virReportError(VIR_ERR_RPC, _("unable to find callback ID %d"), callbackID);
         goto done;
     }
 
-    if ((count = virDomainEventStateDeregisterID(conn,
+    if ((count = virObjectEventStateDeregisterID(conn,
                                                  priv->domainEventState,
                                                  callbackID)) < 0) {
         virReportError(VIR_ERR_RPC, _("unable to find callback ID %d"), callbackID);
@@ -6679,9 +6679,9 @@ done:
 }
 
 static void
-remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event)
+remoteDomainEventQueue(struct private_data *priv, virObjectEventPtr event)
 {
-    virDomainEventStateQueue(priv->domainEventState, event);
+    virObjectEventStateQueue(priv->domainEventState, event);
 }
 
 /* get_nonnull_domain and get_nonnull_network turn an on-wire
diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 2678247..f472494 100644
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -99,7 +99,7 @@ struct _testConn {
     int numCells;
     testCell cells[MAX_CELLS];
 
-    virDomainEventStatePtr domainEventState;
+    virObjectEventStatePtr domainEventState;
 };
 typedef struct _testConn testConn;
 typedef struct _testConn *testConnPtr;
@@ -122,7 +122,7 @@ static const virNodeInfo defaultNodeInfo = {
 
 static int testConnectClose(virConnectPtr conn);
 static void testDomainEventQueue(testConnPtr driver,
-                                 virDomainEventPtr event);
+                                 virObjectEventPtr event);
 
 
 static void testDriverLock(testConnPtr driver)
@@ -1444,7 +1444,7 @@ static virDrvOpenStatus testConnectOpen(virConnectPtr conn,
     privconn = conn->privateData;
     testDriverLock(privconn);
 
-    privconn->domainEventState = virDomainEventStateNew();
+    privconn->domainEventState = virObjectEventStateNew();
     if (!privconn->domainEventState) {
         testDriverUnlock(privconn);
         testConnectClose(conn);
@@ -1467,7 +1467,7 @@ static int testConnectClose(virConnectPtr conn)
     virNetworkObjListFree(&privconn->networks);
     virInterfaceObjListFree(&privconn->ifaces);
     virStoragePoolObjListFree(&privconn->pools);
-    virDomainEventStateFree(privconn->domainEventState);
+    virObjectEventStateFree(privconn->domainEventState);
     VIR_FREE(privconn->path);
 
     testDriverUnlock(privconn);
@@ -1615,7 +1615,7 @@ testDomainCreateXML(virConnectPtr conn, const char *xml,
     virDomainPtr ret = NULL;
     virDomainDefPtr def;
     virDomainObjPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     virCheckFlags(0, NULL);
 
@@ -1753,7 +1753,7 @@ static int testDomainDestroy(virDomainPtr domain)
 {
     testConnPtr privconn = domain->conn->privateData;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     testDriverLock(privconn);
@@ -1790,7 +1790,7 @@ static int testDomainResume(virDomainPtr domain)
 {
     testConnPtr privconn = domain->conn->privateData;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     testDriverLock(privconn);
@@ -1831,7 +1831,7 @@ static int testDomainSuspend(virDomainPtr domain)
 {
     testConnPtr privconn = domain->conn->privateData;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
     int state;
 
@@ -1875,7 +1875,7 @@ static int testDomainShutdownFlags(virDomainPtr domain,
 {
     testConnPtr privconn = domain->conn->privateData;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     virCheckFlags(0, -1);
@@ -1927,7 +1927,7 @@ static int testDomainReboot(virDomainPtr domain,
 {
     testConnPtr privconn = domain->conn->privateData;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     testDriverLock(privconn);
@@ -2071,7 +2071,7 @@ testDomainSaveFlags(virDomainPtr domain, const char *path,
     int fd = -1;
     int len;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     virCheckFlags(0, -1);
@@ -2184,7 +2184,7 @@ testDomainRestoreFlags(virConnectPtr conn,
     int len;
     virDomainDefPtr def = NULL;
     virDomainObjPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     virCheckFlags(0, -1);
@@ -2284,7 +2284,7 @@ static int testDomainCoreDump(virDomainPtr domain,
     testConnPtr privconn = domain->conn->privateData;
     int fd = -1;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     virCheckFlags(VIR_DUMP_CRASH, -1);
@@ -2783,7 +2783,7 @@ static virDomainPtr testDomainDefineXML(virConnectPtr conn,
     virDomainPtr ret = NULL;
     virDomainDefPtr def;
     virDomainObjPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     virDomainDefPtr oldDef = NULL;
 
     testDriverLock(privconn);
@@ -2921,7 +2921,7 @@ cleanup:
 static int testDomainCreateWithFlags(virDomainPtr domain, unsigned int flags) {
     testConnPtr privconn = domain->conn->privateData;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     virCheckFlags(0, -1);
@@ -2969,7 +2969,7 @@ static int testDomainUndefineFlags(virDomainPtr domain,
 {
     testConnPtr privconn = domain->conn->privateData;
     virDomainObjPtr privdom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int nsnapshots;
     int ret = -1;
 
@@ -6018,7 +6018,7 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn,
     int ret;
 
     testDriverLock(driver);
-    ret = virDomainEventStateDeregisterID(conn,
+    ret = virObjectEventStateDeregisterID(conn,
                                           driver->domainEventState,
                                           callbackID);
     testDriverUnlock(driver);
@@ -6029,9 +6029,9 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn,
 
 /* driver must be locked before calling */
 static void testDomainEventQueue(testConnPtr driver,
-                                 virDomainEventPtr event)
+                                 virObjectEventPtr event)
 {
-    virDomainEventStateQueue(driver->domainEventState, event);
+    virObjectEventStateQueue(driver->domainEventState, event);
 }
 
 static virDrvOpenStatus testSecretOpen(virConnectPtr conn,
@@ -6151,7 +6151,7 @@ testDomainManagedSave(virDomainPtr dom, unsigned int flags)
 {
     testConnPtr privconn = dom->conn->privateData;
     virDomainObjPtr vm = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     virCheckFlags(VIR_DOMAIN_SAVE_BYPASS_CACHE |
@@ -6641,7 +6641,7 @@ testDomainSnapshotCreateXML(virDomainPtr domain,
     virDomainSnapshotDefPtr def = NULL;
     virDomainSnapshotObjPtr snap = NULL;
     virDomainSnapshotPtr snapshot = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     char *xml = NULL;
     bool update_current = true;
     bool redefine = flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE;
@@ -6890,8 +6890,8 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
     testConnPtr privconn = snapshot->domain->conn->privateData;
     virDomainObjPtr vm = NULL;
     virDomainSnapshotObjPtr snap = NULL;
-    virDomainEventPtr event = NULL;
-    virDomainEventPtr event2 = NULL;
+    virObjectEventPtr event = NULL;
+    virObjectEventPtr event2 = NULL;
     virDomainDefPtr config = NULL;
     int ret = -1;
 
@@ -7035,7 +7035,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
             } /* else transition 6 and 9 use event as-is */
         } else {
             /* Transitions 2, 5, 8 */
-            virDomainEventFree(event);
+            virObjectEventFree(event);
             event = NULL;
 
             if (was_stopped) {
@@ -7089,7 +7089,7 @@ cleanup:
         if (event2)
             testDomainEventQueue(privconn, event2);
     } else {
-        virDomainEventFree(event2);
+        virObjectEventFree(event2);
     }
     virObjectUnlock(vm);
     testDriverUnlock(privconn);
diff --git a/src/uml/uml_conf.h b/src/uml/uml_conf.h
index 7f7ea05..c23a177 100644
--- a/src/uml/uml_conf.h
+++ b/src/uml/uml_conf.h
@@ -66,7 +66,7 @@ struct uml_driver {
     virDomainXMLOptionPtr xmlopt;
 
     /* Event handling */
-    virDomainEventStatePtr domainEventState;
+    virObjectEventStatePtr domainEventState;
 
     /* Mapping of 'char *uuidstr' -> virConnectPtr
      * of guests which will be automatically killed
diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c
index 9ac896a..382a670 100644
--- a/src/uml/uml_driver.c
+++ b/src/uml/uml_driver.c
@@ -128,7 +128,7 @@ static int umlOpenMonitor(struct uml_driver *driver,
 static int umlReadPidFile(struct uml_driver *driver,
                           virDomainObjPtr vm);
 static void umlDomainEventQueue(struct uml_driver *driver,
-                                virDomainEventPtr event);
+                                virObjectEventPtr event);
 
 static int umlStartVMDaemon(virConnectPtr conn,
                             struct uml_driver *driver,
@@ -194,7 +194,7 @@ umlAutostartDomain(virDomainObjPtr vm,
             VIR_ERROR(_("Failed to autostart VM '%s': %s"),
                       vm->def->name, err ? err->message : _("unknown error"));
         } else {
-            virDomainEventPtr event =
+            virObjectEventPtr event =
                 virDomainEventNewFromObj(vm,
                                          VIR_DOMAIN_EVENT_STARTED,
                                          VIR_DOMAIN_EVENT_STARTED_BOOTED);
@@ -301,7 +301,7 @@ umlInotifyEvent(int watch,
     char *tmp, *name;
     struct uml_driver *driver = data;
     virDomainObjPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     umlDriverLock(driver);
     if (watch != driver->inotifyWatch)
@@ -475,7 +475,7 @@ umlStateInitialize(bool privileged,
     if (!(uml_driver->domains = virDomainObjListNew()))
         goto error;
 
-    uml_driver->domainEventState = virDomainEventStateNew();
+    uml_driver->domainEventState = virObjectEventStateNew();
     if (!uml_driver->domainEventState)
         goto error;
 
@@ -604,7 +604,7 @@ static void umlNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
     struct uml_driver *driver = opaque;
 
     if (newVM) {
-        virDomainEventPtr event =
+        virObjectEventPtr event =
             virDomainEventNewFromObj(vm,
                                      VIR_DOMAIN_EVENT_DEFINED,
                                      VIR_DOMAIN_EVENT_DEFINED_ADDED);
@@ -677,7 +677,7 @@ umlStateCleanup(void) {
 
     virObjectUnref(uml_driver->domains);
 
-    virDomainEventStateFree(uml_driver->domainEventState);
+    virObjectEventStateFree(uml_driver->domainEventState);
 
     VIR_FREE(uml_driver->logDir);
     VIR_FREE(uml_driver->configDir);
@@ -716,7 +716,7 @@ static void umlProcessAutoDestroyDom(void *payload,
     const char *uuidstr = name;
     unsigned char uuid[VIR_UUID_BUFLEN];
     virDomainObjPtr dom;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     VIR_DEBUG("conn=%p uuidstr=%s thisconn=%p", conn, uuidstr, data->conn);
 
@@ -1571,7 +1571,7 @@ static virDomainPtr umlDomainCreateXML(virConnectPtr conn, const char *xml,
     virDomainDefPtr def;
     virDomainObjPtr vm = NULL;
     virDomainPtr dom = NULL;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
 
     virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, NULL);
 
@@ -1667,7 +1667,7 @@ umlDomainDestroyFlags(virDomainPtr dom,
 {
     struct uml_driver *driver = dom->conn->privateData;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     virCheckFlags(0, -1);
@@ -1993,7 +1993,7 @@ static int umlConnectNumOfDefinedDomains(virConnectPtr conn) {
 static int umlDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) {
     struct uml_driver *driver = dom->conn->privateData;
     virDomainObjPtr vm;
-    virDomainEventPtr event = NULL;
+    virObjectEventPtr event = NULL;
     int ret = -1;
 
     virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, -1);
@@ -2680,7 +2680,7 @@ umlConnectDomainEventDeregisterAny(virConnectPtr conn,
         return -1;
 
     umlDriverLock(driver);
-    ret = virDomainEventStateDeregisterID(conn,
+    ret = virObjectEventStateDeregisterID(conn,
                                           driver->domainEventState,
                                           callbackID);
     umlDriverUnlock(driver);
@@ -2691,9 +2691,9 @@ umlConnectDomainEventDeregisterAny(virConnectPtr conn,
 
 /* driver must be locked before calling */
 static void umlDomainEventQueue(struct uml_driver *driver,
-                                virDomainEventPtr event)
+                                virObjectEventPtr event)
 {
-    virDomainEventStateQueue(driver->domainEventState, event);
+    virObjectEventStateQueue(driver->domainEventState, event);
 }
 
 static int umlConnectListAllDomains(virConnectPtr conn,
diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index 3807a6d..b7c63b3 100644
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -211,7 +211,7 @@ typedef struct {
 #else /* !(VBOX_API_VERSION == 2002) */
 
     /* Async event handling */
-    virDomainEventStatePtr domainEvents;
+    virObjectEventStatePtr domainEvents;
     int fdWatch;
 
 # if VBOX_API_VERSION <= 3002
@@ -988,7 +988,7 @@ static void vboxUninitialize(vboxGlobalData *data) {
 #if VBOX_API_VERSION == 2002
     /* No domainEventCallbacks in 2.2.* version */
 #else  /* !(VBOX_API_VERSION == 2002) */
-    virDomainEventStateFree(data->domainEvents);
+    virObjectEventStateFree(data->domainEvents);
 #endif /* !(VBOX_API_VERSION == 2002) */
     VIR_FREE(data);
 }
@@ -1053,7 +1053,7 @@ static virDrvOpenStatus vboxConnectOpen(virConnectPtr conn,
 
 #else  /* !(VBOX_API_VERSION == 2002) */
 
-    if (!(data->domainEvents = virDomainEventStateNew())) {
+    if (!(data->domainEvents = virObjectEventStateNew())) {
         vboxUninitialize(data);
         return VIR_DRV_OPEN_ERROR;
     }
@@ -6878,7 +6878,7 @@ vboxCallbackOnMachineStateChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
 
         dom = vboxDomainLookupByUUID(g_pVBoxGlobalData->conn, uuid);
         if (dom) {
-            virDomainEventPtr ev;
+            virObjectEventPtr ev;
 
             if (state == MachineState_Starting) {
                 event  = VIR_DOMAIN_EVENT_STARTED;
@@ -6912,7 +6912,7 @@ vboxCallbackOnMachineStateChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
             ev = virDomainEventNewFromDom(dom, event, detail);
 
             if (ev)
-                virDomainEventStateQueue(g_pVBoxGlobalData->domainEvents, ev);
+                virObjectEventStateQueue(g_pVBoxGlobalData->domainEvents, ev);
         }
     }
 
@@ -6997,7 +6997,7 @@ vboxCallbackOnMachineRegistered(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
 
         dom = vboxDomainLookupByUUID(g_pVBoxGlobalData->conn, uuid);
         if (dom) {
-            virDomainEventPtr ev;
+            virObjectEventPtr ev;
 
             /* CURRENT LIMITATION: we never get the VIR_DOMAIN_EVENT_UNDEFINED
              * event because the when the machine is de-registered the call
@@ -7016,7 +7016,7 @@ vboxCallbackOnMachineRegistered(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED,
             ev = virDomainEventNewFromDom(dom, event, detail);
 
             if (ev)
-                virDomainEventStateQueue(g_pVBoxGlobalData->domainEvents, ev);
+                virObjectEventStateQueue(g_pVBoxGlobalData->domainEvents, ev);
         }
     }
 
@@ -7241,7 +7241,7 @@ static int vboxConnectDomainEventRegister(virConnectPtr conn,
 
             ret = virDomainEventStateRegister(conn, data->domainEvents,
                                               callback, opaque, freecb);
-            VIR_DEBUG("virDomainEventStateRegister (ret = %d) (conn: %p, "
+            VIR_DEBUG("virObjectEventStateRegister (ret = %d) (conn: %p, "
                       "callback: %p, opaque: %p, "
                       "freecb: %p)", ret, conn, callback,
                       opaque, freecb);
@@ -7335,7 +7335,7 @@ static int vboxConnectDomainEventRegisterAny(virConnectPtr conn,
                                               dom, eventID,
                                               callback, opaque, freecb, &ret) < 0)
                 ret = -1;
-            VIR_DEBUG("virDomainEventStateRegisterID (ret = %d) (conn: %p, "
+            VIR_DEBUG("virObjectEventStateRegisterID (ret = %d) (conn: %p, "
                       "callback: %p, opaque: %p, "
                       "freecb: %p)", ret, conn, callback,
                       opaque, freecb);
@@ -7364,7 +7364,7 @@ static int vboxConnectDomainEventDeregisterAny(virConnectPtr conn,
      */
     vboxDriverLock(data);
 
-    cnt = virDomainEventStateDeregisterID(conn, data->domainEvents,
+    cnt = virObjectEventStateDeregisterID(conn, data->domainEvents,
                                           callbackID);
 
     if (data->vboxCallback && cnt == 0) {
diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c
index 9ba1b10..4103dc9 100644
--- a/src/xen/xen_driver.c
+++ b/src/xen/xen_driver.c
@@ -453,7 +453,7 @@ xenUnifiedConnectOpen(virConnectPtr conn, virConnectAuthPtr auth, unsigned int f
         return VIR_DRV_OPEN_ERROR;
     }
 
-    if (!(priv->domainEvents = virDomainEventStateNew())) {
+    if (!(priv->domainEvents = virObjectEventStateNew())) {
         virMutexDestroy(&priv->lock);
         VIR_FREE(priv);
         return VIR_DRV_OPEN_ERROR;
@@ -551,7 +551,7 @@ xenUnifiedConnectClose(virConnectPtr conn)
 
     virObjectUnref(priv->caps);
     virObjectUnref(priv->xmlopt);
-    virDomainEventStateFree(priv->domainEvents);
+    virObjectEventStateFree(priv->domainEvents);
 
 #if WITH_XEN_INOTIFY
     if (priv->opened[XEN_UNIFIED_INOTIFY_OFFSET])
@@ -2409,7 +2409,7 @@ xenUnifiedConnectDomainEventDeregisterAny(virConnectPtr conn,
         return -1;
     }
 
-    ret = virDomainEventStateDeregisterID(conn,
+    ret = virObjectEventStateDeregisterID(conn,
                                           priv->domainEvents,
                                           callbackID);
 
@@ -2946,12 +2946,12 @@ xenUnifiedRemoveDomainInfo(xenUnifiedDomainInfoListPtr list,
  *
  */
 void xenUnifiedDomainEventDispatch(xenUnifiedPrivatePtr priv,
-                                    virDomainEventPtr event)
+                                    virObjectEventPtr event)
 {
     if (!priv)
         return;
 
-    virDomainEventStateQueue(priv->domainEvents, event);
+    virObjectEventStateQueue(priv->domainEvents, event);
 }
 
 void xenUnifiedLock(xenUnifiedPrivatePtr priv)
diff --git a/src/xen/xen_driver.h b/src/xen/xen_driver.h
index a363161..b8c1c27 100644
--- a/src/xen/xen_driver.h
+++ b/src/xen/xen_driver.h
@@ -159,7 +159,7 @@ struct _xenUnifiedPrivate {
     int nbNodeCells;
     int nbNodeCpus;
 
-    virDomainEventStatePtr domainEvents;
+    virObjectEventStatePtr domainEvents;
 
     /* Location of config files, either /etc
      * or /var/lib/xen */
@@ -199,7 +199,7 @@ int  xenUnifiedRemoveDomainInfo(xenUnifiedDomainInfoListPtr info,
                                 int id, char *name,
                                 unsigned char *uuid);
 void xenUnifiedDomainEventDispatch (xenUnifiedPrivatePtr priv,
-                                    virDomainEventPtr event);
+                                    virObjectEventPtr event);
 unsigned long xenUnifiedVersion(void);
 int xenUnifiedConnectGetMaxVcpus(virConnectPtr conn, const char *type);
 
diff --git a/src/xen/xen_inotify.c b/src/xen/xen_inotify.c
index 755be8f..b67178e 100644
--- a/src/xen/xen_inotify.c
+++ b/src/xen/xen_inotify.c
@@ -135,13 +135,13 @@ xenInotifyDomainLookup(virConnectPtr conn,
         return xenInotifyXendDomainsDirLookup(conn, filename, name, uuid);
 }
 
-static virDomainEventPtr
+static virObjectEventPtr
 xenInotifyDomainEventFromFile(virConnectPtr conn,
                               const char *filename,
                               int type,
                               int detail)
 {
-    virDomainEventPtr event;
+    virObjectEventPtr event;
     char *name = NULL;
     unsigned char uuid[VIR_UUID_BUFLEN];
 
@@ -290,7 +290,7 @@ reread:
                  priv->configDir, name);
 
         if (e->mask & (IN_DELETE | IN_MOVED_FROM)) {
-            virDomainEventPtr event =
+            virObjectEventPtr event =
                 xenInotifyDomainEventFromFile(conn, fname,
                                               VIR_DOMAIN_EVENT_UNDEFINED,
                                               VIR_DOMAIN_EVENT_UNDEFINED_REMOVED);
@@ -306,7 +306,7 @@ reread:
                 goto cleanup;
             }
         } else if (e->mask & (IN_CREATE | IN_CLOSE_WRITE | IN_MOVED_TO)) {
-            virDomainEventPtr event;
+            virObjectEventPtr event;
             if (xenInotifyAddDomainConfigInfo(conn, fname) < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR,
                                "%s", _("Error adding file to config cache"));
diff --git a/src/xen/xs_internal.c b/src/xen/xs_internal.c
index 4368f85..e66b6ad 100644
--- a/src/xen/xs_internal.c
+++ b/src/xen/xs_internal.c
@@ -835,7 +835,7 @@ retry:
         }
 
         if (!found) {
-            virDomainEventPtr event;
+            virObjectEventPtr event;
             char *name;
             unsigned char uuid[VIR_UUID_BUFLEN];
 
@@ -918,7 +918,7 @@ retry:
         }
 
         if (!found) {
-            virDomainEventPtr event =
+            virObjectEventPtr event =
                 virDomainEventNew(-1,
                                   priv->activeDomainList->doms[j]->name,
                                   priv->activeDomainList->doms[j]->uuid,
diff --git a/tests/qemuhotplugtest.c b/tests/qemuhotplugtest.c
index 961dfc6..8036adc 100644
--- a/tests/qemuhotplugtest.c
+++ b/tests/qemuhotplugtest.c
@@ -344,7 +344,7 @@ mymain(void)
     if (VIR_STRDUP_QUIET(driver.config->spicePassword, "123456") < 0)
         return EXIT_FAILURE;
 
-    if (!(driver.domainEventState = virDomainEventStateNew()))
+    if (!(driver.domainEventState = virObjectEventStateNew()))
         return EXIT_FAILURE;
 
     driver.lockManager = virLockManagerPluginNew("nop", "qemu",
-- 
1.8.4.2

--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list




[Index of Archives]     [Virt Tools]     [Libvirt Users]     [Lib OS Info]     [Fedora Users]     [Fedora Desktop]     [Fedora SELinux]     [Big List of Linux Books]     [Yosemite News]     [KDE Users]     [Fedora Tools]