These unit tests are aiming at providing some help during the domain events refactoring. --- .gitignore | 1 + tests/Makefile.am | 7 ++ tests/objecteventtest.c | 246 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 254 insertions(+) create mode 100644 tests/objecteventtest.c diff --git a/.gitignore b/.gitignore index 8de0b26..fbb2c01 100644 --- a/.gitignore +++ b/.gitignore @@ -160,6 +160,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/tests/Makefile.am b/tests/Makefile.am index 0900448..568b7a0 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -303,6 +303,8 @@ EXTRA_DIST += \ $(NULL) endif ! WITH_LIBVIRTD +test_programs += objecteventtest + if WITH_SECDRIVER_APPARMOR test_scripts += virt-aa-helper-test else ! WITH_SECDRIVER_APPARMOR @@ -895,6 +897,11 @@ fdstreamtest_SOURCES = \ fdstreamtest.c testutils.h testutils.c fdstreamtest_LDADD = $(LDADDS) +objecteventtest_SOURCES = \ + objecteventtest.c \ + testutils.c testutils.h +objecteventtest_LDADD = $(LDADDS) + if WITH_LINUX fchosttest_SOURCES = \ fchosttest.c testutils.h testutils.c diff --git a/tests/objecteventtest.c b/tests/objecteventtest.c new file mode 100644 index 0000000..031d677 --- /dev/null +++ b/tests/objecteventtest.c @@ -0,0 +1,246 @@ +/* + * Copyright (C) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. + * + * 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: Cedric Bosdonnat <cbosdonnat@suse.com> + */ + +#include <config.h> + +#include "testutils.h" + +#include "virerror.h" +#include "virxml.h" + +#define VIR_FROM_THIS VIR_FROM_NONE + + +static const char domainDef[] = +"<domain type='test'>" +" <name>test-domain</name>" +" <uuid>77a6fc12-07b5-9415-8abb-a803613f2a40</uuid>" +" <memory>8388608</memory>" +" <currentMemory>2097152</currentMemory>" +" <vcpu>2</vcpu>" +" <os>" +" <type>hvm</type>" +" </os>" +"</domain>"; + +struct lifecycleEventCounter { + int startEvents; + int stopEvents; + int defineEvents; + int undefineEvents; +}; + +static void lifecycleEventCounter_reset(struct lifecycleEventCounter* counter) +{ + counter->startEvents = 0; + counter->stopEvents = 0; + counter->defineEvents = 0; + counter->undefineEvents = 0; +} + +struct objecteventTest { + virConnectPtr conn; +}; + + +static int domainLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED, + virDomainPtr dom ATTRIBUTE_UNUSED, + int event, + int detail ATTRIBUTE_UNUSED, + void *opaque) +{ + struct lifecycleEventCounter *counter = opaque; + + switch (event) { + case VIR_DOMAIN_EVENT_STARTED: + counter->startEvents++; + break; + case VIR_DOMAIN_EVENT_STOPPED: + counter->stopEvents++; + break; + case VIR_DOMAIN_EVENT_DEFINED: + counter->defineEvents++; + break; + case VIR_DOMAIN_EVENT_UNDEFINED: + counter->undefineEvents++; + break; + default: + /* Ignore other events */ + break; + } + return 0; +} + +static int +testDomainCreateXML(const void *data) +{ + const struct objecteventTest *test = data; + struct lifecycleEventCounter counter; + int eventId = VIR_DOMAIN_EVENT_ID_LIFECYCLE; + virDomainPtr dom; + int id; + int ret = 0; + + lifecycleEventCounter_reset(&counter); + + id = virConnectDomainEventRegisterAny(test->conn, NULL, eventId, + VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb), + &counter, NULL); + dom = virDomainCreateXML(test->conn, domainDef, 0); + + if (dom == NULL || virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.startEvents != 1) { + ret = -1; + goto cleanup; + } + +cleanup: + virConnectDomainEventDeregisterAny(test->conn, id); + if (dom != NULL) { + virDomainDestroy(dom); + virDomainFree(dom); + } + + return ret; +} + +static int +testDomainDefine(const void *data) +{ + const struct objecteventTest *test = data; + struct lifecycleEventCounter counter; + int eventId = VIR_DOMAIN_EVENT_ID_LIFECYCLE; + virDomainPtr dom; + int id; + int ret = 0; + + lifecycleEventCounter_reset(&counter); + + id = virConnectDomainEventRegisterAny(test->conn, NULL, eventId, + VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb), + &counter, NULL); + + /* Make sure the define event is triggered */ + dom = virDomainDefineXML(test->conn, domainDef); + + if (dom == NULL || virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.defineEvents != 1) { + ret = -1; + goto cleanup; + } + + /* Make sure the undefine event is triggered */ + virDomainUndefine(dom); + + if (virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.undefineEvents != 1) { + ret = -1; + goto cleanup; + } + + +cleanup: + virConnectDomainEventDeregisterAny(test->conn, id); + if (dom != NULL) + virDomainFree(dom); + + return ret; +} + +static int +testDomainStartStopEvent(const void *data) +{ + const struct objecteventTest *test = data; + struct lifecycleEventCounter counter; + int eventId = VIR_DOMAIN_EVENT_ID_LIFECYCLE; + int id; + int ret = 0; + virDomainPtr dom; + + lifecycleEventCounter_reset(&counter); + + dom = virDomainLookupByName(test->conn, "test"); + if (dom == NULL) + return -1; + + id = virConnectDomainEventRegisterAny(test->conn, dom, eventId, + VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb), + &counter, NULL); + + /* Test domain is started */ + virDomainDestroy(dom); + virDomainCreate(dom); + + if (virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.startEvents != 1 || counter.stopEvents != 1) { + ret = -1; + goto cleanup; + } + +cleanup: + virConnectDomainEventDeregisterAny(test->conn, id); + virDomainFree(dom); + + return ret; +} + +static int +mymain(void) +{ + struct objecteventTest test; + int ret = EXIT_SUCCESS; + + virEventRegisterDefaultImpl(); + + if (!(test.conn = virConnectOpen("test:///default"))) + return EXIT_FAILURE; + + virtTestQuiesceLibvirtErrors(false); + + /* Domain event tests */ + if (virtTestRun("Domain createXML start event ", testDomainCreateXML, &test) < 0) + ret = EXIT_FAILURE; + if (virtTestRun("Domain (un)define events", testDomainDefine, &test) < 0) + ret = EXIT_FAILURE; + if (virtTestRun("Domain start stop events", testDomainStartStopEvent, &test) < 0) + ret = EXIT_FAILURE; + + virConnectClose(test.conn); + + return ret; +} + +VIRT_TEST_MAIN(mymain) -- 1.8.4.4

