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(a)suse.com&gt; + */ + +#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

On 12/02/2013 09:39 AM, Cédric Bosdonnat wrote: More things to look for in a followup patch that adjusts indentation, and a question. Indentation: { belongs on the same line as switch. Indentation - most code aligns the 'case' to be flush with 'switch' rather than 4 spaces in. Indentation: this is typically written: virDomainEventDispatchDefaultFunc(conn, event, VIR_DOMAIN_EVENT_CALLBACK(cb), cbopaque, NULL); This switch statement falls through with no action on unknown namespaces. Are event ids always internal, such that hitting the default case implies programmer error? If so, should we add a default: label that does a VIR_ERROR to warn us in the logs of our mistake? -- Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org

On Mon, Dec 02, 2013 at 05:39:44PM +0100, Cédric Bosdonnat wrote: For the domain events, we have an 'int detail' argument too. I can't help thinking we should allow for the same with network lifecycle events, even if we don't have more than one detail reason to start with. It has been quite helpful for domain lifecycle events. No need to have the ifdef - the sentinels are guaranteed to exist for libvirt internal code The internal driver.h entry points should take the same data as the public API. So we don't want to add in VIR_EVENT_NAMESPACE_NETWORK values here. Doing this means that the VIR_EVENT_NAMESPACE_NETWORK value becomes visible on the RPC protocol wire, which forces us into maintaining these values forever more. We really want to avoid that, so we can change the way we deal with this if we need to in the future. We should only translate to add VIR_EVENT_NAMESPACE_NETWORK in the actual hypervisor drivers Daniel -- |: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|

--- 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

On Tue, Dec 10, 2013 at 01:22:30PM +0000, Daniel P. Berrange wrote: On second thoughts, virNetworkEventStateRegisterID itself should add the VIR_EVENT_NAMESPACE_NETWORK value, not the callers. Daniel -- |: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|

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

On Tue, Dec 10, 2013 at 01:27:52PM +0000, Daniel P. Berrange wrote: Opps, should not add it here either - this is calling public API so should have the raw eventID from the public header. Or actually just have virNetworkEventStateRegisterID do it instead of the callers Daniel -- |: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|