--- src/conf/domain_event.c | 8 ++++---- src/conf/domain_event.h | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 19e3920..fd68820 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -43,7 +43,7 @@ typedef virDomainMeta *virDomainMetaPtr; struct _virDomainEventCallbackList { unsigned int nextID; unsigned int count; - virDomainEventCallbackPtr *callbacks; + virObjectEventCallbackPtr *callbacks; }; struct _virDomainEventQueue { @@ -63,7 +63,7 @@ struct _virDomainEventState { virMutex lock; }; -struct _virDomainEventCallback { +struct _virObjectEventCallback { int callbackID; int eventID; virConnectPtr conn; @@ -355,7 +355,7 @@ virDomainEventCallbackListAddID(virConnectPtr conn, virFreeCallback freecb, int *callbackID) { - virDomainEventCallbackPtr event; + virObjectEventCallbackPtr event; size_t i; int ret = 0; @@ -1366,7 +1366,7 @@ cleanup: static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, - virDomainEventCallbackPtr cb) + virObjectEventCallbackPtr cb) { if (!cb) return 0; diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index f6b957d..07b14c4 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -28,8 +28,8 @@ # include "domain_conf.h" -typedef struct _virDomainEventCallback virDomainEventCallback; -typedef virDomainEventCallback *virDomainEventCallbackPtr; +typedef struct _virObjectEventCallback virObjectEventCallback; +typedef virObjectEventCallback *virObjectEventCallbackPtr; typedef struct _virDomainEventCallbackList virDomainEventCallbackList; typedef virDomainEventCallbackList *virDomainEventCallbackListPtr; -- 1.8.4.4

--- src/conf/domain_event.c | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index fd68820..3bfe1e0 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -32,13 +32,13 @@ #define VIR_FROM_THIS VIR_FROM_NONE -struct _virDomainMeta { +struct _virObjectMeta { int id; char *name; unsigned char uuid[VIR_UUID_BUFLEN]; }; -typedef struct _virDomainMeta virDomainMeta; -typedef virDomainMeta *virDomainMetaPtr; +typedef struct _virObjectMeta virObjectMeta; +typedef virObjectMeta *virObjectMetaPtr; struct _virDomainEventCallbackList { unsigned int nextID; @@ -67,7 +67,7 @@ struct _virObjectEventCallback { int callbackID; int eventID; virConnectPtr conn; - virDomainMetaPtr dom; + virObjectMetaPtr meta; virConnectDomainEventGenericCallback cb; void *opaque; virFreeCallback freecb; @@ -77,7 +77,7 @@ struct _virObjectEventCallback { struct _virDomainEvent { int eventID; - virDomainMeta dom; + virObjectMeta meta; union { struct { @@ -369,10 +369,10 @@ virDomainEventCallbackListAddID(virConnectPtr conn, 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 && cbList->callbacks[i]->meta && + memcmp(cbList->callbacks[i]->meta->uuid, dom->uuid, VIR_UUID_BUFLEN) == 0) || - (!dom && !cbList->callbacks[i]->dom))) { + (!dom && !cbList->callbacks[i]->meta))) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("event callback already tracked")); return -1; @@ -388,12 +388,12 @@ virDomainEventCallbackListAddID(virConnectPtr conn, event->freecb = freecb; if (dom) { - if (VIR_ALLOC(event->dom) < 0) + if (VIR_ALLOC(event->meta) < 0) goto error; - if (VIR_STRDUP(event->dom->name, dom->name) < 0) + if (VIR_STRDUP(event->meta->name, dom->name) < 0) goto error; - memcpy(event->dom->uuid, dom->uuid, VIR_UUID_BUFLEN); - event->dom->id = dom->id; + memcpy(event->meta->uuid, dom->uuid, VIR_UUID_BUFLEN); + event->meta->id = dom->id; } /* Make space on list */ @@ -421,9 +421,9 @@ virDomainEventCallbackListAddID(virConnectPtr conn, error: if (event) { - if (event->dom) - VIR_FREE(event->dom->name); - VIR_FREE(event->dom); + if (event->meta) + VIR_FREE(event->meta->name); + VIR_FREE(event->meta); } VIR_FREE(event); return -1; @@ -526,7 +526,7 @@ void virDomainEventFree(virDomainEventPtr event) break; } - VIR_FREE(event->dom.name); + VIR_FREE(event->meta.name); VIR_FREE(event); } @@ -664,12 +664,12 @@ static virDomainEventPtr virDomainEventNewInternal(int eventID, return NULL; event->eventID = eventID; - if (VIR_STRDUP(event->dom.name, name) < 0) { + if (VIR_STRDUP(event->meta.name, name) < 0) { VIR_FREE(event); return NULL; } - event->dom.id = id; - memcpy(event->dom.uuid, uuid, VIR_UUID_BUFLEN); + event->meta.id = id; + memcpy(event->meta.uuid, uuid, VIR_UUID_BUFLEN); return event; } @@ -1244,10 +1244,10 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, void *cbopaque, void *opaque ATTRIBUTE_UNUSED) { - virDomainPtr dom = virGetDomain(conn, event->dom.name, event->dom.uuid); + virDomainPtr dom = virGetDomain(conn, event->meta.name, event->meta.uuid); if (!dom) return; - dom->id = event->dom.id; + dom->id = event->meta.id; switch ((virDomainEventID) event->eventID) { case VIR_DOMAIN_EVENT_ID_LIFECYCLE: @@ -1375,14 +1375,14 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, if (cb->eventID != event->eventID) return 0; - if (cb->dom) { + if (cb->meta) { /* 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) + if (memcmp(event->meta.uuid, cb->meta->uuid, VIR_UUID_BUFLEN) == 0) return 1; return 0; -- 1.8.4.4

--- src/conf/domain_event.c | 49 ++++++++++++++++++++++++++----------------------- src/conf/domain_event.h | 3 --- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 3bfe1e0..ee19142 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -40,13 +40,16 @@ struct _virObjectMeta { typedef struct _virObjectMeta virObjectMeta; typedef virObjectMeta *virObjectMetaPtr; +typedef struct _virObjectEventQueue virObjectEventQueue; +typedef virObjectEventQueue *virObjectEventQueuePtr; + struct _virDomainEventCallbackList { unsigned int nextID; unsigned int count; virObjectEventCallbackPtr *callbacks; }; -struct _virDomainEventQueue { +struct _virObjectEventQueue { unsigned int count; virDomainEventPtr *events; }; @@ -54,8 +57,8 @@ struct _virDomainEventQueue { struct _virDomainEventState { /* The list of domain event callbacks */ virDomainEventCallbackListPtr callbacks; - /* The queue of domain events */ - virDomainEventQueuePtr queue; + /* The queue of object events */ + virObjectEventQueuePtr queue; /* Timer for flushing events queue */ int timer; /* Flag if we're in process of dispatching */ @@ -531,13 +534,13 @@ void virDomainEventFree(virDomainEventPtr event) } /** - * virDomainEventQueueClear: + * virObjectEventQueueClear: * @queue: pointer to the queue * * Removes all elements from the queue */ static void -virDomainEventQueueClear(virDomainEventQueuePtr queue) +virObjectEventQueueClear(virObjectEventQueuePtr queue) { size_t i; if (!queue) @@ -551,25 +554,25 @@ virDomainEventQueueClear(virDomainEventQueuePtr queue) } /** - * virDomainEventQueueFree: + * virObjectEventQueueFree: * @queue: pointer to the queue * * Free the memory in the queue. We process this like a list here */ static void -virDomainEventQueueFree(virDomainEventQueuePtr queue) +virObjectEventQueueFree(virObjectEventQueuePtr queue) { if (!queue) return; - virDomainEventQueueClear(queue); + virObjectEventQueueClear(queue); VIR_FREE(queue); } -static virDomainEventQueuePtr -virDomainEventQueueNew(void) +static virObjectEventQueuePtr +virObjectEventQueueNew(void) { - virDomainEventQueuePtr ret; + virObjectEventQueuePtr ret; ignore_value(VIR_ALLOC(ret)); return ret; @@ -600,7 +603,7 @@ virDomainEventStateFree(virDomainEventStatePtr state) return; virDomainEventCallbackListFree(state->callbacks); - virDomainEventQueueFree(state->queue); + virObjectEventQueueFree(state->queue); if (state->timer != -1) virEventRemoveTimeout(state->timer); @@ -641,7 +644,7 @@ virDomainEventStateNew(void) if (VIR_ALLOC(state->callbacks) < 0) goto error; - if (!(state->queue = virDomainEventQueueNew())) + if (!(state->queue = virObjectEventQueueNew())) goto error; state->timer = -1; @@ -1203,16 +1206,16 @@ virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, } /** - * virDomainEventQueuePush: - * @evtQueue: the dom event queue + * virObjectEventQueuePush: + * @evtQueue: the object event queue * @event: the event to add * - * Internal function to push to the back of a virDomainEventQueue + * Internal function to push to the back of a virObjectEventQueue * * Returns: 0 on success, -1 on failure */ static int -virDomainEventQueuePush(virDomainEventQueuePtr evtQueue, +virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, virDomainEventPtr event) { if (!evtQueue) { @@ -1418,7 +1421,7 @@ virDomainEventDispatch(virDomainEventPtr event, static void -virDomainEventQueueDispatch(virDomainEventQueuePtr queue, +virObjectEventQueueDispatch(virObjectEventQueuePtr queue, virDomainEventCallbackListPtr callbacks, virDomainEventDispatchFunc dispatch, void *opaque) @@ -1444,7 +1447,7 @@ virDomainEventStateQueue(virDomainEventStatePtr state, virDomainEventStateLock(state); - if (virDomainEventQueuePush(state->queue, event) < 0) { + if (virObjectEventQueuePush(state->queue, event) < 0) { VIR_DEBUG("Error adding event to queue"); virDomainEventFree(event); } @@ -1474,7 +1477,7 @@ virDomainEventStateDispatchFunc(virConnectPtr conn, static void virDomainEventStateFlush(virDomainEventStatePtr state) { - virDomainEventQueue tempQueue; + virObjectEventQueue tempQueue; virDomainEventStateLock(state); state->isDispatching = true; @@ -1487,7 +1490,7 @@ virDomainEventStateFlush(virDomainEventStatePtr state) state->queue->events = NULL; virEventUpdateTimeout(state->timer, -1); - virDomainEventQueueDispatch(&tempQueue, + virObjectEventQueueDispatch(&tempQueue, state->callbacks, virDomainEventStateDispatchFunc, state); @@ -1637,7 +1640,7 @@ virDomainEventStateDeregister(virConnectPtr conn, state->timer != -1) { virEventRemoveTimeout(state->timer); state->timer = -1; - virDomainEventQueueClear(state->queue); + virObjectEventQueueClear(state->queue); } virDomainEventStateUnlock(state); @@ -1675,7 +1678,7 @@ virDomainEventStateDeregisterID(virConnectPtr conn, state->timer != -1) { virEventRemoveTimeout(state->timer); state->timer = -1; - virDomainEventQueueClear(state->queue); + virObjectEventQueueClear(state->queue); } virDomainEventStateUnlock(state); diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 07b14c4..f58fbb6 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -41,9 +41,6 @@ typedef virDomainEventCallbackList *virDomainEventCallbackListPtr; typedef struct _virDomainEvent virDomainEvent; typedef virDomainEvent *virDomainEventPtr; -typedef struct _virDomainEventQueue virDomainEventQueue; -typedef virDomainEventQueue *virDomainEventQueuePtr; - typedef struct _virDomainEventState virDomainEventState; typedef virDomainEventState *virDomainEventStatePtr; -- 1.8.4.4

Leave virDomainEventRegister and its Deregister brother as these are legacy functions only for domain lifecycle events. --- cfg.mk | 4 +- src/conf/domain_event.c | 100 ++++++++++++++++++++-------------------- src/conf/domain_event.h | 26 +++++------ src/libvirt_private.syms | 10 ++-- src/libxl/libxl_conf.h | 2 +- src/libxl/libxl_driver.c | 8 ++-- src/lxc/lxc_conf.h | 2 +- src/lxc/lxc_driver.c | 22 ++++----- src/lxc/lxc_process.c | 6 +-- src/parallels/parallels_utils.h | 2 +- src/qemu/qemu_conf.h | 2 +- src/qemu/qemu_domain.c | 2 +- src/qemu/qemu_driver.c | 6 +-- src/remote/remote_driver.c | 14 +++--- src/test/test_driver.c | 10 ++-- src/uml/uml_conf.h | 2 +- src/uml/uml_driver.c | 8 ++-- src/vbox/vbox_tmpl.c | 14 +++--- src/xen/xen_driver.c | 8 ++-- src/xen/xen_driver.h | 2 +- tests/qemuhotplugtest.c | 2 +- 21 files changed, 126 insertions(+), 126 deletions(-) diff --git a/cfg.mk b/cfg.mk index bd3dd48..c256164 100644 --- a/cfg.mk +++ b/cfg.mk @@ -126,8 +126,8 @@ useless_free_options = \ --name=virDomainDiskDefFree \ --name=virDomainEventCallbackListFree \ --name=virDomainEventFree \ - --name=virDomainEventQueueFree \ - --name=virDomainEventStateFree \ + --name=virObjectEventQueueFree \ + --name=virObjectEventStateFree \ --name=virDomainFSDefFree \ --name=virDomainGraphicsDefFree \ --name=virDomainHostdevDefFree \ diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index ee19142..5389aef 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -54,7 +54,7 @@ struct _virObjectEventQueue { virDomainEventPtr *events; }; -struct _virDomainEventState { +struct _virObjectEventState { /* The list of domain event callbacks */ virDomainEventCallbackListPtr callbacks; /* The queue of object events */ @@ -579,25 +579,25 @@ virObjectEventQueueNew(void) } static void -virDomainEventStateLock(virDomainEventStatePtr state) +virObjectEventStateLock(virObjectEventStatePtr state) { virMutexLock(&state->lock); } static void -virDomainEventStateUnlock(virDomainEventStatePtr state) +virObjectEventStateUnlock(virObjectEventStatePtr state) { virMutexUnlock(&state->lock); } /** - * virDomainEventStateFree: - * @list: virDomainEventStatePtr to free + * virObjectEventStateFree: + * @list: virObjectEventStatePtr to free * - * Free a virDomainEventStatePtr and its members, and unregister the timer. + * Free a virObjectEventStatePtr and its members, and unregister the timer. */ void -virDomainEventStateFree(virDomainEventStatePtr state) +virObjectEventStateFree(virObjectEventStatePtr state) { if (!state) return; @@ -613,23 +613,23 @@ virDomainEventStateFree(virDomainEventStatePtr state) } -static void virDomainEventStateFlush(virDomainEventStatePtr state); +static void virObjectEventStateFlush(virObjectEventStatePtr state); static void virDomainEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque) { - virDomainEventStatePtr state = opaque; + virObjectEventStatePtr state = opaque; - virDomainEventStateFlush(state); + virObjectEventStateFlush(state); } /** - * virDomainEventStateNew: + * virObjectEventStateNew: */ -virDomainEventStatePtr -virDomainEventStateNew(void) +virObjectEventStatePtr +virObjectEventStateNew(void) { - virDomainEventStatePtr state = NULL; + virObjectEventStatePtr state = NULL; if (VIR_ALLOC(state) < 0) goto error; @@ -652,7 +652,7 @@ virDomainEventStateNew(void) return state; error: - virDomainEventStateFree(state); + virObjectEventStateFree(state); return NULL; } @@ -1437,7 +1437,7 @@ virObjectEventQueueDispatch(virObjectEventQueuePtr queue, } void -virDomainEventStateQueue(virDomainEventStatePtr state, +virObjectEventStateQueue(virObjectEventStatePtr state, virDomainEventPtr event) { if (state->timer < 0) { @@ -1445,7 +1445,7 @@ virDomainEventStateQueue(virDomainEventStatePtr state, return; } - virDomainEventStateLock(state); + virObjectEventStateLock(state); if (virObjectEventQueuePush(state->queue, event) < 0) { VIR_DEBUG("Error adding event to queue"); @@ -1454,32 +1454,32 @@ virDomainEventStateQueue(virDomainEventStatePtr state, if (state->queue->count == 1) virEventUpdateTimeout(state->timer, 0); - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); } static void -virDomainEventStateDispatchFunc(virConnectPtr conn, +virObjectEventStateDispatchFunc(virConnectPtr conn, virDomainEventPtr event, virConnectDomainEventGenericCallback cb, void *cbopaque, void *opaque) { - virDomainEventStatePtr state = opaque; + virObjectEventStatePtr state = opaque; /* Drop the lock whle dispatching, for sake of re-entrancy */ - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL); - virDomainEventStateLock(state); + virObjectEventStateLock(state); } static void -virDomainEventStateFlush(virDomainEventStatePtr state) +virObjectEventStateFlush(virObjectEventStatePtr state) { virObjectEventQueue tempQueue; - virDomainEventStateLock(state); + virObjectEventStateLock(state); state->isDispatching = true; /* Copy the queue, so we're reentrant safe when dispatchFunc drops the @@ -1492,21 +1492,21 @@ virDomainEventStateFlush(virDomainEventStatePtr state) virObjectEventQueueDispatch(&tempQueue, state->callbacks, - virDomainEventStateDispatchFunc, + virObjectEventStateDispatchFunc, state); /* Purge any deleted callbacks */ virDomainEventCallbackListPurgeMarked(state->callbacks); state->isDispatching = false; - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); } /** * virDomainEventStateRegister: * @conn: connection to associate with callback - * @state: domain event state + * @state: object event state * @callback: function to remove from event * @opaque: data blob to pass to callback * @freecb: callback to free @opaque @@ -1518,14 +1518,14 @@ virDomainEventStateFlush(virDomainEventStatePtr state) */ int virDomainEventStateRegister(virConnectPtr conn, - virDomainEventStatePtr state, + virObjectEventStatePtr state, virConnectDomainEventCallback callback, void *opaque, virFreeCallback freecb) { int ret = -1; - virDomainEventStateLock(state); + virObjectEventStateLock(state); if ((state->callbacks->count == 0) && (state->timer == -1) && @@ -1549,7 +1549,7 @@ virDomainEventStateRegister(virConnectPtr conn, } cleanup: - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); return ret; } @@ -1557,7 +1557,7 @@ cleanup: /** * virDomainEventStateRegisterID: * @conn: connection to associate with callback - * @state: domain event state + * @state: object event state * @eventID: ID of the event type to register for * @cb: function to remove from event * @opaque: data blob to pass to callback @@ -1571,7 +1571,7 @@ cleanup: */ int virDomainEventStateRegisterID(virConnectPtr conn, - virDomainEventStatePtr state, + virObjectEventStatePtr state, virDomainPtr dom, int eventID, virConnectDomainEventGenericCallback cb, @@ -1581,7 +1581,7 @@ virDomainEventStateRegisterID(virConnectPtr conn, { int ret = -1; - virDomainEventStateLock(state); + virObjectEventStateLock(state); if ((state->callbacks->count == 0) && (state->timer == -1) && @@ -1606,7 +1606,7 @@ virDomainEventStateRegisterID(virConnectPtr conn, } cleanup: - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); return ret; } @@ -1614,7 +1614,7 @@ cleanup: /** * virDomainEventStateDeregister: * @conn: connection to associate with callback - * @state: domain event state + * @state: object event state * @callback: function to remove from event * * Unregister the function @callback with connection @conn, @@ -1624,12 +1624,12 @@ cleanup: */ int virDomainEventStateDeregister(virConnectPtr conn, - virDomainEventStatePtr state, + virObjectEventStatePtr state, virConnectDomainEventCallback callback) { int ret; - virDomainEventStateLock(state); + virObjectEventStateLock(state); if (state->isDispatching) ret = virDomainEventCallbackListMarkDelete(conn, state->callbacks, callback); @@ -1643,15 +1643,15 @@ virDomainEventStateDeregister(virConnectPtr conn, virObjectEventQueueClear(state->queue); } - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); return ret; } /** - * virDomainEventStateDeregisterID: + * virObjectEventStateDeregisterID: * @conn: connection to associate with callback - * @state: domain event state + * @state: object event state * @callbackID: ID of the function to remove from event * * Unregister the function @callbackID with connection @conn, @@ -1660,13 +1660,13 @@ virDomainEventStateDeregister(virConnectPtr conn, * Returns: the number of callbacks still registered, or -1 on error */ int -virDomainEventStateDeregisterID(virConnectPtr conn, - virDomainEventStatePtr state, +virObjectEventStateDeregisterID(virConnectPtr conn, + virObjectEventStatePtr state, int callbackID) { int ret; - virDomainEventStateLock(state); + virObjectEventStateLock(state); if (state->isDispatching) ret = virDomainEventCallbackListMarkDeleteID(conn, state->callbacks, callbackID); @@ -1681,15 +1681,15 @@ virDomainEventStateDeregisterID(virConnectPtr conn, virObjectEventQueueClear(state->queue); } - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); return ret; } /** - * virDomainEventStateEventID: + * virObjectEventStateEventID: * @conn: connection associated with the callback - * @state: domain event state + * @state: object event state * @callbackID: the callback to query * * Query what event ID type is associated with the @@ -1698,15 +1698,15 @@ virDomainEventStateDeregisterID(virConnectPtr conn, * Returns 0 on success, -1 on error */ int -virDomainEventStateEventID(virConnectPtr conn, - virDomainEventStatePtr state, +virObjectEventStateEventID(virConnectPtr conn, + virObjectEventStatePtr state, int callbackID) { int ret; - virDomainEventStateLock(state); + virObjectEventStateLock(state); ret = virDomainEventCallbackListEventID(conn, state->callbacks, callbackID); - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); return ret; } diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index f58fbb6..fa0d409 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -41,8 +41,8 @@ typedef virDomainEventCallbackList *virDomainEventCallbackListPtr; typedef struct _virDomainEvent virDomainEvent; typedef virDomainEvent *virDomainEventPtr; -typedef struct _virDomainEventState virDomainEventState; -typedef virDomainEventState *virDomainEventStatePtr; +typedef struct _virObjectEventState virObjectEventState; +typedef virObjectEventState *virObjectEventStatePtr; virDomainEventPtr virDomainEventNew(int id, const char *name, const unsigned char *uuid, int type, int detail); virDomainEventPtr virDomainEventNewFromDom(virDomainPtr dom, int type, int detail); @@ -136,22 +136,22 @@ virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, void virDomainEventFree(virDomainEventPtr event); -void virDomainEventStateFree(virDomainEventStatePtr state); -virDomainEventStatePtr -virDomainEventStateNew(void); +void virObjectEventStateFree(virObjectEventStatePtr state); +virObjectEventStatePtr +virObjectEventStateNew(void); void -virDomainEventStateQueue(virDomainEventStatePtr state, +virObjectEventStateQueue(virObjectEventStatePtr state, virDomainEventPtr event) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); int virDomainEventStateRegister(virConnectPtr conn, - virDomainEventStatePtr state, + virObjectEventStatePtr 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, @@ -161,17 +161,17 @@ int virDomainEventStateRegisterID(virConnectPtr conn, ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5); int virDomainEventStateDeregister(virConnectPtr conn, - virDomainEventStatePtr state, + virObjectEventStatePtr state, virConnectDomainEventCallback callback) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3); int -virDomainEventStateDeregisterID(virConnectPtr conn, - virDomainEventStatePtr state, +virObjectEventStateDeregisterID(virConnectPtr conn, + virObjectEventStatePtr state, int callbackID) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); int -virDomainEventStateEventID(virConnectPtr conn, - virDomainEventStatePtr state, +virObjectEventStateEventID(virConnectPtr conn, + virObjectEventStatePtr state, int callbackID) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 50fe00e..3933b40 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -444,17 +444,17 @@ virDomainEventRebootNewFromObj; virDomainEventRTCChangeNewFromDom; virDomainEventRTCChangeNewFromObj; virDomainEventStateDeregister; -virDomainEventStateDeregisterID; -virDomainEventStateEventID; -virDomainEventStateFree; -virDomainEventStateNew; -virDomainEventStateQueue; virDomainEventStateRegister; virDomainEventStateRegisterID; virDomainEventTrayChangeNewFromDom; virDomainEventTrayChangeNewFromObj; virDomainEventWatchdogNewFromDom; virDomainEventWatchdogNewFromObj; +virObjectEventStateDeregisterID; +virObjectEventStateEventID; +virObjectEventStateFree; +virObjectEventStateNew; +virObjectEventStateQueue; # conf/domain_nwfilter.h 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 1b42f14..bc5f653 100644 --- a/src/libxl/libxl_driver.c +++ b/src/libxl/libxl_driver.c @@ -102,7 +102,7 @@ libxlDomObjFromDomain(virDomainPtr dom) static void libxlDomainEventQueue(libxlDriverPrivatePtr driver, virDomainEventPtr event) { - virDomainEventStateQueue(driver->domainEventState, event); + virObjectEventStateQueue(driver->domainEventState, event); } static int @@ -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; @@ -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..391226b 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -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; @@ -547,7 +547,7 @@ cleanup: if (vm) virObjectUnlock(vm); if (event) - virDomainEventStateQueue(driver->domainEventState, event); + virObjectEventStateQueue(driver->domainEventState, event); virObjectUnref(cfg); return ret; } @@ -944,7 +944,7 @@ cleanup: if (vm) virObjectUnlock(vm); if (event) - virDomainEventStateQueue(driver->domainEventState, event); + virObjectEventStateQueue(driver->domainEventState, event); virObjectUnref(cfg); return ret; } @@ -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); @@ -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; @@ -1486,7 +1486,7 @@ static void lxcNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque) 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); @@ -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); @@ -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..8214f62 100644 --- a/src/lxc/lxc_process.c +++ b/src/lxc/lxc_process.c @@ -82,7 +82,7 @@ lxcProcessAutoDestroy(virDomainObjPtr dom, } if (event) - virDomainEventStateQueue(driver->domainEventState, event); + virObjectEventStateQueue(driver->domainEventState, event); return dom; } @@ -533,7 +533,7 @@ static void virLXCProcessMonitorEOFNotify(virLXCMonitorPtr mon, if (vm) virObjectUnlock(vm); if (event) { - virDomainEventStateQueue(driver->domainEventState, event); + virObjectEventStateQueue(driver->domainEventState, event); } } @@ -1399,7 +1399,7 @@ virLXCProcessAutostartDomain(virDomainObjPtr 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 346fec3..a5fc8d6 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -120,7 +120,7 @@ qemuDomainAsyncJobPhaseFromString(enum qemuDomainAsyncJob job, void qemuDomainEventQueue(virQEMUDriverPtr driver, virDomainEventPtr event) { - virDomainEventStateQueue(driver->domainEventState, event); + virObjectEventStateQueue(driver->domainEventState, event); } diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 47d8a09..8183643 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; @@ -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); @@ -9951,7 +9951,7 @@ qemuConnectDomainEventDeregisterAny(virConnectPtr conn, if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0) goto cleanup; - if (virDomainEventStateDeregisterID(conn, + if (virObjectEventStateDeregisterID(conn, driver->domainEventState, callbackID) < 0) goto cleanup; diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index c43ce1d..e7c319e 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 { @@ -880,7 +880,7 @@ doRemoteOpen(virConnectPtr conn, goto failed; } - if (!(priv->domainEventState = virDomainEventStateNew())) + if (!(priv->domainEventState = virObjectEventStateNew())) goto failed; /* Successful. */ @@ -1085,7 +1085,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; @@ -5122,7 +5122,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; @@ -5148,14 +5148,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); @@ -6692,7 +6692,7 @@ done: static void remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr 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 c1f1cd4..ba24f69 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; @@ -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); @@ -6018,7 +6018,7 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn, int ret; testDriverLock(driver); - ret = virDomainEventStateDeregisterID(conn, + ret = virObjectEventStateDeregisterID(conn, driver->domainEventState, callbackID); testDriverUnlock(driver); @@ -6031,7 +6031,7 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn, static void testDomainEventQueue(testConnPtr driver, virDomainEventPtr event) { - virDomainEventStateQueue(driver->domainEventState, event); + virObjectEventStateQueue(driver->domainEventState, event); } static virDrvOpenStatus testSecretOpen(virConnectPtr conn, 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..e9bc6d4 100644 --- a/src/uml/uml_driver.c +++ b/src/uml/uml_driver.c @@ -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; @@ -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); @@ -2680,7 +2680,7 @@ umlConnectDomainEventDeregisterAny(virConnectPtr conn, return -1; umlDriverLock(driver); - ret = virDomainEventStateDeregisterID(conn, + ret = virObjectEventStateDeregisterID(conn, driver->domainEventState, callbackID); umlDriverUnlock(driver); @@ -2693,7 +2693,7 @@ umlConnectDomainEventDeregisterAny(virConnectPtr conn, static void umlDomainEventQueue(struct uml_driver *driver, virDomainEventPtr 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 983a595..cfb2ca0 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -213,7 +213,7 @@ typedef struct { #else /* !(VBOX_API_VERSION == 2002) */ /* Async event handling */ - virDomainEventStatePtr domainEvents; + virObjectEventStatePtr domainEvents; int fdWatch; # if VBOX_API_VERSION <= 3002 @@ -990,7 +990,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); } @@ -1055,7 +1055,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; } @@ -6988,7 +6988,7 @@ vboxCallbackOnMachineStateChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED, ev = virDomainEventNewFromDom(dom, event, detail); if (ev) - virDomainEventStateQueue(g_pVBoxGlobalData->domainEvents, ev); + virObjectEventStateQueue(g_pVBoxGlobalData->domainEvents, ev); } } @@ -7092,7 +7092,7 @@ vboxCallbackOnMachineRegistered(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED, ev = virDomainEventNewFromDom(dom, event, detail); if (ev) - virDomainEventStateQueue(g_pVBoxGlobalData->domainEvents, ev); + virObjectEventStateQueue(g_pVBoxGlobalData->domainEvents, ev); } } @@ -7317,7 +7317,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); @@ -7440,7 +7440,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..82c1887 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); @@ -2951,7 +2951,7 @@ void xenUnifiedDomainEventDispatch(xenUnifiedPrivatePtr priv, 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..a4b9149 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 */ 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.4

Keep the legacy Domain lifecycle event functions as is. --- src/conf/domain_event.c | 94 ++++++++++++++++++++++++++++--------------------- src/conf/domain_event.h | 3 -- 2 files changed, 53 insertions(+), 44 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 5389aef..8442db5 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -43,11 +43,13 @@ typedef virObjectMeta *virObjectMetaPtr; typedef struct _virObjectEventQueue virObjectEventQueue; typedef virObjectEventQueue *virObjectEventQueuePtr; -struct _virDomainEventCallbackList { +struct _virObjectEventCallbackList { unsigned int nextID; unsigned int count; virObjectEventCallbackPtr *callbacks; }; +typedef struct _virObjectEventCallbackList virObjectEventCallbackList; +typedef virObjectEventCallbackList *virObjectEventCallbackListPtr; struct _virObjectEventQueue { unsigned int count; @@ -56,7 +58,7 @@ struct _virObjectEventQueue { struct _virObjectEventState { /* The list of domain event callbacks */ - virDomainEventCallbackListPtr callbacks; + virObjectEventCallbackListPtr callbacks; /* The queue of object events */ virObjectEventQueuePtr queue; /* Timer for flushing events queue */ @@ -132,13 +134,13 @@ struct _virDomainEvent { }; /** - * virDomainEventCallbackListFree: + * virObjectEventCallbackListFree: * @list: event callback list head * * Free the memory in the domain event callback list */ static void -virDomainEventCallbackListFree(virDomainEventCallbackListPtr list) +virObjectEventCallbackListFree(virObjectEventCallbackListPtr list) { size_t i; if (!list) @@ -161,11 +163,11 @@ virDomainEventCallbackListFree(virDomainEventCallbackListPtr list) * @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 virDomainEventCallbackListRemove(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, + virObjectEventCallbackListPtr cbList, virConnectDomainEventCallback callback) { int ret = 0; @@ -207,16 +209,16 @@ virDomainEventCallbackListRemove(virConnectPtr conn, /** - * virDomainEventCallbackListRemoveID: + * virObjectEventCallbackListRemoveID: * @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, +virObjectEventCallbackListRemoveID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, int callbackID) { int ret = 0; @@ -258,7 +260,7 @@ virDomainEventCallbackListRemoveID(virConnectPtr conn, static int virDomainEventCallbackListMarkDelete(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, + virObjectEventCallbackListPtr cbList, virConnectDomainEventCallback callback) { int ret = 0; @@ -283,8 +285,8 @@ virDomainEventCallbackListMarkDelete(virConnectPtr conn, static int -virDomainEventCallbackListMarkDeleteID(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, +virObjectEventCallbackListMarkDeleteID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, int callbackID) { int ret = 0; @@ -308,7 +310,7 @@ virDomainEventCallbackListMarkDeleteID(virConnectPtr conn, static int -virDomainEventCallbackListPurgeMarked(virDomainEventCallbackListPtr cbList) +virObjectEventCallbackListPurgeMarked(virObjectEventCallbackListPtr cbList) { int old_count = cbList->count; int n; @@ -338,20 +340,25 @@ virDomainEventCallbackListPurgeMarked(virDomainEventCallbackListPtr cbList) /** - * virDomainEventCallbackListAddID: + * virObjectEventCallbackListAddID: * @conn: pointer to the connection * @cbList: the list + * @uuid: the uuid of the object to filter on + * @name: the name of the object to filter on + * @id: the ID of the object to filter on * @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 + * Internal function to add a callback from a virObjectEventCallbackListPtr */ static int -virDomainEventCallbackListAddID(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, - virDomainPtr dom, +virObjectEventCallbackListAddID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, + unsigned char uuid[VIR_UUID_BUFLEN], + const char *name, + int id, int eventID, virConnectDomainEventGenericCallback callback, void *opaque, @@ -372,10 +379,10 @@ virDomainEventCallbackListAddID(virConnectPtr conn, if (cbList->callbacks[i]->cb == VIR_DOMAIN_EVENT_CALLBACK(callback) && cbList->callbacks[i]->eventID == eventID && cbList->callbacks[i]->conn == conn && - ((dom && cbList->callbacks[i]->meta && + ((uuid && cbList->callbacks[i]->meta && memcmp(cbList->callbacks[i]->meta->uuid, - dom->uuid, VIR_UUID_BUFLEN) == 0) || - (!dom && !cbList->callbacks[i]->meta))) { + uuid, VIR_UUID_BUFLEN) == 0) || + (!uuid && !cbList->callbacks[i]->meta))) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("event callback already tracked")); return -1; @@ -390,13 +397,13 @@ virDomainEventCallbackListAddID(virConnectPtr conn, event->opaque = opaque; event->freecb = freecb; - if (dom) { + if (name && uuid && id > 0) { if (VIR_ALLOC(event->meta) < 0) goto error; - if (VIR_STRDUP(event->meta->name, dom->name) < 0) + if (VIR_STRDUP(event->meta->name, name) < 0) goto error; - memcpy(event->meta->uuid, dom->uuid, VIR_UUID_BUFLEN); - event->meta->id = dom->id; + memcpy(event->meta->uuid, uuid, VIR_UUID_BUFLEN); + event->meta->id = id; } /* Make space on list */ @@ -440,16 +447,16 @@ error: * @callback: the callback to add * @opaque: opaque data tio pass to callback * - * Internal function to add a callback from a virDomainEventCallbackListPtr + * Internal function to add a callback from a virObjectEventCallbackListPtr */ static int virDomainEventCallbackListAdd(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, + virObjectEventCallbackListPtr cbList, virConnectDomainEventCallback callback, void *opaque, virFreeCallback freecb) { - return virDomainEventCallbackListAddID(conn, cbList, NULL, + return virObjectEventCallbackListAddID(conn, cbList, NULL, NULL, 0, VIR_DOMAIN_EVENT_ID_LIFECYCLE, VIR_DOMAIN_EVENT_CALLBACK(callback), opaque, freecb, NULL); @@ -458,8 +465,8 @@ virDomainEventCallbackListAdd(virConnectPtr conn, static int -virDomainEventCallbackListEventID(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, +virObjectEventCallbackListEventID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, int callbackID) { size_t i; @@ -602,7 +609,7 @@ virObjectEventStateFree(virObjectEventStatePtr state) if (!state) return; - virDomainEventCallbackListFree(state->callbacks); + virObjectEventCallbackListFree(state->callbacks); virObjectEventQueueFree(state->queue); if (state->timer != -1) @@ -1397,7 +1404,7 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, static void virDomainEventDispatch(virDomainEventPtr event, - virDomainEventCallbackListPtr callbacks, + virObjectEventCallbackListPtr callbacks, virDomainEventDispatchFunc dispatch, void *opaque) { @@ -1422,7 +1429,7 @@ virDomainEventDispatch(virDomainEventPtr event, static void virObjectEventQueueDispatch(virObjectEventQueuePtr queue, - virDomainEventCallbackListPtr callbacks, + virObjectEventCallbackListPtr callbacks, virDomainEventDispatchFunc dispatch, void *opaque) { @@ -1496,7 +1503,7 @@ virObjectEventStateFlush(virObjectEventStatePtr state) state); /* Purge any deleted callbacks */ - virDomainEventCallbackListPurgeMarked(state->callbacks); + virObjectEventCallbackListPurgeMarked(state->callbacks); state->isDispatching = false; virObjectEventStateUnlock(state); @@ -1594,9 +1601,14 @@ virDomainEventStateRegisterID(virConnectPtr conn, goto cleanup; } - ret = virDomainEventCallbackListAddID(conn, state->callbacks, - dom, eventID, cb, opaque, freecb, - callbackID); + if (dom == NULL) + ret = virObjectEventCallbackListAddID(conn, state->callbacks, NULL, + NULL, 0, eventID, cb, + opaque, freecb, callbackID); + else + ret = virObjectEventCallbackListAddID(conn, state->callbacks, dom->uuid, + dom->name, dom->id, eventID, cb, + opaque, freecb, callbackID); if (ret == -1 && state->callbacks->count == 0 && @@ -1668,10 +1680,10 @@ virObjectEventStateDeregisterID(virConnectPtr conn, virObjectEventStateLock(state); if (state->isDispatching) - ret = virDomainEventCallbackListMarkDeleteID(conn, + ret = virObjectEventCallbackListMarkDeleteID(conn, state->callbacks, callbackID); else - ret = virDomainEventCallbackListRemoveID(conn, + ret = virObjectEventCallbackListRemoveID(conn, state->callbacks, callbackID); if (state->callbacks->count == 0 && @@ -1705,7 +1717,7 @@ virObjectEventStateEventID(virConnectPtr conn, int ret; virObjectEventStateLock(state); - ret = virDomainEventCallbackListEventID(conn, + ret = virObjectEventCallbackListEventID(conn, state->callbacks, callbackID); virObjectEventStateUnlock(state); return ret; diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index fa0d409..fddc94b 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -31,9 +31,6 @@ typedef struct _virObjectEventCallback virObjectEventCallback; typedef virObjectEventCallback *virObjectEventCallbackPtr; -typedef struct _virDomainEventCallbackList virDomainEventCallbackList; -typedef virDomainEventCallbackList *virDomainEventCallbackListPtr; - /** * Dispatching domain events that come in while * in a call / response rpc -- 1.8.4.4

Keep virDomainEventStateRegisterID as a convenience wrapper around this new function. --- src/conf/domain_event.c | 130 ++++++++++++++++++++++++++++++----------------- src/conf/domain_event.h | 25 +++++++++ src/libvirt_private.syms | 1 + 3 files changed, 110 insertions(+), 46 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 8442db5..99f0340 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -32,6 +32,8 @@ #define VIR_FROM_THIS VIR_FROM_NONE +#define VIR_OBJECT_EVENT_CALLBACK(cb) ((virConnectObjectEventGenericCallback)(cb)) + struct _virObjectMeta { int id; char *name; @@ -73,7 +75,7 @@ struct _virObjectEventCallback { int eventID; virConnectPtr conn; virObjectMetaPtr meta; - virConnectDomainEventGenericCallback cb; + virConnectObjectEventGenericCallback cb; void *opaque; virFreeCallback freecb; int deleted; @@ -173,7 +175,7 @@ virDomainEventCallbackListRemove(virConnectPtr conn, 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; @@ -266,7 +268,7 @@ virDomainEventCallbackListMarkDelete(virConnectPtr conn, 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) { cbList->callbacks[i]->deleted = 1; @@ -360,7 +362,7 @@ virObjectEventCallbackListAddID(virConnectPtr conn, const char *name, int id, int eventID, - virConnectDomainEventGenericCallback callback, + virConnectObjectEventGenericCallback callback, void *opaque, virFreeCallback freecb, int *callbackID) @@ -376,7 +378,7 @@ virObjectEventCallbackListAddID(virConnectPtr conn, /* 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) && + if (cbList->callbacks[i]->cb == VIR_OBJECT_EVENT_CALLBACK(callback) && cbList->callbacks[i]->eventID == eventID && cbList->callbacks[i]->conn == conn && ((uuid && cbList->callbacks[i]->meta && @@ -458,7 +460,7 @@ virDomainEventCallbackListAdd(virConnectPtr conn, { return virObjectEventCallbackListAddID(conn, cbList, NULL, NULL, 0, VIR_DOMAIN_EVENT_ID_LIFECYCLE, - VIR_DOMAIN_EVENT_CALLBACK(callback), + VIR_OBJECT_EVENT_CALLBACK(callback), opaque, freecb, NULL); } @@ -1240,9 +1242,9 @@ virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, } -typedef void (*virDomainEventDispatchFunc)(virConnectPtr conn, +typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, virDomainEventPtr event, - virConnectDomainEventGenericCallback cb, + virConnectObjectEventGenericCallback cb, void *cbopaque, void *opaque); @@ -1405,7 +1407,7 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, static void virDomainEventDispatch(virDomainEventPtr event, virObjectEventCallbackListPtr callbacks, - virDomainEventDispatchFunc dispatch, + virObjectEventDispatchFunc dispatch, void *opaque) { size_t i; @@ -1430,7 +1432,7 @@ virDomainEventDispatch(virDomainEventPtr event, static void virObjectEventQueueDispatch(virObjectEventQueuePtr queue, virObjectEventCallbackListPtr callbacks, - virDomainEventDispatchFunc dispatch, + virObjectEventDispatchFunc dispatch, void *opaque) { size_t i; @@ -1468,7 +1470,7 @@ virObjectEventStateQueue(virObjectEventStatePtr state, static void virObjectEventStateDispatchFunc(virConnectPtr conn, virDomainEventPtr event, - virConnectDomainEventGenericCallback cb, + virConnectObjectEventGenericCallback cb, void *cbopaque, void *opaque) { @@ -1476,7 +1478,8 @@ virObjectEventStateDispatchFunc(virConnectPtr conn, /* Drop the lock whle dispatching, for sake of re-entrancy */ virObjectEventStateUnlock(state); - virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL); + virDomainEventDispatchDefaultFunc(conn, event, + VIR_DOMAIN_EVENT_CALLBACK(cb), cbopaque, NULL); virObjectEventStateLock(state); } @@ -1511,6 +1514,65 @@ virObjectEventStateFlush(virObjectEventStatePtr 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, + 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, + virDomainEventTimer, + 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; +} + + +/** * virDomainEventStateRegister: * @conn: connection to associate with callback * @state: object event state @@ -1586,40 +1648,16 @@ virDomainEventStateRegisterID(virConnectPtr conn, virFreeCallback freecb, int *callbackID) { - int ret = -1; - - virObjectEventStateLock(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; - } - - if (dom == NULL) - ret = virObjectEventCallbackListAddID(conn, state->callbacks, NULL, - NULL, 0, eventID, cb, - opaque, freecb, callbackID); - else - ret = virObjectEventCallbackListAddID(conn, state->callbacks, dom->uuid, - dom->name, dom->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; + if (dom) + return virObjectEventStateRegisterID(conn, state, dom->uuid, dom->name, + dom->id, eventID, + VIR_OBJECT_EVENT_CALLBACK(cb), + opaque, freecb, callbackID); + else + 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 fddc94b..f28a866 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -137,6 +137,19 @@ 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, virDomainEventPtr event) @@ -162,6 +175,18 @@ virDomainEventStateDeregister(virConnectPtr conn, virConnectDomainEventCallback callback) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3); int +virObjectEventStateRegisterID(virConnectPtr conn, + virObjectEventStatePtr state, + unsigned char *uuid, + 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) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 3933b40..a14e290 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -455,6 +455,7 @@ virObjectEventStateEventID; virObjectEventStateFree; virObjectEventStateNew; virObjectEventStateQueue; +virObjectEventStateRegisterID; # conf/domain_nwfilter.h -- 1.8.4.4

This change may be confusing at first, but provides a much more consistent naming scheme for the virObjectEvent children construction functions. --- src/conf/domain_event.c | 154 ++++++++++++++++++++++++------------------------ 1 file changed, 77 insertions(+), 77 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index c2b2210..23d4965 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -757,11 +757,11 @@ static void *virObjectEventNew(virClassPtr klass, return event; } -static void *virDomainEventNewInternal(virClassPtr klass, - int eventID, - int id, - const char *name, - const unsigned char *uuid) +static void *virDomainEventNew(virClassPtr klass, + int eventID, + int id, + const char *name, + const unsigned char *uuid) { virDomainEventPtr event; @@ -797,9 +797,9 @@ virDomainEventPtr virDomainEventLifecycleNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - if (!(event = virDomainEventNewInternal(virDomainEventLifecycleClass, - VIR_DOMAIN_EVENT_ID_LIFECYCLE, - id, name, uuid))) + if (!(event = virDomainEventNew(virDomainEventLifecycleClass, + VIR_DOMAIN_EVENT_ID_LIFECYCLE, + id, name, uuid))) return NULL; event->type = type; @@ -831,9 +831,9 @@ virDomainEventPtr virDomainEventRebootNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - return virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_REBOOT, - id, name, uuid); + return virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_REBOOT, + id, name, uuid); } virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom) @@ -841,9 +841,9 @@ virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom) if (virObjectEventInitialize() < 0) return NULL; - return virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_REBOOT, - dom->id, dom->name, dom->uuid); + return virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_REBOOT, + dom->id, dom->name, dom->uuid); } virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) @@ -851,9 +851,9 @@ virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) if (virObjectEventInitialize() < 0) return NULL; - return virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_REBOOT, - obj->def->id, obj->def->name, obj->def->uuid); + return virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_REBOOT, + obj->def->id, obj->def->name, obj->def->uuid); } virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, @@ -864,9 +864,9 @@ virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_RTC_CHANGE, - dom->id, dom->name, dom->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_RTC_CHANGE, + dom->id, dom->name, dom->uuid))) return NULL; ev->data.rtcChange.offset = offset; @@ -881,10 +881,10 @@ virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_RTC_CHANGE, - obj->def->id, obj->def->name, - obj->def->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_RTC_CHANGE, + obj->def->id, obj->def->name, + obj->def->uuid))) return NULL; ev->data.rtcChange.offset = offset; @@ -900,9 +900,9 @@ virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_WATCHDOG, - dom->id, dom->name, dom->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_WATCHDOG, + dom->id, dom->name, dom->uuid))) return NULL; ev->data.watchdog.action = action; @@ -917,10 +917,10 @@ virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_WATCHDOG, - obj->def->id, obj->def->name, - obj->def->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_WATCHDOG, + obj->def->id, obj->def->name, + obj->def->uuid))) return NULL; ev->data.watchdog.action = action; @@ -940,8 +940,8 @@ static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, event, - dom->id, dom->name, dom->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, event, + dom->id, dom->name, dom->uuid))) return NULL; ev->data.ioError.action = action; @@ -967,9 +967,9 @@ static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, event, - obj->def->id, obj->def->name, - obj->def->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, event, + obj->def->id, obj->def->name, + obj->def->uuid))) return NULL; ev->data.ioError.action = action; @@ -1038,9 +1038,9 @@ virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_GRAPHICS, - dom->id, dom->name, dom->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_GRAPHICS, + dom->id, dom->name, dom->uuid))) return NULL; ev->data.graphics.phase = phase; @@ -1067,10 +1067,10 @@ virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_GRAPHICS, - obj->def->id, obj->def->name, - obj->def->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_GRAPHICS, + obj->def->id, obj->def->name, + obj->def->uuid))) return NULL; ev->data.graphics.phase = phase; @@ -1094,9 +1094,9 @@ virDomainEventBlockJobNew(int id, const char *name, unsigned char *uuid, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_BLOCK_JOB, - id, name, uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_BLOCK_JOB, + id, name, uuid))) return NULL; if (VIR_STRDUP(ev->data.blockJob.path, path) < 0) { @@ -1134,9 +1134,9 @@ virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom) if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, - dom->id, dom->name, dom->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, + dom->id, dom->name, dom->uuid))) return NULL; return ev; } @@ -1149,10 +1149,10 @@ virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, - obj->def->id, obj->def->name, - obj->def->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, + obj->def->id, obj->def->name, + obj->def->uuid))) return NULL; return ev; } @@ -1169,9 +1169,9 @@ virDomainEventDiskChangeNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_DISK_CHANGE, - id, name, uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_DISK_CHANGE, + id, name, uuid))) return NULL; if (VIR_STRDUP(ev->data.diskChange.devAlias, devAlias) < 0) @@ -1225,9 +1225,9 @@ virDomainEventTrayChangeNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, - id, name, uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, + id, name, uuid))) return NULL; if (VIR_STRDUP(ev->data.trayChange.devAlias, devAlias) < 0) @@ -1270,9 +1270,9 @@ virDomainEventPMWakeupNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_PMWAKEUP, - id, name, uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_PMWAKEUP, + id, name, uuid))) return NULL; return ev; @@ -1301,9 +1301,9 @@ virDomainEventPMSuspendNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_PMSUSPEND, - id, name, uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_PMSUSPEND, + id, name, uuid))) return NULL; return ev; @@ -1332,9 +1332,9 @@ virDomainEventPMSuspendDiskNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK, - id, name, uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK, + id, name, uuid))) return NULL; return ev; } @@ -1361,9 +1361,9 @@ virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, - dom->id, dom->name, dom->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, + dom->id, dom->name, dom->uuid))) return NULL; ev->data.balloonChange.actual = actual; @@ -1378,9 +1378,9 @@ virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, - obj->def->id, obj->def->name, obj->def->uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, + obj->def->id, obj->def->name, obj->def->uuid))) return NULL; ev->data.balloonChange.actual = actual; @@ -1399,9 +1399,9 @@ virDomainEventDeviceRemovedNew(int id, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED, - id, name, uuid))) + if (!(ev = virDomainEventNew(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED, + id, name, uuid))) return NULL; if (VIR_STRDUP(ev->data.deviceRemoved.devAlias, devAlias) < 0) -- 1.8.4.4

--- src/conf/domain_event.c | 53 +++++++++++++++++++++++++++++++++++-------------- 1 file changed, 38 insertions(+), 15 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 23d4965..ab38a3b 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -86,9 +86,11 @@ struct _virObjectEventCallback { static virClassPtr virObjectEventClass; static virClassPtr virDomainEventClass; static virClassPtr virDomainEventLifecycleClass; +static virClassPtr virDomainEventRTCChangeClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); +static void virDomainEventRTCChangeDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -102,9 +104,6 @@ struct _virDomainEvent { union { struct { - long long offset; - } rtcChange; - struct { int action; } watchdog; struct { @@ -154,6 +153,13 @@ struct _virDomainEventLifecycle { typedef struct _virDomainEventLifecycle virDomainEventLifecycle; typedef virDomainEventLifecycle *virDomainEventLifecyclePtr; +struct _virDomainEventRTCChange { + virDomainEvent parent; + + long long offset; +}; +typedef struct _virDomainEventRTCChange virDomainEventRTCChange; +typedef virDomainEventRTCChange *virDomainEventRTCChangePtr; static int virObjectEventOnceInit(void) { @@ -173,6 +179,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventLifecycle), virDomainEventLifecycleDispose))) return -1; + if (!(virDomainEventRTCChangeClass = virClassNew( + virDomainEventClass, + "virDomainEventRTCChange", + sizeof(virDomainEventRTCChange), + virDomainEventRTCChangeDispose))) + return -1; return 0; } @@ -259,6 +271,12 @@ static void virDomainEventLifecycleDispose(void *obj) VIR_DEBUG("obj=%p", event); } +static void virDomainEventRTCChangeDispose(void *obj) +{ + virDomainEventRTCChangePtr event = obj; + VIR_DEBUG("obj=%p", event); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -859,37 +877,37 @@ virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset) { - virDomainEventPtr ev; + virDomainEventRTCChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventRTCChangeClass, VIR_DOMAIN_EVENT_ID_RTC_CHANGE, dom->id, dom->name, dom->uuid))) return NULL; - ev->data.rtcChange.offset = offset; + ev->offset = offset; - return ev; + return (virDomainEventPtr)ev; } virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset) { - virDomainEventPtr ev; + virDomainEventRTCChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventRTCChangeClass, VIR_DOMAIN_EVENT_ID_RTC_CHANGE, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - ev->data.rtcChange.offset = offset; + ev->offset = offset; - return ev; + return (virDomainEventPtr)ev; } virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, @@ -1497,10 +1515,15 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, goto cleanup; case VIR_DOMAIN_EVENT_ID_RTC_CHANGE: - ((virConnectDomainEventRTCChangeCallback)cb)(conn, dom, - event->data.rtcChange.offset, - cbopaque); - goto cleanup; + { + virDomainEventRTCChangePtr rtcChangeEvent; + + rtcChangeEvent = (virDomainEventRTCChangePtr)event; + ((virConnectDomainEventRTCChangeCallback)cb)(conn, dom, + rtcChangeEvent->offset, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_WATCHDOG: ((virConnectDomainEventWatchdogCallback)cb)(conn, dom, -- 1.8.4.4

--- src/conf/domain_event.c | 60 +++++++++++++++++++++++++++++++++---------------- 1 file changed, 41 insertions(+), 19 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index ab38a3b..63119b2 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -87,10 +87,12 @@ static virClassPtr virObjectEventClass; static virClassPtr virDomainEventClass; static virClassPtr virDomainEventLifecycleClass; static virClassPtr virDomainEventRTCChangeClass; +static virClassPtr virDomainEventWatchdogClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); static void virDomainEventRTCChangeDispose(void *obj); +static void virDomainEventWatchdogDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -104,9 +106,6 @@ struct _virDomainEvent { union { struct { - int action; - } watchdog; - struct { char *srcPath; char *devAlias; int action; @@ -161,6 +160,14 @@ struct _virDomainEventRTCChange { typedef struct _virDomainEventRTCChange virDomainEventRTCChange; typedef virDomainEventRTCChange *virDomainEventRTCChangePtr; +struct _virDomainEventWatchdog { + virDomainEvent parent; + + int action; +}; +typedef struct _virDomainEventWatchdog virDomainEventWatchdog; +typedef virDomainEventWatchdog *virDomainEventWatchdogPtr; + static int virObjectEventOnceInit(void) { if (!(virObjectEventClass = virClassNew(virClassForObject(), @@ -185,6 +192,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventRTCChange), virDomainEventRTCChangeDispose))) return -1; + if (!(virDomainEventWatchdogClass = virClassNew( + virDomainEventClass, + "virDomainEventWatchdog", + sizeof(virDomainEventWatchdog), + virDomainEventWatchdogDispose))) + return -1; return 0; } @@ -277,6 +290,12 @@ static void virDomainEventRTCChangeDispose(void *obj) VIR_DEBUG("obj=%p", event); } +static void virDomainEventWatchdogDispose(void *obj) +{ + virDomainEventWatchdogPtr event = obj; + VIR_DEBUG("obj=%p", event); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -910,40 +929,38 @@ virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, return (virDomainEventPtr)ev; } -virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, - int action) +virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action) { - virDomainEventPtr ev; + virDomainEventWatchdogPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventWatchdogClass, VIR_DOMAIN_EVENT_ID_WATCHDOG, dom->id, dom->name, dom->uuid))) return NULL; - ev->data.watchdog.action = action; + ev->action = action; - return ev; + return (virDomainEventPtr)ev; } -virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, - int action) +virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action) { - virDomainEventPtr ev; + virDomainEventWatchdogPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventWatchdogClass, VIR_DOMAIN_EVENT_ID_WATCHDOG, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - ev->data.watchdog.action = action; + ev->action = action; - return ev; + return (virDomainEventPtr)ev; } static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event, @@ -1526,10 +1543,15 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, } case VIR_DOMAIN_EVENT_ID_WATCHDOG: - ((virConnectDomainEventWatchdogCallback)cb)(conn, dom, - event->data.watchdog.action, - cbopaque); - goto cleanup; + { + virDomainEventWatchdogPtr watchdogEvent; + + watchdogEvent = (virDomainEventWatchdogPtr)event; + ((virConnectDomainEventWatchdogCallback)cb)(conn, dom, + watchdogEvent->action, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_IO_ERROR: ((virConnectDomainEventIOErrorCallback)cb)(conn, dom, -- 1.8.4.4

--- src/conf/domain_event.c | 105 ++++++++++++++++++++++++++++++------------------ 1 file changed, 66 insertions(+), 39 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 63119b2..de3664f 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -88,11 +88,13 @@ static virClassPtr virDomainEventClass; static virClassPtr virDomainEventLifecycleClass; static virClassPtr virDomainEventRTCChangeClass; static virClassPtr virDomainEventWatchdogClass; +static virClassPtr virDomainEventIOErrorClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); static void virDomainEventRTCChangeDispose(void *obj); static void virDomainEventWatchdogDispose(void *obj); +static void virDomainEventIOErrorDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -106,12 +108,6 @@ struct _virDomainEvent { union { struct { - char *srcPath; - char *devAlias; - int action; - char *reason; - } ioError; - struct { int phase; virDomainEventGraphicsAddressPtr local; virDomainEventGraphicsAddressPtr remote; @@ -168,6 +164,17 @@ struct _virDomainEventWatchdog { typedef struct _virDomainEventWatchdog virDomainEventWatchdog; typedef virDomainEventWatchdog *virDomainEventWatchdogPtr; +struct _virDomainEventIOError { + virDomainEvent parent; + + char *srcPath; + char *devAlias; + int action; + char *reason; +}; +typedef struct _virDomainEventIOError virDomainEventIOError; +typedef virDomainEventIOError *virDomainEventIOErrorPtr; + static int virObjectEventOnceInit(void) { if (!(virObjectEventClass = virClassNew(virClassForObject(), @@ -198,6 +205,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventWatchdog), virDomainEventWatchdogDispose))) return -1; + if (!(virDomainEventIOErrorClass = virClassNew( + virDomainEventClass, + "virDomainEventIOError", + sizeof(virDomainEventIOError), + virDomainEventIOErrorDispose))) + return -1; return 0; } @@ -229,12 +242,6 @@ static void virDomainEventDispose(void *obj) VIR_DEBUG("obj=%p", event); switch (virObjectEventGetEventID(event)) { - 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) { @@ -296,6 +303,16 @@ static void virDomainEventWatchdogDispose(void *obj) VIR_DEBUG("obj=%p", event); } +static void virDomainEventIOErrorDispose(void *obj) +{ + virDomainEventIOErrorPtr event = obj; + VIR_DEBUG("obj=%p", event); + + VIR_FREE(event->srcPath); + VIR_FREE(event->devAlias); + VIR_FREE(event->reason); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -970,24 +987,24 @@ static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event, int action, const char *reason) { - virDomainEventPtr ev; + virDomainEventIOErrorPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, event, + if (!(ev = virDomainEventNew(virDomainEventIOErrorClass, event, dom->id, dom->name, dom->uuid))) return NULL; - 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) { + ev->action = action; + if (VIR_STRDUP(ev->srcPath, srcPath) < 0 || + VIR_STRDUP(ev->devAlias, devAlias) < 0 || + VIR_STRDUP(ev->reason, reason) < 0) { virObjectUnref(ev); ev = NULL; } - return ev; + return (virDomainEventPtr)ev; } static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event, @@ -997,25 +1014,25 @@ static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event, int action, const char *reason) { - virDomainEventPtr ev; + virDomainEventIOErrorPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, event, + if (!(ev = virDomainEventNew(virDomainEventIOErrorClass, event, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - 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) { + ev->action = action; + if (VIR_STRDUP(ev->srcPath, srcPath) < 0 || + VIR_STRDUP(ev->devAlias, devAlias) < 0 || + VIR_STRDUP(ev->reason, reason) < 0) { virObjectUnref(ev); ev = NULL; } - return ev; + return (virDomainEventPtr)ev; } virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom, @@ -1554,21 +1571,31 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, } 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; + { + virDomainEventIOErrorPtr ioErrorEvent; + + ioErrorEvent = (virDomainEventIOErrorPtr)event; + ((virConnectDomainEventIOErrorCallback)cb)(conn, dom, + ioErrorEvent->srcPath, + ioErrorEvent->devAlias, + ioErrorEvent->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; + { + virDomainEventIOErrorPtr ioErrorEvent; + + ioErrorEvent = (virDomainEventIOErrorPtr)event; + ((virConnectDomainEventIOErrorReasonCallback)cb)(conn, dom, + ioErrorEvent->srcPath, + ioErrorEvent->devAlias, + ioErrorEvent->action, + ioErrorEvent->reason, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_GRAPHICS: ((virConnectDomainEventGraphicsCallback)cb)(conn, dom, -- 1.8.4.4

--- src/conf/domain_event.c | 148 +++++++++++++++++++++++++++--------------------- src/conf/domain_event.h | 20 +++---- 2 files changed, 95 insertions(+), 73 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index de3664f..e145157 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -89,12 +89,14 @@ static virClassPtr virDomainEventLifecycleClass; static virClassPtr virDomainEventRTCChangeClass; static virClassPtr virDomainEventWatchdogClass; static virClassPtr virDomainEventIOErrorClass; +static virClassPtr virDomainEventGraphicsClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); static void virDomainEventRTCChangeDispose(void *obj); static void virDomainEventWatchdogDispose(void *obj); static void virDomainEventIOErrorDispose(void *obj); +static void virDomainEventGraphicsDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -108,13 +110,6 @@ struct _virDomainEvent { union { struct { - int phase; - virDomainEventGraphicsAddressPtr local; - virDomainEventGraphicsAddressPtr remote; - char *authScheme; - virDomainEventGraphicsSubjectPtr subject; - } graphics; - struct { char *path; int type; int status; @@ -175,6 +170,18 @@ struct _virDomainEventIOError { typedef struct _virDomainEventIOError virDomainEventIOError; typedef virDomainEventIOError *virDomainEventIOErrorPtr; +struct _virDomainEventGraphics { + virDomainEvent parent; + + int phase; + virDomainEventGraphicsAddressPtr local; + virDomainEventGraphicsAddressPtr remote; + char *authScheme; + virDomainEventGraphicsSubjectPtr subject; +}; +typedef struct _virDomainEventGraphics virDomainEventGraphics; +typedef virDomainEventGraphics *virDomainEventGraphicsPtr; + static int virObjectEventOnceInit(void) { if (!(virObjectEventClass = virClassNew(virClassForObject(), @@ -211,6 +218,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventIOError), virDomainEventIOErrorDispose))) return -1; + if (!(virDomainEventGraphicsClass = virClassNew( + virDomainEventClass, + "virDomainEventGraphics", + sizeof(virDomainEventGraphics), + virDomainEventGraphicsDispose))) + return -1; return 0; } @@ -243,28 +256,6 @@ static void virDomainEventDispose(void *obj) switch (virObjectEventGetEventID(event)) { - 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; @@ -313,6 +304,32 @@ static void virDomainEventIOErrorDispose(void *obj) VIR_FREE(event->reason); } +static void virDomainEventGraphicsDispose(void *obj) +{ + virDomainEventGraphicsPtr event = obj; + VIR_DEBUG("obj=%p", event); + + if (event->local) { + VIR_FREE(event->local->node); + VIR_FREE(event->local->service); + VIR_FREE(event->local); + } + if (event->remote) { + VIR_FREE(event->remote->node); + VIR_FREE(event->remote->service); + VIR_FREE(event->remote); + } + VIR_FREE(event->authScheme); + if (event->subject) { + size_t i; + for (i = 0; i < event->subject->nidentity; i++) { + VIR_FREE(event->subject->identities[i].type); + VIR_FREE(event->subject->identities[i].name); + } + VIR_FREE(event->subject); + } +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1079,62 +1096,62 @@ virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, - int phase, - virDomainEventGraphicsAddressPtr local, - virDomainEventGraphicsAddressPtr remote, - const char *authScheme, - virDomainEventGraphicsSubjectPtr subject) + int phase, + virDomainEventGraphicsAddressPtr local, + virDomainEventGraphicsAddressPtr remote, + const char *authScheme, + virDomainEventGraphicsSubjectPtr subject) { - virDomainEventPtr ev; + virDomainEventGraphicsPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventGraphicsClass, VIR_DOMAIN_EVENT_ID_GRAPHICS, dom->id, dom->name, dom->uuid))) return NULL; - ev->data.graphics.phase = phase; - if (VIR_STRDUP(ev->data.graphics.authScheme, authScheme) < 0) { + ev->phase = phase; + if (VIR_STRDUP(ev->authScheme, authScheme) < 0) { virObjectUnref(ev); return NULL; } - ev->data.graphics.local = local; - ev->data.graphics.remote = remote; - ev->data.graphics.subject = subject; + ev->local = local; + ev->remote = remote; + ev->subject = subject; - return ev; + return (virDomainEventPtr)ev; } virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, - int phase, - virDomainEventGraphicsAddressPtr local, - virDomainEventGraphicsAddressPtr remote, - const char *authScheme, - virDomainEventGraphicsSubjectPtr subject) + int phase, + virDomainEventGraphicsAddressPtr local, + virDomainEventGraphicsAddressPtr remote, + const char *authScheme, + virDomainEventGraphicsSubjectPtr subject) { - virDomainEventPtr ev; + virDomainEventGraphicsPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventGraphicsClass, VIR_DOMAIN_EVENT_ID_GRAPHICS, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - ev->data.graphics.phase = phase; - if (VIR_STRDUP(ev->data.graphics.authScheme, authScheme) < 0) { + ev->phase = phase; + if (VIR_STRDUP(ev->authScheme, authScheme) < 0) { virObjectUnref(ev); return NULL; } - ev->data.graphics.local = local; - ev->data.graphics.remote = remote; - ev->data.graphics.subject = subject; + ev->local = local; + ev->remote = remote; + ev->subject = subject; - return ev; + return (virDomainEventPtr)ev; } static virDomainEventPtr @@ -1598,14 +1615,19 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, } 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; + { + virDomainEventGraphicsPtr graphicsEvent; + + graphicsEvent = (virDomainEventGraphicsPtr)event; + ((virConnectDomainEventGraphicsCallback)cb)(conn, dom, + graphicsEvent->phase, + graphicsEvent->local, + graphicsEvent->remote, + graphicsEvent->authScheme, + graphicsEvent->subject, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_CONTROL_ERROR: (cb)(conn, dom, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 5de8390..63b8c9f 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -89,17 +89,17 @@ virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, const char *reason); virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, - int phase, - virDomainEventGraphicsAddressPtr local, - virDomainEventGraphicsAddressPtr remote, - const char *authScheme, - virDomainEventGraphicsSubjectPtr subject); + int phase, + virDomainEventGraphicsAddressPtr local, + virDomainEventGraphicsAddressPtr remote, + const char *authScheme, + virDomainEventGraphicsSubjectPtr subject); virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, - int phase, - virDomainEventGraphicsAddressPtr local, - virDomainEventGraphicsAddressPtr remote, - const char *authScheme, - virDomainEventGraphicsSubjectPtr subject); + int phase, + virDomainEventGraphicsAddressPtr local, + virDomainEventGraphicsAddressPtr remote, + const char *authScheme, + virDomainEventGraphicsSubjectPtr subject); virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom); virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj); -- 1.8.4.4

--- src/conf/domain_event.c | 86 ++++++++++++++++++++++++++++++++----------------- src/conf/domain_event.h | 12 +++---- 2 files changed, 62 insertions(+), 36 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index e145157..91bdbae 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -90,6 +90,7 @@ static virClassPtr virDomainEventRTCChangeClass; static virClassPtr virDomainEventWatchdogClass; static virClassPtr virDomainEventIOErrorClass; static virClassPtr virDomainEventGraphicsClass; +static virClassPtr virDomainEventBlockJobClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); @@ -97,6 +98,7 @@ static void virDomainEventRTCChangeDispose(void *obj); static void virDomainEventWatchdogDispose(void *obj); static void virDomainEventIOErrorDispose(void *obj); static void virDomainEventGraphicsDispose(void *obj); +static void virDomainEventBlockJobDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -110,11 +112,6 @@ struct _virDomainEvent { union { struct { - char *path; - int type; - int status; - } blockJob; - struct { char *oldSrcPath; char *newSrcPath; char *devAlias; @@ -170,6 +167,16 @@ struct _virDomainEventIOError { typedef struct _virDomainEventIOError virDomainEventIOError; typedef virDomainEventIOError *virDomainEventIOErrorPtr; +struct _virDomainEventBlockJob { + virDomainEvent parent; + + char *path; + int type; + int status; +}; +typedef struct _virDomainEventBlockJob virDomainEventBlockJob; +typedef virDomainEventBlockJob *virDomainEventBlockJobPtr; + struct _virDomainEventGraphics { virDomainEvent parent; @@ -224,6 +231,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventGraphics), virDomainEventGraphicsDispose))) return -1; + if (!(virDomainEventBlockJobClass = virClassNew( + virDomainEventClass, + "virDomainEventBlockJob", + sizeof(virDomainEventBlockJob), + virDomainEventBlockJobDispose))) + return -1; return 0; } @@ -256,10 +269,6 @@ static void virDomainEventDispose(void *obj) switch (virObjectEventGetEventID(event)) { - 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); @@ -330,6 +339,14 @@ static void virDomainEventGraphicsDispose(void *obj) } } +static void virDomainEventBlockJobDispose(void *obj) +{ + virDomainEventBlockJobPtr event = obj; + VIR_DEBUG("obj=%p", event); + + VIR_FREE(event->path); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1154,43 +1171,47 @@ virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, return (virDomainEventPtr)ev; } -static virDomainEventPtr -virDomainEventBlockJobNew(int id, const char *name, unsigned char *uuid, - const char *path, int type, int status) +static +virDomainEventPtr virDomainEventBlockJobNew(int id, + const char *name, + unsigned char *uuid, + const char *path, + int type, + int status) { - virDomainEventPtr ev; + virDomainEventBlockJobPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventBlockJobClass, VIR_DOMAIN_EVENT_ID_BLOCK_JOB, id, name, uuid))) return NULL; - if (VIR_STRDUP(ev->data.blockJob.path, path) < 0) { + if (VIR_STRDUP(ev->path, path) < 0) { virObjectUnref(ev); return NULL; } - ev->data.blockJob.type = type; - ev->data.blockJob.status = status; + ev->type = type; + ev->status = status; - return ev; + return (virDomainEventPtr)ev; } virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, - const char *path, - int type, - int status) + const char *path, + int type, + int status) { return virDomainEventBlockJobNew(obj->def->id, obj->def->name, obj->def->uuid, path, type, status); } virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom, - const char *path, - int type, - int status) + const char *path, + int type, + int status) { return virDomainEventBlockJobNew(dom->id, dom->name, dom->uuid, path, type, status); @@ -1635,12 +1656,17 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, 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; + { + virDomainEventBlockJobPtr blockJobEvent; + + blockJobEvent = (virDomainEventBlockJobPtr)event; + ((virConnectDomainEventBlockJobCallback)cb)(conn, dom, + blockJobEvent->path, + blockJobEvent->type, + blockJobEvent->status, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_DISK_CHANGE: ((virConnectDomainEventDiskChangeCallback)cb)(conn, dom, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 63b8c9f..bf701f9 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -104,13 +104,13 @@ virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom); virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj); virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, - const char *path, - int type, - int status); + const char *path, + int type, + int status); virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom, - const char *path, - int type, - int status); + const char *path, + int type, + int status); virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj, const char *oldSrcPath, -- 1.8.4.4

--- src/conf/domain_event.c | 87 +++++++++++++++++++++++++++++++------------------ 1 file changed, 56 insertions(+), 31 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 91bdbae..49b87dd 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -91,6 +91,8 @@ static virClassPtr virDomainEventWatchdogClass; static virClassPtr virDomainEventIOErrorClass; static virClassPtr virDomainEventGraphicsClass; static virClassPtr virDomainEventBlockJobClass; +static virClassPtr virDomainEventDiskChangeClass; + static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); @@ -99,6 +101,7 @@ static void virDomainEventWatchdogDispose(void *obj); static void virDomainEventIOErrorDispose(void *obj); static void virDomainEventGraphicsDispose(void *obj); static void virDomainEventBlockJobDispose(void *obj); +static void virDomainEventDiskChangeDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -112,12 +115,6 @@ struct _virDomainEvent { union { struct { - char *oldSrcPath; - char *newSrcPath; - char *devAlias; - int reason; - } diskChange; - struct { char *devAlias; int reason; } trayChange; @@ -189,6 +186,18 @@ struct _virDomainEventGraphics { typedef struct _virDomainEventGraphics virDomainEventGraphics; typedef virDomainEventGraphics *virDomainEventGraphicsPtr; +struct _virDomainEventDiskChange { + virDomainEvent parent; + + char *oldSrcPath; + char *newSrcPath; + char *devAlias; + int reason; +}; +typedef struct _virDomainEventDiskChange virDomainEventDiskChange; +typedef virDomainEventDiskChange *virDomainEventDiskChangePtr; + + static int virObjectEventOnceInit(void) { if (!(virObjectEventClass = virClassNew(virClassForObject(), @@ -237,6 +246,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventBlockJob), virDomainEventBlockJobDispose))) return -1; + if (!(virDomainEventDiskChangeClass = virClassNew( + virDomainEventClass, + "virDomainEventDiskChange", + sizeof(virDomainEventDiskChange), + virDomainEventDiskChangeDispose))) + return -1; return 0; } @@ -269,11 +284,6 @@ static void virDomainEventDispose(void *obj) switch (virObjectEventGetEventID(event)) { - 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; @@ -347,6 +357,16 @@ static void virDomainEventBlockJobDispose(void *obj) VIR_FREE(event->path); } +static void virDomainEventDiskChangeDispose(void *obj) +{ + virDomainEventDiskChangePtr event = obj; + VIR_DEBUG("obj=%p", event); + + VIR_FREE(event->oldSrcPath); + VIR_FREE(event->newSrcPath); + VIR_FREE(event->devAlias); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1247,35 +1267,35 @@ virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) return ev; } -static virDomainEventPtr -virDomainEventDiskChangeNew(int id, const char *name, - unsigned char *uuid, - const char *oldSrcPath, - const char *newSrcPath, - const char *devAlias, int reason) +static +virDomainEventPtr virDomainEventDiskChangeNew(int id, const char *name, + unsigned char *uuid, + const char *oldSrcPath, + const char *newSrcPath, + const char *devAlias, int reason) { - virDomainEventPtr ev; + virDomainEventDiskChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventDiskChangeClass, VIR_DOMAIN_EVENT_ID_DISK_CHANGE, id, name, uuid))) return NULL; - if (VIR_STRDUP(ev->data.diskChange.devAlias, devAlias) < 0) + if (VIR_STRDUP(ev->devAlias, devAlias) < 0) goto error; - if (VIR_STRDUP(ev->data.diskChange.oldSrcPath, oldSrcPath) < 0) + if (VIR_STRDUP(ev->oldSrcPath, oldSrcPath) < 0) goto error; - if (VIR_STRDUP(ev->data.diskChange.newSrcPath, newSrcPath) < 0) + if (VIR_STRDUP(ev->newSrcPath, newSrcPath) < 0) goto error; - ev->data.diskChange.reason = reason; + ev->reason = reason; - return ev; + return (virDomainEventPtr)ev; error: virObjectUnref(ev); @@ -1669,13 +1689,18 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, } 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; + { + virDomainEventDiskChangePtr diskChangeEvent; + + diskChangeEvent = (virDomainEventDiskChangePtr)event; + ((virConnectDomainEventDiskChangeCallback)cb)(conn, dom, + diskChangeEvent->oldSrcPath, + diskChangeEvent->newSrcPath, + diskChangeEvent->devAlias, + diskChangeEvent->reason, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE: ((virConnectDomainEventTrayChangeCallback)cb)(conn, dom, -- 1.8.4.4

--- src/conf/domain_event.c | 57 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 40 insertions(+), 17 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 49b87dd..47b183a 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -92,6 +92,7 @@ static virClassPtr virDomainEventIOErrorClass; static virClassPtr virDomainEventGraphicsClass; static virClassPtr virDomainEventBlockJobClass; static virClassPtr virDomainEventDiskChangeClass; +static virClassPtr virDomainEventTrayChangeClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); @@ -102,6 +103,7 @@ static void virDomainEventIOErrorDispose(void *obj); static void virDomainEventGraphicsDispose(void *obj); static void virDomainEventBlockJobDispose(void *obj); static void virDomainEventDiskChangeDispose(void *obj); +static void virDomainEventTrayChangeDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -115,10 +117,6 @@ struct _virDomainEvent { union { struct { - char *devAlias; - int reason; - } trayChange; - struct { /* In unit of 1024 bytes */ unsigned long long actual; } balloonChange; @@ -197,6 +195,15 @@ struct _virDomainEventDiskChange { typedef struct _virDomainEventDiskChange virDomainEventDiskChange; typedef virDomainEventDiskChange *virDomainEventDiskChangePtr; +struct _virDomainEventTrayChange { + virDomainEvent parent; + + char *devAlias; + int reason; +}; +typedef struct _virDomainEventTrayChange virDomainEventTrayChange; +typedef virDomainEventTrayChange *virDomainEventTrayChangePtr; + static int virObjectEventOnceInit(void) { @@ -252,6 +259,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventDiskChange), virDomainEventDiskChangeDispose))) return -1; + if (!(virDomainEventTrayChangeClass = virClassNew( + virDomainEventClass, + "virDomainEventTrayChange", + sizeof(virDomainEventTrayChange), + virDomainEventTrayChangeDispose))) + return -1; return 0; } @@ -284,9 +297,6 @@ static void virDomainEventDispose(void *obj) switch (virObjectEventGetEventID(event)) { - 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; @@ -367,6 +377,14 @@ static void virDomainEventDiskChangeDispose(void *obj) VIR_FREE(event->devAlias); } +static void virDomainEventTrayChangeDispose(void *obj) +{ + virDomainEventTrayChangePtr event = obj; + VIR_DEBUG("obj=%p", event); + + VIR_FREE(event->devAlias); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1330,22 +1348,22 @@ virDomainEventTrayChangeNew(int id, const char *name, const char *devAlias, int reason) { - virDomainEventPtr ev; + virDomainEventTrayChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventTrayChangeClass, VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, id, name, uuid))) return NULL; - if (VIR_STRDUP(ev->data.trayChange.devAlias, devAlias) < 0) + if (VIR_STRDUP(ev->devAlias, devAlias) < 0) goto error; - ev->data.trayChange.reason = reason; + ev->reason = reason; - return ev; + return (virDomainEventPtr)ev; error: virObjectUnref(ev); @@ -1703,11 +1721,16 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, } case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE: - ((virConnectDomainEventTrayChangeCallback)cb)(conn, dom, - event->data.trayChange.devAlias, - event->data.trayChange.reason, - cbopaque); - goto cleanup; + { + virDomainEventTrayChangePtr trayChangeEvent; + + trayChangeEvent = (virDomainEventTrayChangePtr)event; + ((virConnectDomainEventTrayChangeCallback)cb)(conn, dom, + trayChangeEvent->devAlias, + trayChangeEvent->reason, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_PMWAKEUP: ((virConnectDomainEventPMWakeupCallback)cb)(conn, dom, 0, cbopaque); -- 1.8.4.4

--- src/conf/domain_event.c | 56 +++++++++++++++++++++++++++++++++++-------------- 1 file changed, 40 insertions(+), 16 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 47b183a..589ffea 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -93,6 +93,7 @@ static virClassPtr virDomainEventGraphicsClass; static virClassPtr virDomainEventBlockJobClass; static virClassPtr virDomainEventDiskChangeClass; static virClassPtr virDomainEventTrayChangeClass; +static virClassPtr virDomainEventBalloonChangeClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); @@ -104,6 +105,7 @@ static void virDomainEventGraphicsDispose(void *obj); static void virDomainEventBlockJobDispose(void *obj); static void virDomainEventDiskChangeDispose(void *obj); static void virDomainEventTrayChangeDispose(void *obj); +static void virDomainEventBalloonChangeDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -117,10 +119,6 @@ struct _virDomainEvent { union { struct { - /* In unit of 1024 bytes */ - unsigned long long actual; - } balloonChange; - struct { char *devAlias; } deviceRemoved; } data; @@ -204,6 +202,15 @@ struct _virDomainEventTrayChange { typedef struct _virDomainEventTrayChange virDomainEventTrayChange; typedef virDomainEventTrayChange *virDomainEventTrayChangePtr; +struct _virDomainEventBalloonChange { + virDomainEvent parent; + + /* In unit of 1024 bytes */ + unsigned long long actual; +}; +typedef struct _virDomainEventBalloonChange virDomainEventBalloonChange; +typedef virDomainEventBalloonChange *virDomainEventBalloonChangePtr; + static int virObjectEventOnceInit(void) { @@ -265,6 +272,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventTrayChange), virDomainEventTrayChangeDispose))) return -1; + if (!(virDomainEventBalloonChangeClass = virClassNew( + virDomainEventClass, + "virDomainEventBalloonChange", + sizeof(virDomainEventBalloonChange), + virDomainEventBalloonChangeDispose))) + return -1; return 0; } @@ -385,6 +398,12 @@ static void virDomainEventTrayChangeDispose(void *obj) VIR_FREE(event->devAlias); } +static void virDomainEventBalloonChangeDispose(void *obj) +{ + virDomainEventBalloonChangePtr event = obj; + VIR_DEBUG("obj=%p", event); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1484,36 +1503,36 @@ virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom) virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual) { - virDomainEventPtr ev; + virDomainEventBalloonChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventBalloonChangeClass, VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, dom->id, dom->name, dom->uuid))) return NULL; - ev->data.balloonChange.actual = actual; + ev->actual = actual; - return ev; + return (virDomainEventPtr)ev; } virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual) { - virDomainEventPtr ev; + virDomainEventBalloonChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventBalloonChangeClass, VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - ev->data.balloonChange.actual = actual; + ev->actual = actual; - return ev; + return (virDomainEventPtr)ev; } static virDomainEventPtr @@ -1741,10 +1760,15 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, goto cleanup; case VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE: - ((virConnectDomainEventBalloonChangeCallback)cb)(conn, dom, - event->data.balloonChange.actual, - cbopaque); - goto cleanup; + { + virDomainEventBalloonChangePtr balloonChangeEvent; + + balloonChangeEvent = (virDomainEventBalloonChangePtr)event; + ((virConnectDomainEventBalloonChangeCallback)cb)(conn, dom, + balloonChangeEvent->actual, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK: ((virConnectDomainEventPMSuspendDiskCallback)cb)(conn, dom, 0, cbopaque); -- 1.8.4.4

RIP virDomainEvent union. All data are now stored in each virObjectEvent subclass. --- src/conf/domain_event.c | 77 +++++++++++++++++++++++++++++-------------------- 1 file changed, 45 insertions(+), 32 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 589ffea..9108207 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -94,6 +94,7 @@ static virClassPtr virDomainEventBlockJobClass; static virClassPtr virDomainEventDiskChangeClass; static virClassPtr virDomainEventTrayChangeClass; static virClassPtr virDomainEventBalloonChangeClass; +static virClassPtr virDomainEventDeviceRemovedClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); @@ -106,6 +107,7 @@ static void virDomainEventBlockJobDispose(void *obj); static void virDomainEventDiskChangeDispose(void *obj); static void virDomainEventTrayChangeDispose(void *obj); static void virDomainEventBalloonChangeDispose(void *obj); +static void virDomainEventDeviceRemovedDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -116,12 +118,6 @@ struct _virDomainEvent { virObjectEvent parent; virObjectMeta meta; - - union { - struct { - char *devAlias; - } deviceRemoved; - } data; }; struct _virDomainEventLifecycle { @@ -211,6 +207,14 @@ struct _virDomainEventBalloonChange { typedef struct _virDomainEventBalloonChange virDomainEventBalloonChange; typedef virDomainEventBalloonChange *virDomainEventBalloonChangePtr; +struct _virDomainEventDeviceRemoved { + virDomainEvent parent; + + char *devAlias; +}; +typedef struct _virDomainEventDeviceRemoved virDomainEventDeviceRemoved; +typedef virDomainEventDeviceRemoved *virDomainEventDeviceRemovedPtr; + static int virObjectEventOnceInit(void) { @@ -278,6 +282,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventBalloonChange), virDomainEventBalloonChangeDispose))) return -1; + if (!(virDomainEventDeviceRemovedClass = virClassNew( + virDomainEventClass, + "virDomainEventDeviceRemoved", + sizeof(virDomainEventDeviceRemoved), + virDomainEventDeviceRemovedDispose))) + return -1; return 0; } @@ -308,13 +318,6 @@ static void virDomainEventDispose(void *obj) VIR_DEBUG("obj=%p", event); - switch (virObjectEventGetEventID(event)) { - - case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED: - VIR_FREE(event->data.deviceRemoved.devAlias); - break; - } - VIR_FREE(event->meta.name); } @@ -404,6 +407,14 @@ static void virDomainEventBalloonChangeDispose(void *obj) VIR_DEBUG("obj=%p", event); } +static void virDomainEventDeviceRemovedDispose(void *obj) +{ + virDomainEventDeviceRemovedPtr event = obj; + VIR_DEBUG("obj=%p", event); + + VIR_FREE(event->devAlias); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1535,43 +1546,40 @@ virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, return (virDomainEventPtr)ev; } -static virDomainEventPtr -virDomainEventDeviceRemovedNew(int id, - const char *name, - unsigned char *uuid, - const char *devAlias) +static virDomainEventPtr virDomainEventDeviceRemovedNew(int id, + const char *name, + unsigned char *uuid, + const char *devAlias) { - virDomainEventPtr ev; + virDomainEventDeviceRemovedPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventDeviceRemovedClass, VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED, id, name, uuid))) return NULL; - if (VIR_STRDUP(ev->data.deviceRemoved.devAlias, devAlias) < 0) + if (VIR_STRDUP(ev->devAlias, devAlias) < 0) goto error; - return ev; + return (virDomainEventPtr)ev; error: virObjectUnref(ev); return NULL; } -virDomainEventPtr -virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, - const char *devAlias) +virDomainEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, + const char *devAlias) { return virDomainEventDeviceRemovedNew(obj->def->id, obj->def->name, obj->def->uuid, devAlias); } -virDomainEventPtr -virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, - const char *devAlias) +virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, + const char *devAlias) { return virDomainEventDeviceRemovedNew(dom->id, dom->name, dom->uuid, devAlias); @@ -1775,10 +1783,15 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, goto cleanup; case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED: - ((virConnectDomainEventDeviceRemovedCallback)cb)(conn, dom, - event->data.deviceRemoved.devAlias, - cbopaque); - goto cleanup; + { + virDomainEventDeviceRemovedPtr deviceRemovedEvent; + + deviceRemovedEvent = (virDomainEventDeviceRemovedPtr)event; + ((virConnectDomainEventDeviceRemovedCallback)cb)(conn, dom, + deviceRemovedEvent->devAlias, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_LAST: break; -- 1.8.4.4

The virDomainEvent class is kept as it indicates what meta informations are valid for the children classes. This may be useful in the future. --- src/conf/domain_event.c | 186 +++++++++++++++++++++++---------------------- src/conf/domain_event.h | 75 +++++++++--------- src/libxl/libxl_driver.c | 20 ++--- src/lxc/lxc_driver.c | 16 ++-- src/lxc/lxc_process.c | 6 +- src/qemu/qemu_domain.c | 4 +- src/qemu/qemu_domain.h | 2 +- src/qemu/qemu_driver.c | 42 +++++----- src/qemu/qemu_hotplug.c | 10 +-- src/qemu/qemu_migration.c | 12 +-- src/qemu/qemu_process.c | 48 ++++++------ src/remote/remote_driver.c | 36 ++++----- src/test/test_driver.c | 36 ++++----- src/uml/uml_driver.c | 18 ++--- src/vbox/vbox_tmpl.c | 4 +- src/xen/xen_driver.c | 2 +- src/xen/xen_driver.h | 2 +- src/xen/xen_inotify.c | 8 +- src/xen/xs_internal.c | 4 +- 19 files changed, 268 insertions(+), 263 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 9108207..3c14cec 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -55,7 +55,7 @@ typedef virObjectEventCallbackList *virObjectEventCallbackListPtr; struct _virObjectEventQueue { unsigned int count; - virDomainEventPtr *events; + virObjectEventPtr *events; }; struct _virObjectEventState { @@ -112,13 +112,17 @@ static void virDomainEventDeviceRemovedDispose(void *obj); struct _virObjectEvent { virObject parent; int eventID; + virObjectMeta meta; }; struct _virDomainEvent { virObjectEvent parent; - virObjectMeta meta; + /* Unused attribute to get virDomainEvent class being created */ + bool dummy; }; +typedef struct _virDomainEvent virDomainEvent; +typedef virDomainEvent *virDomainEventPtr; struct _virDomainEventLifecycle { virDomainEvent parent; @@ -310,6 +314,8 @@ static void virObjectEventDispose(void *obj) virObjectEventPtr event = obj; VIR_DEBUG("obj=%p", event); + + VIR_FREE(event->meta.name); } static void virDomainEventDispose(void *obj) @@ -317,8 +323,6 @@ static void virDomainEventDispose(void *obj) virDomainEventPtr event = obj; VIR_DEBUG("obj=%p", event); - - VIR_FREE(event->meta.name); } static void virDomainEventLifecycleDispose(void *obj) @@ -890,7 +894,10 @@ error: } static void *virObjectEventNew(virClassPtr klass, - int eventID) + int eventID, + int id, + const char *name, + const unsigned char *uuid) { virObjectEventPtr event; @@ -909,6 +916,13 @@ static void *virObjectEventNew(virClassPtr klass, event->eventID = eventID; + if (VIR_STRDUP(event->meta.name, name) < 0) { + VIR_FREE(event); + return NULL; + } + event->meta.id = id; + memcpy(event->meta.uuid, uuid, VIR_UUID_BUFLEN); + VIR_DEBUG("obj=%p", event); return event; } @@ -931,22 +945,16 @@ static void *virDomainEventNew(virClassPtr klass, return NULL; } - if (!(event = virObjectEventNew(klass, eventID))) - return NULL; - - if (VIR_STRDUP(event->meta.name, name) < 0) { - VIR_FREE(event); + if (!(event = virObjectEventNew(klass, eventID, + id, name, uuid))) return NULL; - } - event->meta.id = id; - memcpy(event->meta.uuid, uuid, VIR_UUID_BUFLEN); - return event; + return (virObjectEventPtr)event; } -virDomainEventPtr virDomainEventLifecycleNew(int id, const char *name, - const unsigned char *uuid, - int type, int detail) +virObjectEventPtr virDomainEventLifecycleNew(int id, const char *name, + const unsigned char *uuid, + int type, int detail) { virDomainEventLifecyclePtr event; @@ -961,27 +969,27 @@ virDomainEventPtr virDomainEventLifecycleNew(int id, const char *name, event->type = type; event->detail = detail; - return (virDomainEventPtr)event; + return (virObjectEventPtr)event; } -virDomainEventPtr virDomainEventLifecycleNewFromDom(virDomainPtr dom, int type, int detail) +virObjectEventPtr virDomainEventLifecycleNewFromDom(virDomainPtr dom, int type, int detail) { return virDomainEventLifecycleNew(dom->id, dom->name, dom->uuid, type, detail); } -virDomainEventPtr virDomainEventLifecycleNewFromObj(virDomainObjPtr obj, int type, int detail) +virObjectEventPtr virDomainEventLifecycleNewFromObj(virDomainObjPtr obj, int type, int detail) { return virDomainEventLifecycleNewFromDef(obj->def, type, detail); } -virDomainEventPtr virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detail) +virObjectEventPtr virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detail) { return virDomainEventLifecycleNew(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) { if (virObjectEventInitialize() < 0) @@ -992,7 +1000,7 @@ virDomainEventPtr virDomainEventRebootNew(int id, const char *name, id, name, uuid); } -virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom) +virObjectEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom) { if (virObjectEventInitialize() < 0) return NULL; @@ -1002,7 +1010,7 @@ virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom) dom->id, dom->name, dom->uuid); } -virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) +virObjectEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) { if (virObjectEventInitialize() < 0) return NULL; @@ -1012,7 +1020,7 @@ virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) obj->def->id, obj->def->name, obj->def->uuid); } -virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, +virObjectEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset) { virDomainEventRTCChangePtr ev; @@ -1027,9 +1035,9 @@ virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, ev->offset = offset; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset) { virDomainEventRTCChangePtr ev; @@ -1045,10 +1053,10 @@ virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, ev->offset = offset; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action) +virObjectEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action) { virDomainEventWatchdogPtr ev; @@ -1062,9 +1070,9 @@ virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action) ev->action = action; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action) +virObjectEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action) { virDomainEventWatchdogPtr ev; @@ -1079,10 +1087,10 @@ virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int acti ev->action = action; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event, +static virObjectEventPtr virDomainEventIOErrorNewFromDomImpl(int event, virDomainPtr dom, const char *srcPath, const char *devAlias, @@ -1106,10 +1114,10 @@ static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event, ev = NULL; } - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event, +static virObjectEventPtr virDomainEventIOErrorNewFromObjImpl(int event, virDomainObjPtr obj, const char *srcPath, const char *devAlias, @@ -1134,10 +1142,10 @@ static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event, ev = NULL; } - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom, +virObjectEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom, const char *srcPath, const char *devAlias, int action) @@ -1147,7 +1155,7 @@ virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom, action, NULL); } -virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj, const char *srcPath, const char *devAlias, int action) @@ -1157,7 +1165,7 @@ virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj, action, NULL); } -virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom, +virObjectEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom, const char *srcPath, const char *devAlias, int action, @@ -1168,7 +1176,7 @@ virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom, action, reason); } -virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, const char *srcPath, const char *devAlias, int action, @@ -1180,7 +1188,7 @@ virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, } -virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, +virObjectEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, int phase, virDomainEventGraphicsAddressPtr local, virDomainEventGraphicsAddressPtr remote, @@ -1206,10 +1214,10 @@ virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, ev->remote = remote; ev->subject = subject; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, int phase, virDomainEventGraphicsAddressPtr local, virDomainEventGraphicsAddressPtr remote, @@ -1236,11 +1244,11 @@ virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, ev->remote = remote; ev->subject = subject; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } static -virDomainEventPtr virDomainEventBlockJobNew(int id, +virObjectEventPtr virDomainEventBlockJobNew(int id, const char *name, unsigned char *uuid, const char *path, @@ -1264,10 +1272,10 @@ virDomainEventPtr virDomainEventBlockJobNew(int id, ev->type = type; ev->status = status; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, const char *path, int type, int status) @@ -1276,7 +1284,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) @@ -1285,9 +1293,9 @@ virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom, path, type, status); } -virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom) +virObjectEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom) { - virDomainEventPtr ev; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; @@ -1300,9 +1308,9 @@ virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom) } -virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) +virObjectEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) { - virDomainEventPtr ev; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; @@ -1316,7 +1324,7 @@ virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) } static -virDomainEventPtr virDomainEventDiskChangeNew(int id, const char *name, +virObjectEventPtr virDomainEventDiskChangeNew(int id, const char *name, unsigned char *uuid, const char *oldSrcPath, const char *newSrcPath, @@ -1343,14 +1351,14 @@ virDomainEventPtr virDomainEventDiskChangeNew(int id, const char *name, ev->reason = reason; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; error: virObjectUnref(ev); return NULL; } -virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj, const char *oldSrcPath, const char *newSrcPath, const char *devAlias, @@ -1361,7 +1369,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, @@ -1372,7 +1380,7 @@ virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom, devAlias, reason); } -static virDomainEventPtr +static virObjectEventPtr virDomainEventTrayChangeNew(int id, const char *name, unsigned char *uuid, const char *devAlias, @@ -1393,14 +1401,14 @@ virDomainEventTrayChangeNew(int id, const char *name, ev->reason = reason; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; error: virObjectUnref(ev); return NULL; } -virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, const char *devAlias, int reason) { @@ -1411,7 +1419,7 @@ virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, reason); } -virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom, +virObjectEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom, const char *devAlias, int reason) { @@ -1419,11 +1427,11 @@ virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom, devAlias, reason); } -static virDomainEventPtr +static virObjectEventPtr virDomainEventPMWakeupNew(int id, const char *name, unsigned char *uuid) { - virDomainEventPtr ev; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; @@ -1436,7 +1444,7 @@ virDomainEventPMWakeupNew(int id, const char *name, return ev; } -virDomainEventPtr +virObjectEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj) { return virDomainEventPMWakeupNew(obj->def->id, @@ -1444,17 +1452,17 @@ 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; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; @@ -1467,7 +1475,7 @@ virDomainEventPMSuspendNew(int id, const char *name, return ev; } -virDomainEventPtr +virObjectEventPtr virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj) { return virDomainEventPMSuspendNew(obj->def->id, @@ -1475,17 +1483,17 @@ 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; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; @@ -1497,7 +1505,7 @@ virDomainEventPMSuspendDiskNew(int id, const char *name, return ev; } -virDomainEventPtr +virObjectEventPtr virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj) { return virDomainEventPMSuspendDiskNew(obj->def->id, @@ -1505,13 +1513,13 @@ 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) { virDomainEventBalloonChangePtr ev; @@ -1526,9 +1534,9 @@ virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, ev->actual = actual; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual) { virDomainEventBalloonChangePtr ev; @@ -1543,10 +1551,10 @@ virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, ev->actual = actual; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; } -static virDomainEventPtr virDomainEventDeviceRemovedNew(int id, +static virObjectEventPtr virDomainEventDeviceRemovedNew(int id, const char *name, unsigned char *uuid, const char *devAlias) @@ -1564,21 +1572,21 @@ static virDomainEventPtr virDomainEventDeviceRemovedNew(int id, if (VIR_STRDUP(ev->devAlias, devAlias) < 0) goto error; - return (virDomainEventPtr)ev; + return (virObjectEventPtr)ev; error: virObjectUnref(ev); return NULL; } -virDomainEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, const char *devAlias) { return virDomainEventDeviceRemovedNew(obj->def->id, obj->def->name, obj->def->uuid, devAlias); } -virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, +virObjectEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, const char *devAlias) { return virDomainEventDeviceRemovedNew(dom->id, dom->name, dom->uuid, @@ -1596,7 +1604,7 @@ virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, */ static int virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, - virDomainEventPtr event) + virObjectEventPtr event) { if (!evtQueue) { return -1; @@ -1614,7 +1622,7 @@ virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, - virDomainEventPtr event, + virObjectEventPtr event, virConnectObjectEventGenericCallback cb, void *cbopaque, void *opaque); @@ -1622,7 +1630,7 @@ typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, static void virDomainEventDispatchDefaultFunc(virConnectPtr conn, - virDomainEventPtr event, + virObjectEventPtr event, virConnectDomainEventGenericCallback cb, void *cbopaque, void *opaque ATTRIBUTE_UNUSED) @@ -1804,7 +1812,7 @@ cleanup: } -static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, +static int virObjectEventDispatchMatchCallback(virObjectEventPtr event, virObjectEventCallbackPtr cb) { if (!cb) @@ -1832,7 +1840,7 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, static void -virDomainEventDispatch(virDomainEventPtr event, +virObjectEventDispatch(virObjectEventPtr event, virObjectEventCallbackListPtr callbacks, virObjectEventDispatchFunc dispatch, void *opaque) @@ -1844,7 +1852,7 @@ virDomainEventDispatch(virDomainEventPtr event, int cbCount = callbacks->count; for (i = 0; i < cbCount; i++) { - if (!virDomainEventDispatchMatchCallback(event, callbacks->callbacks[i])) + if (!virObjectEventDispatchMatchCallback(event, callbacks->callbacks[i])) continue; (*dispatch)(callbacks->callbacks[i]->conn, @@ -1865,7 +1873,7 @@ virObjectEventQueueDispatch(virObjectEventQueuePtr queue, size_t i; for (i = 0; i < queue->count; i++) { - virDomainEventDispatch(queue->events[i], callbacks, dispatch, opaque); + virObjectEventDispatch(queue->events[i], callbacks, dispatch, opaque); virObjectUnref(queue->events[i]); } VIR_FREE(queue->events); @@ -1874,7 +1882,7 @@ virObjectEventQueueDispatch(virObjectEventQueuePtr queue, void virObjectEventStateQueue(virObjectEventStatePtr state, - virDomainEventPtr event) + virObjectEventPtr event) { if (state->timer < 0) { virObjectUnref(event); @@ -1896,7 +1904,7 @@ virObjectEventStateQueue(virObjectEventStatePtr state, static void virObjectEventStateDispatchFunc(virConnectPtr conn, - virDomainEventPtr event, + virObjectEventPtr event, virConnectObjectEventGenericCallback cb, void *cbopaque, void *opaque) diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index bf701f9..647b7e4 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -38,110 +38,107 @@ typedef virObjectEventCallback *virObjectEventCallbackPtr; typedef struct _virObjectEvent virObjectEvent; typedef virObjectEvent *virObjectEventPtr; -typedef struct _virDomainEvent virDomainEvent; -typedef virDomainEvent *virDomainEventPtr; - typedef struct _virObjectEventState virObjectEventState; typedef virObjectEventState *virObjectEventStatePtr; -virDomainEventPtr virDomainEventLifecycleNew(int id, +virObjectEventPtr virDomainEventLifecycleNew(int id, const char *name, const unsigned char *uuid, int type, int detail); -virDomainEventPtr virDomainEventLifecycleNewFromDom(virDomainPtr dom, +virObjectEventPtr virDomainEventLifecycleNewFromDom(virDomainPtr dom, int type, int detail); -virDomainEventPtr virDomainEventLifecycleNewFromObj(virDomainObjPtr obj, +virObjectEventPtr virDomainEventLifecycleNewFromObj(virDomainObjPtr obj, int type, int detail); -virDomainEventPtr virDomainEventLifecycleNewFromDef(virDomainDefPtr def, +virObjectEventPtr virDomainEventLifecycleNewFromDef(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 virObjectEventStateFree(virObjectEventStatePtr state); @@ -163,7 +160,7 @@ typedef void (*virConnectObjectEventGenericCallback)(virConnectPtr conn, void virObjectEventStateQueue(virObjectEventStatePtr state, - virDomainEventPtr event) + virObjectEventPtr event) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); int virDomainEventStateRegister(virConnectPtr conn, virObjectEventStatePtr state, diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c index 9a598a9..692c3b7 100644 --- a/src/libxl/libxl_driver.c +++ b/src/libxl/libxl_driver.c @@ -100,7 +100,7 @@ libxlDomObjFromDomain(virDomainPtr dom) } static void -libxlDomainEventQueue(libxlDriverPrivatePtr driver, virDomainEventPtr event) +libxlDomainEventQueue(libxlDriverPrivatePtr driver, virObjectEventPtr event) { virObjectEventStateQueue(driver->domainEventState, event); } @@ -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; @@ -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; diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index 57d64b8..c499182 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; @@ -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); @@ -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); @@ -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; @@ -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; @@ -1481,7 +1481,7 @@ static void lxcNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque) virLXCDriverPtr driver = opaque; if (newVM) { - virDomainEventPtr event = + virObjectEventPtr event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, VIR_DOMAIN_EVENT_DEFINED_ADDED); @@ -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); @@ -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); diff --git a/src/lxc/lxc_process.c b/src/lxc/lxc_process.c index 9b5f3f2..131b5c1 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); @@ -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); @@ -1394,7 +1394,7 @@ virLXCProcessAutostartDomain(virDomainObjPtr vm, vm->def->name, err ? err->message : ""); } else { - virDomainEventPtr event = + virObjectEventPtr event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index a5fc8d6..e964c75 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -118,7 +118,7 @@ qemuDomainAsyncJobPhaseFromString(enum qemuDomainAsyncJob job, void qemuDomainEventQueue(virQEMUDriverPtr driver, - virDomainEventPtr event) + virObjectEventPtr event) { virObjectEventStateQueue(driver->domainEventState, event); } @@ -2117,7 +2117,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 b6be9a8..b1c4795 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -878,7 +878,7 @@ static void qemuNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque) virQEMUDriverPtr driver = opaque; if (newVM) { - virDomainEventPtr event = + virObjectEventPtr event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, VIR_DOMAIN_EVENT_DEFINED_ADDED); @@ -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; @@ -6058,7 +6058,7 @@ qemuDomainObjStart(virConnectPtr conn, VIR_NETDEV_VPORT_PROFILE_OP_CREATE, start_flags); virDomainAuditStart(vm, "booted", ret >= 0); if (ret >= 0) { - virDomainEventPtr event = + virObjectEventPtr event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); @@ -6133,7 +6133,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; @@ -6226,7 +6226,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; @@ -11663,7 +11663,7 @@ qemuDomainSnapshotCreateActiveInternal(virConnectPtr conn, { virDomainObjPtr vm = *vmptr; qemuDomainObjPrivatePtr priv = vm->privateData; - virDomainEventPtr event = NULL; + virObjectEventPtr event = NULL; bool resume = false; int ret = -1; @@ -12249,7 +12249,7 @@ qemuDomainSnapshotCreateActiveExternal(virConnectPtr conn, /* the snapshot is complete now */ if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) { - virDomainEventPtr event; + virObjectEventPtr event; event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT); @@ -12267,7 +12267,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); @@ -12284,7 +12284,7 @@ endjob: qemuProcessStartCPUs(driver, vm, conn, VIR_DOMAIN_RUNNING_UNPAUSED, QEMU_ASYNC_JOB_SNAPSHOT) < 0) { - virDomainEventPtr event = NULL; + virObjectEventPtr event = NULL; event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR); @@ -12944,8 +12944,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; @@ -13900,7 +13900,7 @@ cleanup: qemuProcessStartCPUs(driver, vm, conn, VIR_DOMAIN_RUNNING_UNPAUSED, QEMU_ASYNC_JOB_NONE) < 0) { - virDomainEventPtr event = NULL; + virObjectEventPtr event = NULL; event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR); @@ -13927,7 +13927,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 649c884..a4c8ebf 100644 --- a/src/qemu/qemu_hotplug.c +++ b/src/qemu/qemu_hotplug.c @@ -2427,7 +2427,7 @@ qemuDomainRemoveDiskDevice(virQEMUDriverPtr driver, virDomainDiskDefPtr disk) { virDomainDeviceDef dev; - virDomainEventPtr event; + virObjectEventPtr event; size_t i; VIR_DEBUG("Removing disk %s from domain %p %s", @@ -2471,7 +2471,7 @@ qemuDomainRemoveControllerDevice(virQEMUDriverPtr driver, virDomainObjPtr vm, virDomainControllerDefPtr controller) { - virDomainEventPtr event; + virObjectEventPtr event; size_t i; VIR_DEBUG("Removing controller %s from domain %p %s", @@ -2559,7 +2559,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", @@ -2630,7 +2630,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) { @@ -2695,7 +2695,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 221beea..9342062 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 = virDomainEventLifecycleNewFromObj(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; @@ -2702,7 +2702,7 @@ qemuMigrationConfirmPhase(virQEMUDriverPtr driver, int retcode) { qemuMigrationCookiePtr mig; - virDomainEventPtr event = NULL; + virObjectEventPtr event = NULL; int rv = -1; virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); @@ -4055,7 +4055,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; @@ -4169,7 +4169,7 @@ qemuMigrationPerformPhase(virQEMUDriverPtr driver, unsigned long flags, unsigned long resource) { - virDomainEventPtr event = NULL; + virObjectEventPtr event = NULL; int ret = -1; bool resume; bool hasrefs; @@ -4365,7 +4365,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 7904ee5..bbe9c68 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 9d1a7c5..4a84a52 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -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. */ @@ -4380,7 +4380,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) @@ -4402,7 +4402,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) @@ -4424,7 +4424,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) @@ -4446,7 +4446,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) @@ -4468,7 +4468,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) @@ -4493,7 +4493,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) @@ -4519,7 +4519,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) @@ -4542,7 +4542,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; @@ -4622,7 +4622,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) @@ -4645,7 +4645,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) @@ -4672,7 +4672,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) @@ -4696,7 +4696,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) @@ -4718,7 +4718,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) @@ -4741,7 +4741,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) @@ -4763,7 +4763,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) @@ -4786,7 +4786,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) @@ -6690,7 +6690,7 @@ done: } static void -remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event) +remoteDomainEventQueue(struct private_data *priv, virObjectEventPtr event) { virObjectEventStateQueue(priv->domainEventState, event); } diff --git a/src/test/test_driver.c b/src/test/test_driver.c index fdd1d3e..6d2a0e2 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -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) @@ -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; @@ -6029,7 +6029,7 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn, /* driver must be locked before calling */ static void testDomainEventQueue(testConnPtr driver, - virDomainEventPtr event) + virObjectEventPtr event) { virObjectEventStateQueue(driver->domainEventState, event); } @@ -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; diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c index 4c5bac5..1784eb5 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 = virDomainEventLifecycleNewFromObj(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) @@ -604,7 +604,7 @@ static void umlNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque) struct uml_driver *driver = opaque; if (newVM) { - virDomainEventPtr event = + virObjectEventPtr event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, VIR_DOMAIN_EVENT_DEFINED_ADDED); @@ -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); @@ -2691,7 +2691,7 @@ umlConnectDomainEventDeregisterAny(virConnectPtr conn, /* driver must be locked before calling */ static void umlDomainEventQueue(struct uml_driver *driver, - virDomainEventPtr event) + virObjectEventPtr event) { virObjectEventStateQueue(driver->domainEventState, event); } diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 6e930ee..3cb65cf 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -6954,7 +6954,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; @@ -7073,7 +7073,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 diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c index 82c1887..4103dc9 100644 --- a/src/xen/xen_driver.c +++ b/src/xen/xen_driver.c @@ -2946,7 +2946,7 @@ xenUnifiedRemoveDomainInfo(xenUnifiedDomainInfoListPtr list, * */ void xenUnifiedDomainEventDispatch(xenUnifiedPrivatePtr priv, - virDomainEventPtr event) + virObjectEventPtr event) { if (!priv) return; diff --git a/src/xen/xen_driver.h b/src/xen/xen_driver.h index a4b9149..b8c1c27 100644 --- a/src/xen/xen_driver.h +++ b/src/xen/xen_driver.h @@ -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 defbe44..2e9787f 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 c12e123..9be7591 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 = virDomainEventLifecycleNew(-1, priv->activeDomainList->doms[j]->name, priv->activeDomainList->doms[j]->uuid, -- 1.8.4.4

Each unique event ID will thus be composed by 1 byte for the namespace and 1 byte for a namespace-specific ID. The namespace for domain event needs to be 0 for compatibility reasons. --- src/conf/domain_event.c | 10 ++++++++-- src/conf/domain_event.h | 8 ++++++++ 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 3c14cec..8462754 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -1910,11 +1910,17 @@ virObjectEventStateDispatchFunc(virConnectPtr conn, void *opaque) { virObjectEventStatePtr state = opaque; + virEventNamespaceID namespace = (event->eventID & 0xFF00) >> 8; /* Drop the lock whle dispatching, for sake of re-entrancy */ virObjectEventStateUnlock(state); - virDomainEventDispatchDefaultFunc(conn, event, - VIR_DOMAIN_EVENT_CALLBACK(cb), cbopaque, NULL); + switch (namespace) + { + case VIR_EVENT_NAMESPACE_DOMAIN: + virDomainEventDispatchDefaultFunc(conn, event, + VIR_DOMAIN_EVENT_CALLBACK(cb), cbopaque, NULL); + break; + } virObjectEventStateLock(state); } diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 647b7e4..ec1b3d6 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -28,6 +28,14 @@ # include "domain_conf.h" + +/** 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; + typedef struct _virObjectEventCallback virObjectEventCallback; typedef virObjectEventCallback *virObjectEventCallbackPtr; -- 1.8.4.4

--- src/test/test_driver.c | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 6d2a0e2..4972e3d 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -121,7 +121,7 @@ static const virNodeInfo defaultNodeInfo = { static int testConnectClose(virConnectPtr conn); -static void testDomainEventQueue(testConnPtr driver, +static void testObjectEventQueue(testConnPtr driver, virObjectEventPtr event); @@ -1650,7 +1650,7 @@ cleanup: if (dom) virObjectUnlock(dom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); virDomainDefFree(def); testDriverUnlock(privconn); return ret; @@ -1781,7 +1781,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -1821,7 +1821,7 @@ cleanup: virObjectUnlock(privdom); if (event) { testDriverLock(privconn); - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); } return ret; @@ -1864,7 +1864,7 @@ cleanup: if (event) { testDriverLock(privconn); - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); } return ret; @@ -1911,7 +1911,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -1987,7 +1987,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2159,7 +2159,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2265,7 +2265,7 @@ cleanup: if (dom) virObjectUnlock(dom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2335,7 +2335,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2819,7 +2819,7 @@ cleanup: if (dom) virObjectUnlock(dom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2955,7 +2955,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -3030,7 +3030,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -6028,7 +6028,7 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn, /* driver must be locked before calling */ -static void testDomainEventQueue(testConnPtr driver, +static void testObjectEventQueue(testConnPtr driver, virObjectEventPtr event) { virObjectEventStateQueue(driver->domainEventState, event); @@ -6191,7 +6191,7 @@ cleanup: virObjectUnlock(vm); if (event) { testDriverLock(privconn); - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); } @@ -6743,7 +6743,7 @@ cleanup: } if (event) { testDriverLock(privconn); - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); } virDomainSnapshotDefFree(def); @@ -6989,7 +6989,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); goto load; } @@ -7069,7 +7069,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, bool paused = (flags & VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED) != 0; if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT); @@ -7085,9 +7085,9 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, ret = 0; cleanup: if (event) { - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); if (event2) - testDomainEventQueue(privconn, event2); + testObjectEventQueue(privconn, event2); } else { virObjectUnref(event2); } -- 1.8.4.4

--- src/test/test_driver.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 4972e3d..66afdf7 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -45,6 +45,7 @@ #include "interface_conf.h" #include "domain_conf.h" #include "domain_event.h" +#include "network_event.h" #include "snapshot_conf.h" #include "fdstream.h" #include "storage_conf.h" @@ -3529,6 +3530,7 @@ static virNetworkPtr testNetworkCreateXML(virConnectPtr conn, const char *xml) { virNetworkDefPtr def; virNetworkObjPtr net = NULL; virNetworkPtr ret = NULL; + virObjectEventPtr event = NULL; testDriverLock(privconn); if ((def = virNetworkDefParseString(xml)) == NULL) @@ -3539,10 +3541,15 @@ static virNetworkPtr testNetworkCreateXML(virConnectPtr conn, const char *xml) { def = NULL; net->active = 1; + event = virNetworkEventLifecycleNew(net->def->name, net->def->uuid, + VIR_NETWORK_EVENT_STARTED); + ret = virGetNetwork(conn, net->def->name, net->def->uuid); cleanup: virNetworkDefFree(def); + if (event) + testObjectEventQueue(privconn, event); if (net) virNetworkObjUnlock(net); testDriverUnlock(privconn); @@ -3556,6 +3563,7 @@ virNetworkPtr testNetworkDefineXML(virConnectPtr conn, const char *xml) virNetworkDefPtr def; virNetworkObjPtr net = NULL; virNetworkPtr ret = NULL; + virObjectEventPtr event = NULL; testDriverLock(privconn); if ((def = virNetworkDefParseString(xml)) == NULL) @@ -3566,10 +3574,15 @@ virNetworkPtr testNetworkDefineXML(virConnectPtr conn, const char *xml) def = NULL; net->persistent = 1; + event = virNetworkEventLifecycleNew(net->def->name, net->def->uuid, + VIR_NETWORK_EVENT_DEFINED); + ret = virGetNetwork(conn, net->def->name, net->def->uuid); cleanup: virNetworkDefFree(def); + if (event) + testObjectEventQueue(privconn, event); if (net) virNetworkObjUnlock(net); testDriverUnlock(privconn); @@ -3580,6 +3593,7 @@ static int testNetworkUndefine(virNetworkPtr network) { testConnPtr privconn = network->conn->privateData; virNetworkObjPtr privnet; int ret = -1; + virObjectEventPtr event = NULL; testDriverLock(privconn); privnet = virNetworkFindByName(&privconn->networks, @@ -3596,12 +3610,17 @@ static int testNetworkUndefine(virNetworkPtr network) { goto cleanup; } + event = virNetworkEventLifecycleNew(network->name, network->uuid, + VIR_NETWORK_EVENT_UNDEFINED); + virNetworkRemoveInactive(&privconn->networks, privnet); privnet = NULL; ret = 0; cleanup: + if (event) + testObjectEventQueue(privconn, event); if (privnet) virNetworkObjUnlock(privnet); testDriverUnlock(privconn); @@ -3660,6 +3679,7 @@ static int testNetworkCreate(virNetworkPtr network) { testConnPtr privconn = network->conn->privateData; virNetworkObjPtr privnet; int ret = -1; + virObjectEventPtr event = NULL; testDriverLock(privconn); privnet = virNetworkFindByName(&privconn->networks, @@ -3678,9 +3698,13 @@ static int testNetworkCreate(virNetworkPtr network) { } privnet->active = 1; + event = virNetworkEventLifecycleNew(privnet->def->name, privnet->def->uuid, + VIR_NETWORK_EVENT_STARTED); ret = 0; cleanup: + if (event) + testObjectEventQueue(privconn, event); if (privnet) virNetworkObjUnlock(privnet); return ret; @@ -3690,6 +3714,7 @@ static int testNetworkDestroy(virNetworkPtr network) { testConnPtr privconn = network->conn->privateData; virNetworkObjPtr privnet; int ret = -1; + virObjectEventPtr event = NULL; testDriverLock(privconn); privnet = virNetworkFindByName(&privconn->networks, @@ -3701,6 +3726,8 @@ static int testNetworkDestroy(virNetworkPtr network) { } privnet->active = 0; + event = virNetworkEventLifecycleNew(privnet->def->name, privnet->def->uuid, + VIR_NETWORK_EVENT_STOPPED); if (!privnet->persistent) { virNetworkRemoveInactive(&privconn->networks, privnet); @@ -3709,6 +3736,8 @@ static int testNetworkDestroy(virNetworkPtr network) { ret = 0; cleanup: + if (event) + testObjectEventQueue(privconn, event); if (privnet) virNetworkObjUnlock(privnet); testDriverUnlock(privconn); @@ -6027,6 +6056,37 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn, } +static int +testConnectNetworkEventRegisterAny(virConnectPtr conn, + virNetworkPtr net, + int eventID, + virConnectNetworkEventGenericCallback callback, + void *opaque, + virFreeCallback freecb) +{ + testConnPtr driver = conn->privateData; + int ret; + + testDriverLock(driver); + if (virNetworkEventStateRegisterID(conn, + driver->domainEventState, + net, eventID, + VIR_OBJECT_EVENT_CALLBACK(callback), + opaque, freecb, &ret) < 0) + ret = -1; + testDriverUnlock(driver); + + return ret; +} + +static int +testConnectNetworkEventDeregisterAny(virConnectPtr conn, + int callbackID) +{ + return testConnectDomainEventDeregisterAny(conn, callbackID); +} + + /* driver must be locked before calling */ static void testObjectEventQueue(testConnPtr driver, virObjectEventPtr event) @@ -7205,6 +7265,8 @@ static virNetworkDriver testNetworkDriver = { .connectNumOfDefinedNetworks = testConnectNumOfDefinedNetworks, /* 0.3.2 */ .connectListDefinedNetworks = testConnectListDefinedNetworks, /* 0.3.2 */ .connectListAllNetworks = testConnectListAllNetworks, /* 0.10.2 */ + .connectNetworkEventRegisterAny = testConnectNetworkEventRegisterAny, /* 1.2.1 */ + .connectNetworkEventDeregisterAny = testConnectNetworkEventDeregisterAny, /* 1.2.1 */ .networkLookupByUUID = testNetworkLookupByUUID, /* 0.3.2 */ .networkLookupByName = testNetworkLookupByName, /* 0.3.2 */ .networkCreateXML = testNetworkCreateXML, /* 0.3.2 */ -- 1.8.4.4

Renamed into remoteDispatchObjectEventSend as it will later be used for both the domain and network events. --- daemon/remote.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index decaecc..f060006 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -108,7 +108,7 @@ remoteSerializeDomainDiskErrors(virDomainDiskErrorPtr errors, /* Prototypes */ static void -remoteDispatchDomainEventSend(virNetServerClientPtr client, +remoteDispatchObjectEventSend(virNetServerClientPtr client, virNetServerProgramPtr program, int procnr, xdrproc_t proc, @@ -134,7 +134,7 @@ static int remoteRelayDomainEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED, data.event = event; data.detail = detail; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE, (xdrproc_t)xdr_remote_domain_event_lifecycle_msg, &data); @@ -157,7 +157,7 @@ static int remoteRelayDomainEventReboot(virConnectPtr conn ATTRIBUTE_UNUSED, memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_REBOOT, (xdrproc_t)xdr_remote_domain_event_reboot_msg, &data); @@ -183,7 +183,7 @@ static int remoteRelayDomainEventRTCChange(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); data.offset = offset; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE, (xdrproc_t)xdr_remote_domain_event_rtc_change_msg, &data); @@ -209,7 +209,7 @@ static int remoteRelayDomainEventWatchdog(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); data.action = action; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_WATCHDOG, (xdrproc_t)xdr_remote_domain_event_watchdog_msg, &data); @@ -240,7 +240,7 @@ static int remoteRelayDomainEventIOError(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); data.action = action; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_IO_ERROR, (xdrproc_t)xdr_remote_domain_event_io_error_msg, &data); @@ -279,7 +279,7 @@ static int remoteRelayDomainEventIOErrorReason(virConnectPtr conn ATTRIBUTE_UNUS make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON, (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg, &data); @@ -342,7 +342,7 @@ static int remoteRelayDomainEventGraphics(virConnectPtr conn ATTRIBUTE_UNUSED, } make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_GRAPHICS, (xdrproc_t)xdr_remote_domain_event_graphics_msg, &data); @@ -388,7 +388,7 @@ static int remoteRelayDomainEventBlockJob(virConnectPtr conn ATTRIBUTE_UNUSED, data.status = status; make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB, (xdrproc_t)xdr_remote_domain_event_block_job_msg, &data); @@ -415,7 +415,7 @@ static int remoteRelayDomainEventControlError(virConnectPtr conn ATTRIBUTE_UNUSE memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR, (xdrproc_t)xdr_remote_domain_event_control_error_msg, &data); @@ -461,7 +461,7 @@ static int remoteRelayDomainEventDiskChange(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE, (xdrproc_t)xdr_remote_domain_event_disk_change_msg, &data); @@ -497,7 +497,7 @@ static int remoteRelayDomainEventTrayChange(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE, (xdrproc_t)xdr_remote_domain_event_tray_change_msg, &data); @@ -520,7 +520,7 @@ static int remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED, memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP, (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg, &data); @@ -543,7 +543,7 @@ static int remoteRelayDomainEventPMSuspend(virConnectPtr conn ATTRIBUTE_UNUSED, memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND, (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg, &data); @@ -569,7 +569,7 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); data.actual = actual; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE, (xdrproc_t)xdr_remote_domain_event_balloon_change_msg, &data); @@ -593,7 +593,7 @@ static int remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn ATTRIBUTE_UNUS memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK, (xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg, &data); @@ -623,7 +623,7 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED, (xdrproc_t)xdr_remote_domain_event_device_removed_msg, &data); @@ -3158,7 +3158,7 @@ cleanup: } static void -remoteDispatchDomainEventSend(virNetServerClientPtr client, +remoteDispatchObjectEventSend(virNetServerClientPtr client, virNetServerProgramPtr program, int procnr, xdrproc_t proc, -- 1.8.4.4

--- daemon/libvirtd.h | 1 + daemon/remote.c | 140 +++++++++++++++++++++++++++++++++++++++++++ src/remote/remote_driver.c | 127 +++++++++++++++++++++++++++++++++++++++ src/remote/remote_protocol.x | 46 +++++++++++++- 4 files changed, 313 insertions(+), 1 deletion(-) diff --git a/daemon/libvirtd.h b/daemon/libvirtd.h index d0afdc8..47f2589 100644 --- a/daemon/libvirtd.h +++ b/daemon/libvirtd.h @@ -50,6 +50,7 @@ struct daemonClientPrivate { virMutex lock; int domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LAST]; + int networkEventCallbackID[VIR_NETWORK_EVENT_ID_LAST]; # if WITH_SASL virNetSASLSessionPtr sasl; diff --git a/daemon/remote.c b/daemon/remote.c index f060006..d14b0f3 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -49,6 +49,7 @@ #include "qemu_protocol.h" #include "lxc_protocol.h" #include "virstring.h" +#include "object_event.h" #define VIR_FROM_THIS VIR_FROM_RPC @@ -653,6 +654,37 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = { verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST); +static int remoteRelayNetworkEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED, + virNetworkPtr net, + int event, + void *opaque) +{ + virNetServerClientPtr client = opaque; + remote_network_event_lifecycle_msg data; + + if (!client) + return -1; + + VIR_DEBUG("Relaying network lifecycle event %d", event); + + /* build return data */ + memset(&data, 0, sizeof(data)); + make_nonnull_network(&data.net, net); + data.event = event; + + remoteDispatchObjectEventSend(client, remoteProgram, + REMOTE_PROC_NETWORK_EVENT_LIFECYCLE, + (xdrproc_t)xdr_remote_network_event_lifecycle_msg, &data); + + return 0; +} + +static virConnectNetworkEventGenericCallback networkEventCallbacks[] = { + VIR_NETWORK_EVENT_CALLBACK(remoteRelayNetworkEventLifecycle), +}; + +verify(ARRAY_CARDINALITY(networkEventCallbacks) == VIR_NETWORK_EVENT_ID_LAST); + /* * You must hold lock for at least the client * We don't free stuff here, merely disconnect the client's @@ -680,6 +712,15 @@ void remoteClientFreeFunc(void *data) priv->domainEventCallbackID[i] = -1; } + for (i = 0; i < VIR_NETWORK_EVENT_ID_LAST; i++) { + if (priv->networkEventCallbackID[i] != -1) { + VIR_DEBUG("Deregistering to relay remote events %zu", i); + virConnectNetworkEventDeregisterAny(priv->conn, + priv->networkEventCallbackID[i]); + } + priv->networkEventCallbackID[i] = -1; + } + virConnectClose(priv->conn); virIdentitySetCurrent(NULL); @@ -716,6 +757,9 @@ void *remoteClientInitHook(virNetServerClientPtr client, for (i = 0; i < VIR_DOMAIN_EVENT_ID_LAST; i++) priv->domainEventCallbackID[i] = -1; + for (i = 0; i < VIR_NETWORK_EVENT_ID_LAST; i++) + priv->networkEventCallbackID[i] = -1; + virNetServerClientSetCloseHook(client, remoteClientCloseFunc); return priv; } @@ -5216,6 +5260,102 @@ cleanup: } +static int +remoteDispatchConnectNetworkEventRegisterAny(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED, + remote_connect_network_event_register_any_args *args, + remote_connect_network_event_register_any_ret *ret ATTRIBUTE_UNUSED) +{ + int callbackID; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + virMutexLock(&priv->lock); + + if ((args->eventID & 0xFF) >= VIR_NETWORK_EVENT_ID_LAST || + ((args->eventID & 0xFF00) >> 8) != VIR_EVENT_NAMESPACE_NETWORK) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"), args->eventID); + goto cleanup; + } + + if (priv->networkEventCallbackID[args->eventID & 0xFF] != -1) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("network event %d already registered"), args->eventID); + goto cleanup; + } + + if ((callbackID = virConnectNetworkEventRegisterAny(priv->conn, + NULL, + args->eventID, + networkEventCallbacks[args->eventID & 0xFF], + client, NULL)) < 0) + goto cleanup; + + priv->networkEventCallbackID[args->eventID & 0xFF] = callbackID; + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + virMutexUnlock(&priv->lock); + return rv; +} + + +static int +remoteDispatchConnectNetworkEventDeregisterAny(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED, + remote_connect_network_event_deregister_any_args *args, + remote_connect_network_event_deregister_any_ret *ret ATTRIBUTE_UNUSED) +{ + int callbackID = -1; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + virMutexLock(&priv->lock); + + if ((args->eventID & 0xFF) >= VIR_NETWORK_EVENT_ID_LAST || + ((args->eventID & 0xFF00) >> 8) != VIR_EVENT_NAMESPACE_NETWORK) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"), args->eventID); + goto cleanup; + } + + callbackID = priv->networkEventCallbackID[args->eventID & 0xFF]; + if (callbackID < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("network event %d not registered"), args->eventID); + goto cleanup; + } + + if (virConnectNetworkEventDeregisterAny(priv->conn, callbackID) < 0) + goto cleanup; + + priv->networkEventCallbackID[args->eventID & 0xFF] = -1; + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + virMutexUnlock(&priv->lock); + return rv; +} + /*----- Helpers. -----*/ diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 4a84a52..046f424 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -33,6 +33,7 @@ #include "virlog.h" #include "datatypes.h" #include "domain_event.h" +#include "network_event.h" #include "driver.h" #include "virbuffer.h" #include "remote_driver.h" @@ -273,6 +274,11 @@ remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog, virNetClientPtr client, void *evdata, void *opaque); +static void +remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, + virNetClientPtr client ATTRIBUTE_UNUSED, + void *evdata, void *opaque); + static virNetClientProgramEvent remoteDomainEvents[] = { { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE, remoteDomainBuildEventRTCChange, @@ -338,6 +344,10 @@ static virNetClientProgramEvent remoteDomainEvents[] = { remoteDomainBuildEventDeviceRemoved, sizeof(remote_domain_event_device_removed_msg), (xdrproc_t)xdr_remote_domain_event_device_removed_msg }, + { REMOTE_PROC_NETWORK_EVENT_LIFECYCLE, + remoteNetworkBuildEventLifecycle, + sizeof(remote_network_event_lifecycle_msg), + (xdrproc_t)xdr_remote_network_event_lifecycle_msg }, }; enum virDrvOpenRemoteFlags { @@ -2902,6 +2912,99 @@ done: } static int +remoteConnectNetworkEventRegisterAny(virConnectPtr conn, + virNetworkPtr net, + int eventID, + virConnectNetworkEventGenericCallback callback, + void *opaque, + virFreeCallback freecb) +{ + int rv = -1; + struct private_data *priv = conn->privateData; + remote_connect_network_event_register_any_args args; + int callbackID; + int count; + + remoteDriverLock(priv); + + if ((count = virNetworkEventStateRegisterID(conn, + priv->domainEventState, + net, eventID, + VIR_OBJECT_EVENT_CALLBACK(callback), + opaque, freecb, + &callbackID)) < 0) { + virReportError(VIR_ERR_RPC, "%s", _("adding cb to list")); + goto done; + } + + /* If this is the first callback for this eventID, we need to enable + * events on the server */ + if (count == 1) { + args.eventID = eventID; + + if (call(conn, priv, 0, REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY, + (xdrproc_t) xdr_remote_connect_network_event_register_any_args, (char *) &args, + (xdrproc_t) xdr_void, (char *)NULL) == -1) { + virObjectEventStateDeregisterID(conn, + priv->domainEventState, + callbackID); + goto done; + } + } + + rv = callbackID; + +done: + remoteDriverUnlock(priv); + return rv; +} + + +static int +remoteConnectNetworkEventDeregisterAny(virConnectPtr conn, + int callbackID) +{ + struct private_data *priv = conn->privateData; + int rv = -1; + remote_connect_network_event_deregister_any_args args; + int eventID; + int count; + + remoteDriverLock(priv); + + if ((eventID = virObjectEventStateEventID(conn, + priv->domainEventState, + callbackID)) < 0) { + virReportError(VIR_ERR_RPC, _("unable to find callback ID %d"), callbackID); + goto done; + } + + if ((count = virObjectEventStateDeregisterID(conn, + priv->domainEventState, + callbackID)) < 0) { + virReportError(VIR_ERR_RPC, _("unable to find callback ID %d"), callbackID); + goto done; + } + + /* If that was the last callback for this eventID, we need to disable + * events on the server */ + if (count == 0) { + args.eventID = eventID; + + if (call(conn, priv, 0, REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY, + (xdrproc_t) xdr_remote_connect_network_event_deregister_any_args, (char *) &args, + (xdrproc_t) xdr_void, (char *) NULL) == -1) + goto done; + } + + rv = 0; + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int remoteConnectListAllInterfaces(virConnectPtr conn, virInterfacePtr **ifaces, unsigned int flags) @@ -4800,6 +4903,28 @@ remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog ATTRIBUTE_UNUSED } +static void +remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, + virNetClientPtr client ATTRIBUTE_UNUSED, + void *evdata, void *opaque) +{ + virConnectPtr conn = opaque; + struct private_data *priv = conn->privateData; + remote_network_event_lifecycle_msg *msg = evdata; + virNetworkPtr net; + virObjectEventPtr event = NULL; + + net = get_nonnull_network(conn, msg->net); + if (!net) + return; + + event = virNetworkEventLifecycleNew(net->name, net->uuid, msg->event); + virNetworkFree(net); + + remoteDomainEventQueue(priv, event); +} + + static virDrvOpenStatus ATTRIBUTE_NONNULL(1) remoteSecretOpen(virConnectPtr conn, virConnectAuthPtr auth, unsigned int flags) @@ -7035,6 +7160,8 @@ static virNetworkDriver network_driver = { .connectNumOfDefinedNetworks = remoteConnectNumOfDefinedNetworks, /* 0.3.0 */ .connectListDefinedNetworks = remoteConnectListDefinedNetworks, /* 0.3.0 */ .connectListAllNetworks = remoteConnectListAllNetworks, /* 0.10.2 */ + .connectNetworkEventDeregisterAny = remoteConnectNetworkEventDeregisterAny, /* 1.2.1 */ + .connectNetworkEventRegisterAny = remoteConnectNetworkEventRegisterAny, /* 1.2.1 */ .networkLookupByUUID = remoteNetworkLookupByUUID, /* 0.3.0 */ .networkLookupByName = remoteNetworkLookupByName, /* 0.3.0 */ .networkCreateXML = remoteNetworkCreateXML, /* 0.3.0 */ diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index f942670..c3d544f 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2849,6 +2849,30 @@ struct remote_connect_get_cpu_model_names_ret { int ret; }; +struct remote_connect_network_event_register_any_args { + int eventID; +}; + +struct remote_connect_network_event_register_any_ret { + int cb_registered; +}; + +struct remote_connect_network_event_deregister_any_args { + int eventID; +}; + +struct remote_connect_network_event_deregister_any_ret { + int cb_registered; +}; + +struct remote_network_event_lifecycle_msg { + remote_nonnull_network net; + int event; + int detail; +}; + + + /*----- Protocol. -----*/ /* Define the program number, protocol version and procedure numbers here. */ @@ -5018,5 +5042,25 @@ enum remote_procedure { * @generate: none * @acl: connect:read */ - REMOTE_PROC_CONNECT_GET_CPU_MODEL_NAMES = 312 + REMOTE_PROC_CONNECT_GET_CPU_MODEL_NAMES = 312, + + /** + * @generate: none + * @priority: high + * @acl: connect:read + */ + REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY = 313, + + /** + * @generate: none + * @priority: high + * @acl: connect:read + */ + REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY = 314, + + /** + * @generate: both + * @acl: none + */ + REMOTE_PROC_NETWORK_EVENT_LIFECYCLE = 315 }; -- 1.8.4.4