These unit tests are aiming at providing some help during the domain events refactoring. --- .gitignore | 1 + tests/Makefile.am | 7 ++ tests/objecteventtest.c | 242 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 250 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..53ab642 --- /dev/null +++ b/tests/objecteventtest.c @@ -0,0 +1,242 @@ +/* + * 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 (virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.startEvents != 1) { + ret = -1; + goto cleanup; + } + +cleanup: + virConnectDomainEventDeregisterAny(test->conn, id); + 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 (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); + 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"); + + 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.2

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

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

--- src/conf/domain_event.c | 46 +++++++++++++++++++++++----------------------- src/conf/domain_event.h | 4 ++-- 2 files changed, 25 insertions(+), 25 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 3bfe1e0..a4af23a 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -46,7 +46,7 @@ struct _virDomainEventCallbackList { virObjectEventCallbackPtr *callbacks; }; -struct _virDomainEventQueue { +struct _virObjectEventQueue { unsigned int count; virDomainEventPtr *events; }; @@ -54,8 +54,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 +531,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 +551,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 +600,7 @@ virDomainEventStateFree(virDomainEventStatePtr state) return; virDomainEventCallbackListFree(state->callbacks); - virDomainEventQueueFree(state->queue); + virObjectEventQueueFree(state->queue); if (state->timer != -1) virEventRemoveTimeout(state->timer); @@ -641,7 +641,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 +1203,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 +1418,7 @@ virDomainEventDispatch(virDomainEventPtr event, static void -virDomainEventQueueDispatch(virDomainEventQueuePtr queue, +virObjectEventQueueDispatch(virObjectEventQueuePtr queue, virDomainEventCallbackListPtr callbacks, virDomainEventDispatchFunc dispatch, void *opaque) @@ -1444,7 +1444,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 +1474,7 @@ virDomainEventStateDispatchFunc(virConnectPtr conn, static void virDomainEventStateFlush(virDomainEventStatePtr state) { - virDomainEventQueue tempQueue; + virObjectEventQueue tempQueue; virDomainEventStateLock(state); state->isDispatching = true; @@ -1487,7 +1487,7 @@ virDomainEventStateFlush(virDomainEventStatePtr state) state->queue->events = NULL; virEventUpdateTimeout(state->timer, -1); - virDomainEventQueueDispatch(&tempQueue, + virObjectEventQueueDispatch(&tempQueue, state->callbacks, virDomainEventStateDispatchFunc, state); @@ -1637,7 +1637,7 @@ virDomainEventStateDeregister(virConnectPtr conn, state->timer != -1) { virEventRemoveTimeout(state->timer); state->timer = -1; - virDomainEventQueueClear(state->queue); + virObjectEventQueueClear(state->queue); } virDomainEventStateUnlock(state); @@ -1675,7 +1675,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..2fe7731 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 _virDomainEventQueue virDomainEventQueue; -typedef virDomainEventQueue *virDomainEventQueuePtr; +typedef struct _virObjectEventQueue virObjectEventQueue; +typedef virObjectEventQueue *virObjectEventQueuePtr; typedef struct _virDomainEventState virDomainEventState; typedef virDomainEventState *virDomainEventStatePtr; -- 1.8.4.2

but left 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 a4af23a..b29da12 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -51,7 +51,7 @@ struct _virObjectEventQueue { virDomainEventPtr *events; }; -struct _virDomainEventState { +struct _virObjectEventState { /* The list of domain event callbacks */ virDomainEventCallbackListPtr callbacks; /* The queue of object events */ @@ -576,25 +576,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; @@ -610,23 +610,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; @@ -649,7 +649,7 @@ virDomainEventStateNew(void) return state; error: - virDomainEventStateFree(state); + virObjectEventStateFree(state); return NULL; } @@ -1434,7 +1434,7 @@ virObjectEventQueueDispatch(virObjectEventQueuePtr queue, } void -virDomainEventStateQueue(virDomainEventStatePtr state, +virObjectEventStateQueue(virObjectEventStatePtr state, virDomainEventPtr event) { if (state->timer < 0) { @@ -1442,7 +1442,7 @@ virDomainEventStateQueue(virDomainEventStatePtr state, return; } - virDomainEventStateLock(state); + virObjectEventStateLock(state); if (virObjectEventQueuePush(state->queue, event) < 0) { VIR_DEBUG("Error adding event to queue"); @@ -1451,32 +1451,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 @@ -1489,21 +1489,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 @@ -1515,14 +1515,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) && @@ -1546,7 +1546,7 @@ virDomainEventStateRegister(virConnectPtr conn, } cleanup: - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); return ret; } @@ -1554,7 +1554,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 @@ -1568,7 +1568,7 @@ cleanup: */ int virDomainEventStateRegisterID(virConnectPtr conn, - virDomainEventStatePtr state, + virObjectEventStatePtr state, virDomainPtr dom, int eventID, virConnectDomainEventGenericCallback cb, @@ -1578,7 +1578,7 @@ virDomainEventStateRegisterID(virConnectPtr conn, { int ret = -1; - virDomainEventStateLock(state); + virObjectEventStateLock(state); if ((state->callbacks->count == 0) && (state->timer == -1) && @@ -1603,7 +1603,7 @@ virDomainEventStateRegisterID(virConnectPtr conn, } cleanup: - virDomainEventStateUnlock(state); + virObjectEventStateUnlock(state); return ret; } @@ -1611,7 +1611,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, @@ -1621,12 +1621,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); @@ -1640,15 +1640,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, @@ -1657,13 +1657,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); @@ -1678,15 +1678,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 @@ -1695,15 +1695,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 2fe7731..c08f770 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -44,8 +44,8 @@ typedef virDomainEvent *virDomainEventPtr; typedef struct _virObjectEventQueue virObjectEventQueue; typedef virObjectEventQueue *virObjectEventQueuePtr; -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); @@ -139,22 +139,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, @@ -164,17 +164,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.2

But kept the legacy Domain lifecycle event functions as is. --- src/conf/domain_event.c | 87 ++++++++++++++++++++++++++----------------------- src/conf/domain_event.h | 4 +-- 2 files changed, 48 insertions(+), 43 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index b29da12..00e20c2 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -40,7 +40,7 @@ struct _virObjectMeta { typedef struct _virObjectMeta virObjectMeta; typedef virObjectMeta *virObjectMetaPtr; -struct _virDomainEventCallbackList { +struct _virObjectEventCallbackList { unsigned int nextID; unsigned int count; virObjectEventCallbackPtr *callbacks; @@ -53,7 +53,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 */ @@ -129,13 +129,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) @@ -158,11 +158,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; @@ -204,16 +204,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; @@ -255,7 +255,7 @@ virDomainEventCallbackListRemoveID(virConnectPtr conn, static int virDomainEventCallbackListMarkDelete(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, + virObjectEventCallbackListPtr cbList, virConnectDomainEventCallback callback) { int ret = 0; @@ -280,8 +280,8 @@ virDomainEventCallbackListMarkDelete(virConnectPtr conn, static int -virDomainEventCallbackListMarkDeleteID(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, +virObjectEventCallbackListMarkDeleteID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, int callbackID) { int ret = 0; @@ -305,7 +305,7 @@ virDomainEventCallbackListMarkDeleteID(virConnectPtr conn, static int -virDomainEventCallbackListPurgeMarked(virDomainEventCallbackListPtr cbList) +virObjectEventCallbackListPurgeMarked(virObjectEventCallbackListPtr cbList) { int old_count = cbList->count; int n; @@ -335,20 +335,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, @@ -369,10 +374,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; @@ -387,13 +392,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 */ @@ -437,16 +442,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); @@ -455,8 +460,8 @@ virDomainEventCallbackListAdd(virConnectPtr conn, static int -virDomainEventCallbackListEventID(virConnectPtr conn, - virDomainEventCallbackListPtr cbList, +virObjectEventCallbackListEventID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, int callbackID) { size_t i; @@ -599,7 +604,7 @@ virObjectEventStateFree(virObjectEventStatePtr state) if (!state) return; - virDomainEventCallbackListFree(state->callbacks); + virObjectEventCallbackListFree(state->callbacks); virObjectEventQueueFree(state->queue); if (state->timer != -1) @@ -1394,7 +1399,7 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, static void virDomainEventDispatch(virDomainEventPtr event, - virDomainEventCallbackListPtr callbacks, + virObjectEventCallbackListPtr callbacks, virDomainEventDispatchFunc dispatch, void *opaque) { @@ -1419,7 +1424,7 @@ virDomainEventDispatch(virDomainEventPtr event, static void virObjectEventQueueDispatch(virObjectEventQueuePtr queue, - virDomainEventCallbackListPtr callbacks, + virObjectEventCallbackListPtr callbacks, virDomainEventDispatchFunc dispatch, void *opaque) { @@ -1493,7 +1498,7 @@ virObjectEventStateFlush(virObjectEventStatePtr state) state); /* Purge any deleted callbacks */ - virDomainEventCallbackListPurgeMarked(state->callbacks); + virObjectEventCallbackListPurgeMarked(state->callbacks); state->isDispatching = false; virObjectEventStateUnlock(state); @@ -1591,9 +1596,9 @@ virDomainEventStateRegisterID(virConnectPtr conn, goto cleanup; } - ret = virDomainEventCallbackListAddID(conn, state->callbacks, - dom, eventID, cb, opaque, freecb, - callbackID); + ret = virObjectEventCallbackListAddID(conn, state->callbacks, dom->uuid, + dom->name, dom->id, eventID, cb, + opaque, freecb, callbackID); if (ret == -1 && state->callbacks->count == 0 && @@ -1665,10 +1670,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 && @@ -1702,7 +1707,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 c08f770..65a17ad 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -31,8 +31,8 @@ typedef struct _virObjectEventCallback virObjectEventCallback; typedef virObjectEventCallback *virObjectEventCallbackPtr; -typedef struct _virDomainEventCallbackList virDomainEventCallbackList; -typedef virDomainEventCallbackList *virDomainEventCallbackListPtr; +typedef struct _virObjectEventCallbackList virObjectEventCallbackList; +typedef virObjectEventCallbackList *virObjectEventCallbackListPtr; /** * Dispatching domain events that come in while -- 1.8.4.2

but kept virDomainEventStateRegisterID as a convenience wrapper around this new function. --- src/conf/domain_event.c | 125 +++++++++++++++++++++++++++++++---------------- src/conf/domain_event.h | 25 ++++++++++ src/libvirt_private.syms | 1 + 3 files changed, 110 insertions(+), 41 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 00e20c2..fa5c190 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; @@ -68,7 +70,7 @@ struct _virObjectEventCallback { int eventID; virConnectPtr conn; virObjectMetaPtr meta; - virConnectDomainEventGenericCallback cb; + virConnectObjectEventGenericCallback cb; void *opaque; virFreeCallback freecb; int deleted; @@ -168,7 +170,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; @@ -261,7 +263,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; @@ -355,7 +357,7 @@ virObjectEventCallbackListAddID(virConnectPtr conn, const char *name, int id, int eventID, - virConnectDomainEventGenericCallback callback, + virConnectObjectEventGenericCallback callback, void *opaque, virFreeCallback freecb, int *callbackID) @@ -371,7 +373,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 && @@ -453,7 +455,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); } @@ -1235,9 +1237,9 @@ virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, } -typedef void (*virDomainEventDispatchFunc)(virConnectPtr conn, +typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, virDomainEventPtr event, - virConnectDomainEventGenericCallback cb, + virConnectObjectEventGenericCallback cb, void *cbopaque, void *opaque); @@ -1400,7 +1402,7 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, static void virDomainEventDispatch(virDomainEventPtr event, virObjectEventCallbackListPtr callbacks, - virDomainEventDispatchFunc dispatch, + virObjectEventDispatchFunc dispatch, void *opaque) { size_t i; @@ -1425,7 +1427,7 @@ virDomainEventDispatch(virDomainEventPtr event, static void virObjectEventQueueDispatch(virObjectEventQueuePtr queue, virObjectEventCallbackListPtr callbacks, - virDomainEventDispatchFunc dispatch, + virObjectEventDispatchFunc dispatch, void *opaque) { size_t i; @@ -1463,7 +1465,7 @@ virObjectEventStateQueue(virObjectEventStatePtr state, static void virObjectEventStateDispatchFunc(virConnectPtr conn, virDomainEventPtr event, - virConnectDomainEventGenericCallback cb, + virConnectObjectEventGenericCallback cb, void *cbopaque, void *opaque) { @@ -1471,7 +1473,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); } @@ -1506,6 +1509,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[VIR_UUID_BUFLEN], + const char *name, + int id, + int eventID, + virConnectObjectEventGenericCallback cb, + void *opaque, + virFreeCallback freecb, + int *callbackID) +{ + int ret = -1; + + virObjectEventStateLock(state); + + if ((state->callbacks->count == 0) && + (state->timer == -1) && + (state->timer = virEventAddTimeout(-1, + 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 @@ -1581,35 +1643,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; - } - - 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 65a17ad..937b113 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -143,6 +143,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) @@ -168,6 +181,18 @@ virDomainEventStateDeregister(virConnectPtr conn, virConnectDomainEventCallback callback) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3); int +virObjectEventStateRegisterID(virConnectPtr conn, + virObjectEventStatePtr state, + unsigned char uuid[VIR_UUID_BUFLEN], + const char *name, + int id, + int eventID, + virConnectObjectEventGenericCallback cb, + void *opaque, + virFreeCallback freecb, + int *callbackID) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(7); +int virObjectEventStateDeregisterID(virConnectPtr conn, virObjectEventStatePtr state, int callbackID) 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.2

Added a parent class virObjectEvent for future event types --- cfg.mk | 2 - src/conf/domain_event.c | 620 +++++++++++++++++++++++++++++++---------------- src/conf/domain_event.h | 5 +- src/libvirt_private.syms | 1 - src/qemu/qemu_driver.c | 2 +- src/test/test_driver.c | 4 +- 6 files changed, 414 insertions(+), 220 deletions(-) diff --git a/cfg.mk b/cfg.mk index c256164..198e084 100644 --- a/cfg.mk +++ b/cfg.mk @@ -125,7 +125,6 @@ useless_free_options = \ --name=virDomainDeviceDefFree \ --name=virDomainDiskDefFree \ --name=virDomainEventCallbackListFree \ - --name=virDomainEventFree \ --name=virObjectEventQueueFree \ --name=virObjectEventStateFree \ --name=virDomainFSDefFree \ @@ -205,7 +204,6 @@ useless_free_options = \ # y virDomainDeviceDefFree # y virDomainDiskDefFree # y virDomainEventCallbackListFree -# y virDomainEventFree # y virDomainEventQueueFree # y virDomainFSDefFree # n virDomainFree diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index fa5c190..ff4f69a 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -76,8 +76,18 @@ struct _virObjectEventCallback { int deleted; }; -struct _virDomainEvent { +static virClassPtr virObjectEventClass; +static virClassPtr virDomainEventClass; +static void virObjectEventDispose(void *obj); +static void virDomainEventDispose(void *obj); + +struct _virObjectEvent { + virObject parent; int eventID; +}; + +struct _virDomainEvent { + virObjectEvent parent; virObjectMeta meta; @@ -130,6 +140,101 @@ struct _virDomainEvent { } data; }; +static int virObjectEventOnceInit(void) +{ + if (!(virObjectEventClass = virClassNew(virClassForObject(), + "virObjectEvent", + sizeof(virObjectEvent), + virObjectEventDispose))) + return -1; + if (!(virDomainEventClass = virClassNew(virObjectEventClass, + "virDomainEvent", + sizeof(virDomainEvent), + virDomainEventDispose))) + return -1; + return 0; +} + +VIR_ONCE_GLOBAL_INIT(virObjectEvent) + +static int virObjectEventGetEventID(void *anyobj) +{ + virObjectEventPtr obj = anyobj; + + if (!virObjectIsClass(obj, virObjectEventClass)) { + VIR_WARN("Object %p (%s) is not a virObjectEvent instance", + obj, obj ? virClassName(obj->parent.klass) : "(unknown)"); + return -1; + } + return obj->eventID; +} + +static void virObjectEventDispose(void *obj) +{ + virObjectEventPtr event = obj; + + VIR_DEBUG("obj=%p", event); +} + +static void virDomainEventDispose(void *obj) +{ + virDomainEventPtr event = obj; + + VIR_DEBUG("obj=%p", event); + + if (!event) + return; + + 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) { + VIR_FREE(event->data.graphics.local->node); + VIR_FREE(event->data.graphics.local->service); + VIR_FREE(event->data.graphics.local); + } + if (event->data.graphics.remote) { + VIR_FREE(event->data.graphics.remote->node); + VIR_FREE(event->data.graphics.remote->service); + VIR_FREE(event->data.graphics.remote); + } + VIR_FREE(event->data.graphics.authScheme); + if (event->data.graphics.subject) { + size_t i; + for (i = 0; i < event->data.graphics.subject->nidentity; i++) { + VIR_FREE(event->data.graphics.subject->identities[i].type); + VIR_FREE(event->data.graphics.subject->identities[i].name); + } + VIR_FREE(event->data.graphics.subject); + } + break; + + case VIR_DOMAIN_EVENT_ID_BLOCK_JOB: + VIR_FREE(event->data.blockJob.path); + break; + + case VIR_DOMAIN_EVENT_ID_DISK_CHANGE: + VIR_FREE(event->data.diskChange.oldSrcPath); + VIR_FREE(event->data.diskChange.newSrcPath); + VIR_FREE(event->data.diskChange.devAlias); + break; + case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE: + VIR_FREE(event->data.trayChange.devAlias); + break; + case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED: + VIR_FREE(event->data.deviceRemoved.devAlias); + break; + } + + VIR_FREE(event->meta.name); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -481,62 +586,6 @@ virObjectEventCallbackListEventID(virConnectPtr conn, } -void virDomainEventFree(virDomainEventPtr event) -{ - if (!event) - return; - - switch (event->eventID) { - case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON: - case VIR_DOMAIN_EVENT_ID_IO_ERROR: - VIR_FREE(event->data.ioError.srcPath); - VIR_FREE(event->data.ioError.devAlias); - VIR_FREE(event->data.ioError.reason); - break; - - case VIR_DOMAIN_EVENT_ID_GRAPHICS: - if (event->data.graphics.local) { - VIR_FREE(event->data.graphics.local->node); - VIR_FREE(event->data.graphics.local->service); - VIR_FREE(event->data.graphics.local); - } - if (event->data.graphics.remote) { - VIR_FREE(event->data.graphics.remote->node); - VIR_FREE(event->data.graphics.remote->service); - VIR_FREE(event->data.graphics.remote); - } - VIR_FREE(event->data.graphics.authScheme); - if (event->data.graphics.subject) { - size_t i; - for (i = 0; i < event->data.graphics.subject->nidentity; i++) { - VIR_FREE(event->data.graphics.subject->identities[i].type); - VIR_FREE(event->data.graphics.subject->identities[i].name); - } - VIR_FREE(event->data.graphics.subject); - } - break; - - case VIR_DOMAIN_EVENT_ID_BLOCK_JOB: - VIR_FREE(event->data.blockJob.path); - break; - - case VIR_DOMAIN_EVENT_ID_DISK_CHANGE: - VIR_FREE(event->data.diskChange.oldSrcPath); - VIR_FREE(event->data.diskChange.newSrcPath); - VIR_FREE(event->data.diskChange.devAlias); - break; - case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE: - VIR_FREE(event->data.trayChange.devAlias); - break; - case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED: - VIR_FREE(event->data.deviceRemoved.devAlias); - break; - } - - VIR_FREE(event->meta.name); - VIR_FREE(event); -} - /** * virObjectEventQueueClear: * @queue: pointer to the queue @@ -551,7 +600,7 @@ virObjectEventQueueClear(virObjectEventQueuePtr queue) return; for (i = 0; i < queue->count; i++) { - virDomainEventFree(queue->events[i]); + virObjectUnref(queue->events[i]); } VIR_FREE(queue->events); queue->count = 0; @@ -660,17 +709,51 @@ error: return NULL; } -static virDomainEventPtr virDomainEventNewInternal(int eventID, - int id, - const char *name, - const unsigned char *uuid) +static void *virObjectEventNew(virClassPtr klass, + int eventID) { - virDomainEventPtr event; + virObjectEventPtr event; - if (VIR_ALLOC(event) < 0) + if (virObjectEventInitialize() < 0) + return NULL; + + if (!virClassIsDerivedFrom(klass, virObjectEventClass)) { + virReportInvalidArg(klass, + _("Class %s must derive from virObjectEvent"), + virClassName(klass)); + return NULL; + } + + if (!(event = virObjectNew(klass))) return NULL; event->eventID = eventID; + + VIR_DEBUG("obj=%p", event); + return event; +} + +static void *virDomainEventNewInternal(virClassPtr klass, + int eventID, + int id, + const char *name, + const unsigned char *uuid) +{ + virDomainEventPtr event; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!virClassIsDerivedFrom(klass, virDomainEventClass)) { + virReportInvalidArg(klass, + _("Class %s must derive from virDomainEvent"), + virClassName(klass)); + return NULL; + } + + if (!(event = virObjectEventNew(klass, eventID))) + return NULL; + if (VIR_STRDUP(event->meta.name, name) < 0) { VIR_FREE(event); return NULL; @@ -685,13 +768,18 @@ virDomainEventPtr virDomainEventNew(int id, const char *name, const unsigned char *uuid, int type, int detail) { - virDomainEventPtr event = virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_LIFECYCLE, - id, name, uuid); + virDomainEventPtr event; - if (event) { - event->data.lifecycle.type = type; - event->data.lifecycle.detail = detail; - } + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(event = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_LIFECYCLE, + id, name, uuid))) + return NULL; + + event->data.lifecycle.type = type; + event->data.lifecycle.detail = detail; return event; } @@ -714,43 +802,66 @@ virDomainEventPtr virDomainEventNewFromDef(virDomainDefPtr def, int type, int de virDomainEventPtr virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid) { - return virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT, + if (virObjectEventInitialize() < 0) + return NULL; + + return virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_REBOOT, id, name, uuid); } virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom) { - return virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT, + if (virObjectEventInitialize() < 0) + return NULL; + + return virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_REBOOT, dom->id, dom->name, dom->uuid); } virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) { - return virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_REBOOT, + if (virObjectEventInitialize() < 0) + return NULL; + + return virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_REBOOT, obj->def->id, obj->def->name, obj->def->uuid); } virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_RTC_CHANGE, - dom->id, dom->name, dom->uuid); + virDomainEventPtr ev; - if (ev) - ev->data.rtcChange.offset = offset; + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_RTC_CHANGE, + dom->id, dom->name, dom->uuid))) + return NULL; + + ev->data.rtcChange.offset = offset; return ev; } virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_RTC_CHANGE, - obj->def->id, obj->def->name, obj->def->uuid); + virDomainEventPtr ev; - if (ev) - ev->data.rtcChange.offset = offset; + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_RTC_CHANGE, + obj->def->id, obj->def->name, + obj->def->uuid))) + return NULL; + + ev->data.rtcChange.offset = offset; return ev; } @@ -758,24 +869,35 @@ virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_WATCHDOG, - dom->id, dom->name, dom->uuid); + virDomainEventPtr ev; - if (ev) - ev->data.watchdog.action = action; + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_WATCHDOG, + dom->id, dom->name, dom->uuid))) + return NULL; + + ev->data.watchdog.action = action; return ev; } virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_WATCHDOG, - obj->def->id, obj->def->name, obj->def->uuid); + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_WATCHDOG, + obj->def->id, obj->def->name, + obj->def->uuid))) + return NULL; - if (ev) - ev->data.watchdog.action = action; + ev->data.watchdog.action = action; return ev; } @@ -787,18 +909,21 @@ static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event, int action, const char *reason) { - virDomainEventPtr ev = - virDomainEventNewInternal(event, - dom->id, dom->name, dom->uuid); - - if (ev) { - ev->data.ioError.action = action; - if (VIR_STRDUP(ev->data.ioError.srcPath, srcPath) < 0 || - VIR_STRDUP(ev->data.ioError.devAlias, devAlias) < 0 || - VIR_STRDUP(ev->data.ioError.reason, reason) < 0) { - virDomainEventFree(ev); - ev = NULL; - } + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, 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) { + virObjectUnref(ev); + ev = NULL; } return ev; @@ -811,18 +936,22 @@ static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event, int action, const char *reason) { - virDomainEventPtr ev = - virDomainEventNewInternal(event, - obj->def->id, obj->def->name, obj->def->uuid); - - if (ev) { - ev->data.ioError.action = action; - if (VIR_STRDUP(ev->data.ioError.srcPath, srcPath) < 0 || - VIR_STRDUP(ev->data.ioError.devAlias, devAlias) < 0 || - VIR_STRDUP(ev->data.ioError.reason, reason) < 0) { - virDomainEventFree(ev); - ev = NULL; - } + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, 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) { + virObjectUnref(ev); + ev = NULL; } return ev; @@ -878,20 +1007,24 @@ virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, const char *authScheme, virDomainEventGraphicsSubjectPtr subject) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_GRAPHICS, - dom->id, dom->name, dom->uuid); + virDomainEventPtr ev; - if (ev) { - ev->data.graphics.phase = phase; - if (VIR_STRDUP(ev->data.graphics.authScheme, authScheme) < 0) { - virDomainEventFree(ev); - return NULL; - } - ev->data.graphics.local = local; - ev->data.graphics.remote = remote; - ev->data.graphics.subject = subject; + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + 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) { + virObjectUnref(ev); + return NULL; } + ev->data.graphics.local = local; + ev->data.graphics.remote = remote; + ev->data.graphics.subject = subject; return ev; } @@ -903,20 +1036,25 @@ virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, const char *authScheme, virDomainEventGraphicsSubjectPtr subject) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_GRAPHICS, - obj->def->id, obj->def->name, obj->def->uuid); + virDomainEventPtr ev; - if (ev) { - ev->data.graphics.phase = phase; - if (VIR_STRDUP(ev->data.graphics.authScheme, authScheme) < 0) { - virDomainEventFree(ev); - return NULL; - } - ev->data.graphics.local = local; - ev->data.graphics.remote = remote; - ev->data.graphics.subject = subject; + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + 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) { + virObjectUnref(ev); + return NULL; } + ev->data.graphics.local = local; + ev->data.graphics.remote = remote; + ev->data.graphics.subject = subject; return ev; } @@ -925,18 +1063,22 @@ static virDomainEventPtr virDomainEventBlockJobNew(int id, const char *name, unsigned char *uuid, const char *path, int type, int status) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_BLOCK_JOB, - id, name, uuid); + virDomainEventPtr ev; - if (ev) { - if (VIR_STRDUP(ev->data.blockJob.path, path) < 0) { - virDomainEventFree(ev); - return NULL; - } - ev->data.blockJob.type = type; - ev->data.blockJob.status = status; + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_BLOCK_JOB, + id, name, uuid))) + return NULL; + + if (VIR_STRDUP(ev->data.blockJob.path, path) < 0) { + virObjectUnref(ev); + return NULL; } + ev->data.blockJob.type = type; + ev->data.blockJob.status = status; return ev; } @@ -961,18 +1103,31 @@ virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom, virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, - dom->id, dom->name, dom->uuid); + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, + dom->id, dom->name, dom->uuid))) + return NULL; return ev; } virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, - obj->def->id, obj->def->name, obj->def->uuid); + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, + obj->def->id, obj->def->name, + obj->def->uuid))) + return NULL; return ev; } @@ -983,27 +1138,31 @@ virDomainEventDiskChangeNew(int id, const char *name, const char *newSrcPath, const char *devAlias, int reason) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_DISK_CHANGE, - id, name, uuid); + virDomainEventPtr ev; - if (ev) { - if (VIR_STRDUP(ev->data.diskChange.devAlias, devAlias) < 0) - goto error; + if (virObjectEventInitialize() < 0) + return NULL; - if (VIR_STRDUP(ev->data.diskChange.oldSrcPath, oldSrcPath) < 0) - goto error; + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_DISK_CHANGE, + id, name, uuid))) + return NULL; - if (VIR_STRDUP(ev->data.diskChange.newSrcPath, newSrcPath) < 0) - goto error; + if (VIR_STRDUP(ev->data.diskChange.devAlias, devAlias) < 0) + goto error; - ev->data.diskChange.reason = reason; - } + if (VIR_STRDUP(ev->data.diskChange.oldSrcPath, oldSrcPath) < 0) + goto error; + + if (VIR_STRDUP(ev->data.diskChange.newSrcPath, newSrcPath) < 0) + goto error; + + ev->data.diskChange.reason = reason; return ev; error: - virDomainEventFree(ev); + virObjectUnref(ev); return NULL; } @@ -1035,21 +1194,25 @@ virDomainEventTrayChangeNew(int id, const char *name, const char *devAlias, int reason) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, - id, name, uuid); + virDomainEventPtr ev; - if (ev) { - if (VIR_STRDUP(ev->data.trayChange.devAlias, devAlias) < 0) - goto error; + if (virObjectEventInitialize() < 0) + return NULL; - ev->data.trayChange.reason = reason; - } + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, + id, name, uuid))) + return NULL; + + if (VIR_STRDUP(ev->data.trayChange.devAlias, devAlias) < 0) + goto error; + + ev->data.trayChange.reason = reason; return ev; error: - virDomainEventFree(ev); + virObjectUnref(ev); return NULL; } @@ -1076,9 +1239,15 @@ static virDomainEventPtr virDomainEventPMWakeupNew(int id, const char *name, unsigned char *uuid) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_PMWAKEUP, - id, name, uuid); + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_PMWAKEUP, + id, name, uuid))) + return NULL; return ev; } @@ -1101,9 +1270,15 @@ static virDomainEventPtr virDomainEventPMSuspendNew(int id, const char *name, unsigned char *uuid) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_PMSUSPEND, - id, name, uuid); + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_PMSUSPEND, + id, name, uuid))) + return NULL; return ev; } @@ -1126,9 +1301,15 @@ static virDomainEventPtr virDomainEventPMSuspendDiskNew(int id, const char *name, unsigned char *uuid) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK, - id, name, uuid); + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK, + id, name, uuid))) + return NULL; return ev; } @@ -1149,24 +1330,34 @@ virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom) virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, - dom->id, dom->name, dom->uuid); + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, + dom->id, dom->name, dom->uuid))) + return NULL; - if (ev) - ev->data.balloonChange.actual = actual; + ev->data.balloonChange.actual = actual; return ev; } virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, - obj->def->id, obj->def->name, obj->def->uuid); + virDomainEventPtr ev; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, + obj->def->id, obj->def->name, obj->def->uuid))) + return NULL; - if (ev) - ev->data.balloonChange.actual = actual; + ev->data.balloonChange.actual = actual; return ev; } @@ -1177,19 +1368,23 @@ virDomainEventDeviceRemovedNew(int id, unsigned char *uuid, const char *devAlias) { - virDomainEventPtr ev = - virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED, - id, name, uuid); + virDomainEventPtr ev; - if (ev) { - if (VIR_STRDUP(ev->data.deviceRemoved.devAlias, devAlias) < 0) - goto error; - } + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNewInternal(virDomainEventClass, + VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED, + id, name, uuid))) + return NULL; + + if (VIR_STRDUP(ev->data.deviceRemoved.devAlias, devAlias) < 0) + goto error; return ev; error: - virDomainEventFree(ev); + virObjectUnref(ev); return NULL; } @@ -1252,11 +1447,12 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, void *opaque ATTRIBUTE_UNUSED) { virDomainPtr dom = virGetDomain(conn, event->meta.name, event->meta.uuid); + int eventID = virObjectEventGetEventID(event); if (!dom) return; dom->id = event->meta.id; - switch ((virDomainEventID) event->eventID) { + switch ((virDomainEventID) eventID) { case VIR_DOMAIN_EVENT_ID_LIFECYCLE: ((virConnectDomainEventCallback)cb)(conn, dom, event->data.lifecycle.type, @@ -1365,7 +1561,7 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, break; } - VIR_WARN("Unexpected event ID %d", event->eventID); + VIR_WARN("Unexpected event ID %d", eventID); cleanup: virDomainFree(dom); @@ -1379,7 +1575,7 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, return 0; if (cb->deleted) return 0; - if (cb->eventID != event->eventID) + if (cb->eventID != virObjectEventGetEventID(event)) return 0; if (cb->meta) { @@ -1434,7 +1630,7 @@ virObjectEventQueueDispatch(virObjectEventQueuePtr queue, for (i = 0; i < queue->count; i++) { virDomainEventDispatch(queue->events[i], callbacks, dispatch, opaque); - virDomainEventFree(queue->events[i]); + virObjectUnref(queue->events[i]); } VIR_FREE(queue->events); queue->count = 0; @@ -1445,7 +1641,7 @@ virObjectEventStateQueue(virObjectEventStatePtr state, virDomainEventPtr event) { if (state->timer < 0) { - virDomainEventFree(event); + virObjectUnref(event); return; } @@ -1453,7 +1649,7 @@ virObjectEventStateQueue(virObjectEventStatePtr state, if (virObjectEventQueuePush(state->queue, event) < 0) { VIR_DEBUG("Error adding event to queue"); - virDomainEventFree(event); + virObjectUnref(event); } if (state->queue->count == 1) diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 937b113..8b9409a 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -38,6 +38,9 @@ typedef virObjectEventCallbackList *virObjectEventCallbackListPtr; * Dispatching domain events that come in while * in a call / response rpc */ +typedef struct _virObjectEvent virObjectEvent; +typedef virObjectEvent *virObjectEventPtr; + typedef struct _virDomainEvent virDomainEvent; typedef virDomainEvent *virDomainEventPtr; @@ -137,8 +140,6 @@ virDomainEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, const char *devAlias); -void virDomainEventFree(virDomainEventPtr event); - void virObjectEventStateFree(virObjectEventStatePtr state); virObjectEventStatePtr virObjectEventStateNew(void); diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index a14e290..a7bbc79 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -421,7 +421,6 @@ virDomainEventDeviceRemovedNewFromDom; virDomainEventDeviceRemovedNewFromObj; virDomainEventDiskChangeNewFromDom; virDomainEventDiskChangeNewFromObj; -virDomainEventFree; virDomainEventGraphicsNewFromDom; virDomainEventGraphicsNewFromObj; virDomainEventIOErrorNewFromDom; diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 8183643..ab6004d 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -13166,7 +13166,7 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, QEMU_ASYNC_JOB_NONE); if (rc < 0) goto endjob; - virDomainEventFree(event); + virObjectUnref(event); event = NULL; if (was_stopped) { /* Transition 2 */ diff --git a/src/test/test_driver.c b/src/test/test_driver.c index ba24f69..04de78b 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -7035,7 +7035,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, } /* else transition 6 and 9 use event as-is */ } else { /* Transitions 2, 5, 8 */ - virDomainEventFree(event); + virObjectUnref(event); event = NULL; if (was_stopped) { @@ -7089,7 +7089,7 @@ cleanup: if (event2) testDomainEventQueue(privconn, event2); } else { - virDomainEventFree(event2); + virObjectUnref(event2); } virObjectUnlock(vm); testDriverUnlock(privconn); -- 1.8.4.2

--- src/conf/domain_event.c | 65 ++++++++++++++++++++++++++++++++++--------------- src/conf/domain_event.h | 8 +++--- 2 files changed, 50 insertions(+), 23 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index ff4f69a..a69ce11 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -76,10 +76,14 @@ struct _virObjectEventCallback { int deleted; }; + + static virClassPtr virObjectEventClass; static virClassPtr virDomainEventClass; +static virClassPtr virDomainEventLifecycleClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); +static void virDomainEventLifecycleDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -93,10 +97,6 @@ struct _virDomainEvent { union { struct { - int type; - int detail; - } lifecycle; - struct { long long offset; } rtcChange; struct { @@ -140,6 +140,16 @@ struct _virDomainEvent { } data; }; +struct _virDomainEventLifecycle { + virDomainEvent parent; + + int type; + int detail; +}; +typedef struct _virDomainEventLifecycle virDomainEventLifecycle; +typedef virDomainEventLifecycle *virDomainEventLifecyclePtr; + + static int virObjectEventOnceInit(void) { if (!(virObjectEventClass = virClassNew(virClassForObject(), @@ -152,6 +162,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEvent), virDomainEventDispose))) return -1; + if (!(virDomainEventLifecycleClass = virClassNew( + virDomainEventClass, + "virDomainEventLifecycle", + sizeof(virDomainEventLifecycle), + virDomainEventLifecycleDispose))) + return -1; return 0; } @@ -235,6 +251,12 @@ static void virDomainEventDispose(void *obj) VIR_FREE(event->meta.name); } +static void virDomainEventLifecycleDispose(void *obj) +{ + virDomainEventLifecyclePtr event = obj; + VIR_DEBUG("obj=%p", event); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -764,37 +786,37 @@ static void *virDomainEventNewInternal(virClassPtr klass, return event; } -virDomainEventPtr virDomainEventNew(int id, const char *name, +void *virDomainEventNew(int id, const char *name, const unsigned char *uuid, int type, int detail) { - virDomainEventPtr event; + virDomainEventLifecyclePtr event; if (virObjectEventInitialize() < 0) return NULL; - if (!(event = virDomainEventNewInternal(virDomainEventClass, - VIR_DOMAIN_EVENT_ID_LIFECYCLE, - id, name, uuid))) + if (!(event = virDomainEventNewInternal(virDomainEventLifecycleClass, + VIR_DOMAIN_EVENT_ID_LIFECYCLE, + id, name, uuid))) return NULL; - event->data.lifecycle.type = type; - event->data.lifecycle.detail = detail; + event->type = type; + event->detail = detail; return event; } -virDomainEventPtr virDomainEventNewFromDom(virDomainPtr dom, int type, int detail) +void *virDomainEventNewFromDom(virDomainPtr dom, int type, int detail) { return virDomainEventNew(dom->id, dom->name, dom->uuid, type, detail); } -virDomainEventPtr virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail) +void *virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail) { return virDomainEventNewFromDef(obj->def, type, detail); } -virDomainEventPtr virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail) +void *virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail) { return virDomainEventNew(def->id, def->name, def->uuid, type, detail); } @@ -1454,11 +1476,16 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, switch ((virDomainEventID) eventID) { case VIR_DOMAIN_EVENT_ID_LIFECYCLE: - ((virConnectDomainEventCallback)cb)(conn, dom, - event->data.lifecycle.type, - event->data.lifecycle.detail, - cbopaque); - goto cleanup; + { + virDomainEventLifecyclePtr lifecycleEvent; + + lifecycleEvent = (virDomainEventLifecyclePtr)event; + ((virConnectDomainEventCallback)cb)(conn, dom, + lifecycleEvent->type, + lifecycleEvent->detail, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_REBOOT: (cb)(conn, dom, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 8b9409a..04b846e 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -50,10 +50,10 @@ typedef virObjectEventQueue *virObjectEventQueuePtr; 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); -virDomainEventPtr virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail); -virDomainEventPtr virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail); +void *virDomainEventNew(int id, const char *name, const unsigned char *uuid, int type, int detail); +void *virDomainEventNewFromDom(virDomainPtr dom, int type, int detail); +void *virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail); +void *virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail); virDomainEventPtr virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid); virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom); -- 1.8.4.2

On Fri, 2013-11-29 at 17:09 +0000, Daniel P. Berrange wrote: OK, I just won't change that in this commit (and the other similar ones) as it would break builds. I'll change that later when changing from virDomainEventPtr to virObjectPtr. -- Cedric

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 | 156 ++++++++++++++++++++++++------------------------ 1 file changed, 78 insertions(+), 78 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 1c5dcd3..07c8100 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -755,11 +755,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; @@ -795,9 +795,9 @@ void *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; @@ -829,9 +829,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) @@ -839,9 +839,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) @@ -849,9 +849,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, @@ -862,9 +862,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; @@ -879,10 +879,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; @@ -898,9 +898,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; @@ -915,10 +915,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; @@ -938,8 +938,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; @@ -965,9 +965,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; @@ -1036,9 +1036,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; @@ -1065,10 +1065,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; @@ -1092,9 +1092,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) { @@ -1132,9 +1132,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; } @@ -1147,10 +1147,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; } @@ -1167,9 +1167,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) @@ -1223,9 +1223,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) @@ -1268,9 +1268,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; @@ -1299,9 +1299,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; @@ -1330,9 +1330,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; } @@ -1359,9 +1359,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; @@ -1376,9 +1376,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; @@ -1397,9 +1397,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) @@ -1480,7 +1480,7 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, case VIR_DOMAIN_EVENT_ID_LIFECYCLE: { virDomainEventLifecyclePtr lifecycleEvent; - + lifecycleEvent = (virDomainEventLifecyclePtr)event; ((virConnectDomainEventCallback)cb)(conn, dom, lifecycleEvent->type, -- 1.8.4.2

On Fri, Nov 29, 2013 at 04:18:48PM +0100, Cédric Bosdonnat wrote: Same point about returning virObjectEventPtr here as with earlier patch. I won't repeat it for the remainder of this series - just update them all to match. 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/conf/domain_event.c | 161 ++++++++++++++++++++++++++++-------------------- src/conf/domain_event.h | 36 +++++------ 2 files changed, 112 insertions(+), 85 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 8d08d2f..21494e5 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -83,11 +83,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; @@ -101,12 +103,6 @@ struct _virDomainEvent { union { struct { - char *srcPath; - char *devAlias; - int action; - char *reason; - } ioError; - struct { int phase; virDomainEventGraphicsAddressPtr local; virDomainEventGraphicsAddressPtr remote; @@ -163,6 +159,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(), @@ -193,6 +200,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventWatchdog), virDomainEventWatchdogDispose))) return -1; + if (!(virDomainEventIOErrorClass = virClassNew( + virDomainEventClass, + "virDomainEventIOError", + sizeof(virDomainEventIOError), + virDomainEventIOErrorDispose))) + return -1; return 0; } @@ -227,12 +240,6 @@ static void virDomainEventDispose(void *obj) return; 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) { @@ -294,6 +301,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 @@ -961,26 +978,26 @@ void *virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action) return ev; } -static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event, - virDomainPtr dom, - const char *srcPath, - const char *devAlias, - int action, - const char *reason) +static void *virDomainEventIOErrorNewFromDomImpl(int event, + virDomainPtr dom, + const char *srcPath, + const char *devAlias, + 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; } @@ -988,27 +1005,27 @@ static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event, return ev; } -static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event, - virDomainObjPtr obj, - const char *srcPath, - const char *devAlias, - int action, - const char *reason) +static void *virDomainEventIOErrorNewFromObjImpl(int event, + virDomainObjPtr obj, + const char *srcPath, + const char *devAlias, + 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; } @@ -1016,42 +1033,42 @@ static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event, return ev; } -virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom, - const char *srcPath, - const char *devAlias, - int action) +void *virDomainEventIOErrorNewFromDom(virDomainPtr dom, + const char *srcPath, + const char *devAlias, + int action) { return virDomainEventIOErrorNewFromDomImpl(VIR_DOMAIN_EVENT_ID_IO_ERROR, dom, srcPath, devAlias, action, NULL); } -virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj, - const char *srcPath, - const char *devAlias, - int action) +void *virDomainEventIOErrorNewFromObj(virDomainObjPtr obj, + const char *srcPath, + const char *devAlias, + int action) { return virDomainEventIOErrorNewFromObjImpl(VIR_DOMAIN_EVENT_ID_IO_ERROR, obj, srcPath, devAlias, action, NULL); } -virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom, - const char *srcPath, - const char *devAlias, - int action, - const char *reason) +void *virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom, + const char *srcPath, + const char *devAlias, + int action, + const char *reason) { return virDomainEventIOErrorNewFromDomImpl(VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON, dom, srcPath, devAlias, action, reason); } -virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, - const char *srcPath, - const char *devAlias, - int action, - const char *reason) +void *virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, + const char *srcPath, + const char *devAlias, + int action, + const char *reason) { return virDomainEventIOErrorNewFromObjImpl(VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON, obj, srcPath, devAlias, @@ -1552,21 +1569,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, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index b51ec97..45819dc 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -75,24 +75,24 @@ void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset); void *virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action); void *virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action); -virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom, - const char *srcPath, - const char *devAlias, - int action); -virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj, - const char *srcPath, - const char *devAlias, - int action); -virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom, - const char *srcPath, - const char *devAlias, - int action, - const char *reason); -virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, - const char *srcPath, - const char *devAlias, - int action, - const char *reason); +void *virDomainEventIOErrorNewFromDom(virDomainPtr dom, + const char *srcPath, + const char *devAlias, + int action); +void *virDomainEventIOErrorNewFromObj(virDomainObjPtr obj, + const char *srcPath, + const char *devAlias, + int action); +void *virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom, + const char *srcPath, + const char *devAlias, + int action, + const char *reason); +void *virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, + const char *srcPath, + const char *devAlias, + int action, + const char *reason); virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, int phase, -- 1.8.4.2

--- src/conf/domain_event.c | 84 +++++++++++++++++++++++++++++++------------------ src/conf/domain_event.h | 16 +++++----- 2 files changed, 61 insertions(+), 39 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index dea8729..5d56fe5 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -85,6 +85,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); @@ -92,6 +93,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; @@ -105,11 +107,6 @@ struct _virDomainEvent { union { struct { - char *path; - int type; - int status; - } blockJob; - struct { char *oldSrcPath; char *newSrcPath; char *devAlias; @@ -165,6 +162,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; @@ -219,6 +226,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventGraphics), virDomainEventGraphicsDispose))) return -1; + if (!(virDomainEventBlockJobClass = virClassNew( + virDomainEventClass, + "virDomainEventBlockJob", + sizeof(virDomainEventBlockJob), + virDomainEventBlockJobDispose))) + return -1; return 0; } @@ -254,10 +267,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); @@ -328,6 +337,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 @@ -1152,43 +1169,43 @@ void *virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, return ev; } -static virDomainEventPtr -virDomainEventBlockJobNew(int id, const char *name, unsigned char *uuid, - const char *path, int type, int status) +static +void * 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; } -virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, - const char *path, - int type, - int status) +void *virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, + 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) +void *virDomainEventBlockJobNewFromDom(virDomainPtr dom, + const char *path, + int type, + int status) { return virDomainEventBlockJobNew(dom->id, dom->name, dom->uuid, path, type, status); @@ -1633,12 +1650,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 c7b0347..1aa1455 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -109,14 +109,14 @@ void *virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom); virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj); -virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, - const char *path, - int type, - int status); -virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom, - const char *path, - int type, - int status); +void *virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, + const char *path, + int type, + int status); +void *virDomainEventBlockJobNewFromDom(virDomainPtr dom, + const char *path, + int type, + int status); virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj, const char *oldSrcPath, -- 1.8.4.2

--- src/conf/domain_event.c | 77 ++++++++++++++++++++++++++++++++----------------- src/conf/domain_event.h | 4 +-- 2 files changed, 52 insertions(+), 29 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 8497b9a..24291b9 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -87,6 +87,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); @@ -97,6 +98,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; @@ -110,10 +112,6 @@ struct _virDomainEvent { union { struct { - char *devAlias; - int reason; - } trayChange; - struct { /* In unit of 1024 bytes */ unsigned long long actual; } balloonChange; @@ -192,6 +190,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) { @@ -247,6 +254,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventDiskChange), virDomainEventDiskChangeDispose))) return -1; + if (!(virDomainEventTrayChangeClass = virClassNew( + virDomainEventClass, + "virDomainEventTrayChange", + sizeof(virDomainEventTrayChange), + virDomainEventTrayChangeDispose))) + return -1; return 0; } @@ -282,9 +295,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; @@ -365,6 +375,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 @@ -1318,26 +1336,26 @@ void *virDomainEventDiskChangeNewFromDom(virDomainPtr dom, devAlias, reason); } -static virDomainEventPtr -virDomainEventTrayChangeNew(int id, const char *name, - unsigned char *uuid, - const char *devAlias, - int reason) +static +void *virDomainEventTrayChangeNew(int id, const char *name, + unsigned char *uuid, + 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; @@ -1346,9 +1364,9 @@ error: return NULL; } -virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, - const char *devAlias, - int reason) +void *virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, + const char *devAlias, + int reason) { return virDomainEventTrayChangeNew(obj->def->id, obj->def->name, @@ -1357,9 +1375,9 @@ virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, reason); } -virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom, - const char *devAlias, - int reason) +void *virDomainEventTrayChangeNewFromDom(virDomainPtr dom, + const char *devAlias, + int reason) { return virDomainEventTrayChangeNew(dom->id, dom->name, dom->uuid, devAlias, reason); @@ -1697,11 +1715,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); diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 965af57..5a684eb 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -128,10 +128,10 @@ void *virDomainEventDiskChangeNewFromDom(virDomainPtr dom, const char *newSrcPath, const char *devAlias, int reason); -virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, +void *virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, const char *devAlias, int reason); -virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom, +void *virDomainEventTrayChangeNewFromDom(virDomainPtr dom, const char *devAlias, int reason); virDomainEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj); -- 1.8.4.2

RIP virDomainEvent union. All data are now stored in each virObjectEvent subclass. --- src/conf/domain_event.c | 75 +++++++++++++++++++++++++++++-------------------- src/conf/domain_event.h | 4 +-- 2 files changed, 46 insertions(+), 33 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index ac7828e..4bd81d9 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -89,6 +89,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); @@ -101,6 +102,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; @@ -111,12 +113,6 @@ struct _virDomainEvent { virObjectEvent parent; virObjectMeta meta; - - union { - struct { - char *devAlias; - } deviceRemoved; - } data; }; struct _virDomainEventLifecycle { @@ -206,6 +202,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) { @@ -273,6 +277,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventBalloonChange), virDomainEventBalloonChangeDispose))) return -1; + if (!(virDomainEventDeviceRemovedClass = virClassNew( + virDomainEventClass, + "virDomainEventDeviceRemoved", + sizeof(virDomainEventDeviceRemoved), + virDomainEventDeviceRemovedDispose))) + return -1; return 0; } @@ -306,13 +316,6 @@ static void virDomainEventDispose(void *obj) if (!event) return; - switch (virObjectEventGetEventID(event)) { - - case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED: - VIR_FREE(event->data.deviceRemoved.devAlias); - break; - } - VIR_FREE(event->meta.name); } @@ -402,6 +405,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 @@ -1529,23 +1540,22 @@ void *virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, return ev; } -static virDomainEventPtr -virDomainEventDeviceRemovedNew(int id, - const char *name, - unsigned char *uuid, - const char *devAlias) +static void *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; @@ -1555,17 +1565,15 @@ error: return NULL; } -virDomainEventPtr -virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, - const char *devAlias) +void *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) +void *virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, + const char *devAlias) { return virDomainEventDeviceRemovedNew(dom->id, dom->name, dom->uuid, devAlias); @@ -1769,10 +1777,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; diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index f4a344c..f13c716 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -145,9 +145,9 @@ void *virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long l virDomainEventPtr virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj); virDomainEventPtr virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom); -virDomainEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, +void *virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, const char *devAlias); -virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, +void *virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, const char *devAlias); void virObjectEventStateFree(virObjectEventStatePtr state); -- 1.8.4.2

The virDomainEvent class wasn't defining anything special, thus it has been dropped. --- src/conf/domain_event.c | 179 +++++++++++++++++---------------------------- src/conf/domain_event.h | 5 +- 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, 204 insertions(+), 250 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 7694fcc..d4ecc23 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -50,7 +50,7 @@ struct _virObjectEventCallbackList { struct _virObjectEventQueue { unsigned int count; - virDomainEventPtr *events; + virObjectEventPtr *events; }; struct _virObjectEventState { @@ -79,7 +79,6 @@ struct _virObjectEventCallback { static virClassPtr virObjectEventClass; -static virClassPtr virDomainEventClass; static virClassPtr virDomainEventLifecycleClass; static virClassPtr virDomainEventRTCChangeClass; static virClassPtr virDomainEventWatchdogClass; @@ -92,7 +91,6 @@ static virClassPtr virDomainEventBalloonChangeClass; static virClassPtr virDomainEventDeviceRemovedClass; 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); @@ -107,16 +105,11 @@ static void virDomainEventDeviceRemovedDispose(void *obj); struct _virObjectEvent { virObject parent; int eventID; -}; - -struct _virDomainEvent { - virObjectEvent parent; - virObjectMeta meta; }; struct _virDomainEventLifecycle { - virDomainEvent parent; + virObjectEvent parent; int type; int detail; @@ -125,7 +118,7 @@ typedef struct _virDomainEventLifecycle virDomainEventLifecycle; typedef virDomainEventLifecycle *virDomainEventLifecyclePtr; struct _virDomainEventRTCChange { - virDomainEvent parent; + virObjectEvent parent; long long offset; }; @@ -133,7 +126,7 @@ typedef struct _virDomainEventRTCChange virDomainEventRTCChange; typedef virDomainEventRTCChange *virDomainEventRTCChangePtr; struct _virDomainEventWatchdog { - virDomainEvent parent; + virObjectEvent parent; int action; }; @@ -141,7 +134,7 @@ typedef struct _virDomainEventWatchdog virDomainEventWatchdog; typedef virDomainEventWatchdog *virDomainEventWatchdogPtr; struct _virDomainEventIOError { - virDomainEvent parent; + virObjectEvent parent; char *srcPath; char *devAlias; @@ -152,7 +145,7 @@ typedef struct _virDomainEventIOError virDomainEventIOError; typedef virDomainEventIOError *virDomainEventIOErrorPtr; struct _virDomainEventBlockJob { - virDomainEvent parent; + virObjectEvent parent; char *path; int type; @@ -162,7 +155,7 @@ typedef struct _virDomainEventBlockJob virDomainEventBlockJob; typedef virDomainEventBlockJob *virDomainEventBlockJobPtr; struct _virDomainEventGraphics { - virDomainEvent parent; + virObjectEvent parent; int phase; virDomainEventGraphicsAddressPtr local; @@ -174,7 +167,7 @@ typedef struct _virDomainEventGraphics virDomainEventGraphics; typedef virDomainEventGraphics *virDomainEventGraphicsPtr; struct _virDomainEventDiskChange { - virDomainEvent parent; + virObjectEvent parent; char *oldSrcPath; char *newSrcPath; @@ -185,7 +178,7 @@ typedef struct _virDomainEventDiskChange virDomainEventDiskChange; typedef virDomainEventDiskChange *virDomainEventDiskChangePtr; struct _virDomainEventTrayChange { - virDomainEvent parent; + virObjectEvent parent; char *devAlias; int reason; @@ -194,7 +187,7 @@ typedef struct _virDomainEventTrayChange virDomainEventTrayChange; typedef virDomainEventTrayChange *virDomainEventTrayChangePtr; struct _virDomainEventBalloonChange { - virDomainEvent parent; + virObjectEvent parent; /* In unit of 1024 bytes */ unsigned long long actual; @@ -203,7 +196,7 @@ typedef struct _virDomainEventBalloonChange virDomainEventBalloonChange; typedef virDomainEventBalloonChange *virDomainEventBalloonChangePtr; struct _virDomainEventDeviceRemoved { - virDomainEvent parent; + virObjectEvent parent; char *devAlias; }; @@ -218,67 +211,62 @@ static int virObjectEventOnceInit(void) sizeof(virObjectEvent), virObjectEventDispose))) return -1; - if (!(virDomainEventClass = virClassNew(virObjectEventClass, - "virDomainEvent", - sizeof(virDomainEvent), - virDomainEventDispose))) - return -1; if (!(virDomainEventLifecycleClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventLifecycle", sizeof(virDomainEventLifecycle), virDomainEventLifecycleDispose))) return -1; if (!(virDomainEventRTCChangeClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventRTCChange", sizeof(virDomainEventRTCChange), virDomainEventRTCChangeDispose))) return -1; if (!(virDomainEventWatchdogClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventWatchdog", sizeof(virDomainEventWatchdog), virDomainEventWatchdogDispose))) return -1; if (!(virDomainEventIOErrorClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventIOError", sizeof(virDomainEventIOError), virDomainEventIOErrorDispose))) return -1; if (!(virDomainEventGraphicsClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventGraphics", sizeof(virDomainEventGraphics), virDomainEventGraphicsDispose))) return -1; if (!(virDomainEventBlockJobClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventBlockJob", sizeof(virDomainEventBlockJob), virDomainEventBlockJobDispose))) return -1; if (!(virDomainEventDiskChangeClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventDiskChange", sizeof(virDomainEventDiskChange), virDomainEventDiskChangeDispose))) return -1; if (!(virDomainEventTrayChangeClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventTrayChange", sizeof(virDomainEventTrayChange), virDomainEventTrayChangeDispose))) return -1; if (!(virDomainEventBalloonChangeClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventBalloonChange", sizeof(virDomainEventBalloonChange), virDomainEventBalloonChangeDispose))) return -1; if (!(virDomainEventDeviceRemovedClass = virClassNew( - virDomainEventClass, + virObjectEventClass, "virDomainEventDeviceRemoved", sizeof(virDomainEventDeviceRemoved), virDomainEventDeviceRemovedDispose))) @@ -305,16 +293,6 @@ static void virObjectEventDispose(void *obj) virObjectEventPtr event = obj; VIR_DEBUG("obj=%p", event); -} - -static void virDomainEventDispose(void *obj) -{ - virDomainEventPtr event = obj; - - VIR_DEBUG("obj=%p", event); - - if (!event) - return; VIR_FREE(event->meta.name); } @@ -888,7 +866,10 @@ error: } static void *virObjectEventNew(virClassPtr klass, - int eventID) + int eventID, + int id, + const char *name, + const unsigned char *uuid) { virObjectEventPtr event; @@ -907,31 +888,6 @@ static void *virObjectEventNew(virClassPtr klass, event->eventID = eventID; - VIR_DEBUG("obj=%p", event); - return event; -} - -static void *virDomainEventNew(virClassPtr klass, - int eventID, - int id, - const char *name, - const unsigned char *uuid) -{ - virDomainEventPtr event; - - if (virObjectEventInitialize() < 0) - return NULL; - - if (!virClassIsDerivedFrom(klass, virDomainEventClass)) { - virReportInvalidArg(klass, - _("Class %s must derive from virDomainEvent"), - virClassName(klass)); - return NULL; - } - - if (!(event = virObjectEventNew(klass, eventID))) - return NULL; - if (VIR_STRDUP(event->meta.name, name) < 0) { VIR_FREE(event); return NULL; @@ -939,19 +895,20 @@ static void *virDomainEventNew(virClassPtr klass, event->meta.id = id; memcpy(event->meta.uuid, uuid, VIR_UUID_BUFLEN); + VIR_DEBUG("obj=%p", event); return event; } void *virDomainEventLifecycleNew(int id, const char *name, - const unsigned char *uuid, - int type, int detail) + const unsigned char *uuid, + int type, int detail) { virDomainEventLifecyclePtr event; if (virObjectEventInitialize() < 0) return NULL; - if (!(event = virDomainEventNew(virDomainEventLifecycleClass, + if (!(event = virObjectEventNew(virDomainEventLifecycleClass, VIR_DOMAIN_EVENT_ID_LIFECYCLE, id, name, uuid))) return NULL; @@ -980,12 +937,12 @@ void *virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detai } void *virDomainEventRebootNew(int id, const char *name, - const unsigned char *uuid) + const unsigned char *uuid) { if (virObjectEventInitialize() < 0) return NULL; - return virDomainEventNew(virDomainEventClass, + return virObjectEventNew(virObjectEventClass, VIR_DOMAIN_EVENT_ID_REBOOT, id, name, uuid); } @@ -995,7 +952,7 @@ void *virDomainEventRebootNewFromDom(virDomainPtr dom) if (virObjectEventInitialize() < 0) return NULL; - return virDomainEventNew(virDomainEventClass, + return virObjectEventNew(virObjectEventClass, VIR_DOMAIN_EVENT_ID_REBOOT, dom->id, dom->name, dom->uuid); } @@ -1005,20 +962,20 @@ void *virDomainEventRebootNewFromObj(virDomainObjPtr obj) if (virObjectEventInitialize() < 0) return NULL; - return virDomainEventNew(virDomainEventClass, + return virObjectEventNew(virObjectEventClass, VIR_DOMAIN_EVENT_ID_REBOOT, obj->def->id, obj->def->name, obj->def->uuid); } void *virDomainEventRTCChangeNewFromDom(virDomainPtr dom, - long long offset) + long long offset) { virDomainEventRTCChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventRTCChangeClass, + if (!(ev = virObjectEventNew(virDomainEventRTCChangeClass, VIR_DOMAIN_EVENT_ID_RTC_CHANGE, dom->id, dom->name, dom->uuid))) return NULL; @@ -1028,14 +985,14 @@ void *virDomainEventRTCChangeNewFromDom(virDomainPtr dom, return ev; } void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, - long long offset) + long long offset) { virDomainEventRTCChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventRTCChangeClass, + if (!(ev = virObjectEventNew(virDomainEventRTCChangeClass, VIR_DOMAIN_EVENT_ID_RTC_CHANGE, obj->def->id, obj->def->name, obj->def->uuid))) @@ -1053,7 +1010,7 @@ void *virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action) if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventWatchdogClass, + if (!(ev = virObjectEventNew(virDomainEventWatchdogClass, VIR_DOMAIN_EVENT_ID_WATCHDOG, dom->id, dom->name, dom->uuid))) return NULL; @@ -1069,7 +1026,7 @@ void *virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action) if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventWatchdogClass, + if (!(ev = virObjectEventNew(virDomainEventWatchdogClass, VIR_DOMAIN_EVENT_ID_WATCHDOG, obj->def->id, obj->def->name, obj->def->uuid))) @@ -1092,7 +1049,7 @@ static void *virDomainEventIOErrorNewFromDomImpl(int event, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventIOErrorClass, event, + if (!(ev = virObjectEventNew(virDomainEventIOErrorClass, event, dom->id, dom->name, dom->uuid))) return NULL; @@ -1119,7 +1076,7 @@ static void *virDomainEventIOErrorNewFromObjImpl(int event, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventIOErrorClass, event, + if (!(ev = virObjectEventNew(virDomainEventIOErrorClass, event, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; @@ -1190,7 +1147,7 @@ void *virDomainEventGraphicsNewFromDom(virDomainPtr dom, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventGraphicsClass, + if (!(ev = virObjectEventNew(virDomainEventGraphicsClass, VIR_DOMAIN_EVENT_ID_GRAPHICS, dom->id, dom->name, dom->uuid))) return NULL; @@ -1219,7 +1176,7 @@ void *virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventGraphicsClass, + if (!(ev = virObjectEventNew(virDomainEventGraphicsClass, VIR_DOMAIN_EVENT_ID_GRAPHICS, obj->def->id, obj->def->name, obj->def->uuid))) @@ -1246,7 +1203,7 @@ void * virDomainEventBlockJobNew(int id, const char *name, unsigned char *uuid, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventBlockJobClass, + if (!(ev = virObjectEventNew(virDomainEventBlockJobClass, VIR_DOMAIN_EVENT_ID_BLOCK_JOB, id, name, uuid))) return NULL; @@ -1281,12 +1238,12 @@ void *virDomainEventBlockJobNewFromDom(virDomainPtr dom, void *virDomainEventControlErrorNewFromDom(virDomainPtr dom) { - virDomainEventPtr ev; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virObjectEventNew(virObjectEventClass, VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, dom->id, dom->name, dom->uuid))) return NULL; @@ -1296,12 +1253,12 @@ void *virDomainEventControlErrorNewFromDom(virDomainPtr dom) void *virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) { - virDomainEventPtr ev; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virObjectEventNew(virObjectEventClass, VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, obj->def->id, obj->def->name, obj->def->uuid))) @@ -1321,7 +1278,7 @@ void *virDomainEventDiskChangeNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventDiskChangeClass, + if (!(ev = virObjectEventNew(virDomainEventDiskChangeClass, VIR_DOMAIN_EVENT_ID_DISK_CHANGE, id, name, uuid))) return NULL; @@ -1377,7 +1334,7 @@ void *virDomainEventTrayChangeNew(int id, const char *name, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventTrayChangeClass, + if (!(ev = virObjectEventNew(virDomainEventTrayChangeClass, VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, id, name, uuid))) return NULL; @@ -1416,12 +1373,12 @@ void *virDomainEventTrayChangeNewFromDom(virDomainPtr dom, static void *virDomainEventPMWakeupNew(int id, const char *name, unsigned char *uuid) { - virDomainEventPtr ev; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virObjectEventNew(virObjectEventClass, VIR_DOMAIN_EVENT_ID_PMWAKEUP, id, name, uuid))) return NULL; @@ -1444,12 +1401,12 @@ void *virDomainEventPMWakeupNewFromDom(virDomainPtr dom) static void *virDomainEventPMSuspendNew(int id, const char *name, unsigned char *uuid) { - virDomainEventPtr ev; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virObjectEventNew(virObjectEventClass, VIR_DOMAIN_EVENT_ID_PMSUSPEND, id, name, uuid))) return NULL; @@ -1472,12 +1429,12 @@ void *virDomainEventPMSuspendNewFromDom(virDomainPtr dom) static void *virDomainEventPMSuspendDiskNew(int id, const char *name, unsigned char *uuid) { - virDomainEventPtr ev; + virObjectEventPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virObjectEventNew(virObjectEventClass, VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK, id, name, uuid))) return NULL; @@ -1504,7 +1461,7 @@ void *virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventBalloonChangeClass, + if (!(ev = virObjectEventNew(virDomainEventBalloonChangeClass, VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, dom->id, dom->name, dom->uuid))) return NULL; @@ -1521,7 +1478,7 @@ void *virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventBalloonChangeClass, + if (!(ev = virObjectEventNew(virDomainEventBalloonChangeClass, VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; @@ -1541,7 +1498,7 @@ static void *virDomainEventDeviceRemovedNew(int id, if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventDeviceRemovedClass, + if (!(ev = virObjectEventNew(virDomainEventDeviceRemovedClass, VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED, id, name, uuid))) return NULL; @@ -1581,7 +1538,7 @@ void *virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, */ static int virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, - virDomainEventPtr event) + virObjectEventPtr event) { if (!evtQueue) { return -1; @@ -1599,7 +1556,7 @@ virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, - virDomainEventPtr event, + virObjectEventPtr event, virConnectObjectEventGenericCallback cb, void *cbopaque, void *opaque); @@ -1607,7 +1564,7 @@ typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, static void virDomainEventDispatchDefaultFunc(virConnectPtr conn, - virDomainEventPtr event, + virObjectEventPtr event, virConnectDomainEventGenericCallback cb, void *cbopaque, void *opaque ATTRIBUTE_UNUSED) @@ -1789,7 +1746,7 @@ cleanup: } -static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, +static int virObjectEventDispatchMatchCallback(virObjectEventPtr event, virObjectEventCallbackPtr cb) { if (!cb) @@ -1817,7 +1774,7 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event, static void -virDomainEventDispatch(virDomainEventPtr event, +virObjectEventDispatch(virObjectEventPtr event, virObjectEventCallbackListPtr callbacks, virObjectEventDispatchFunc dispatch, void *opaque) @@ -1829,7 +1786,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, @@ -1850,7 +1807,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); @@ -1859,7 +1816,7 @@ virObjectEventQueueDispatch(virObjectEventQueuePtr queue, void virObjectEventStateQueue(virObjectEventStatePtr state, - virDomainEventPtr event) + virObjectEventPtr event) { if (state->timer < 0) { virObjectUnref(event); @@ -1881,7 +1838,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 06443a0..4e438f2 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -41,9 +41,6 @@ typedef virObjectEventCallbackList *virObjectEventCallbackListPtr; typedef struct _virObjectEvent virObjectEvent; typedef virObjectEvent *virObjectEventPtr; -typedef struct _virDomainEvent virDomainEvent; -typedef virDomainEvent *virDomainEventPtr; - typedef struct _virObjectEventQueue virObjectEventQueue; typedef virObjectEventQueue *virObjectEventQueuePtr; @@ -169,7 +166,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.2

On Fri, 2013-11-29 at 17:18 +0000, Daniel P. Berrange wrote: In most of the cases, the uuid is used for the filtering... but that can be improved later for virInterfacePtr and virInterfacePtr. The problem is that virClassNew is failing to create a class that has no new attribute due to objectSize <= parent->objectSize. I'm tempted to replace the '<=' in that test by '<'. Any objection? -- Cedric

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. --- include/libvirt/libvirt.h.in | 8 ++++++++ src/conf/domain_event.c | 10 ++++++++-- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 5aad75c..25ab777 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -4961,6 +4961,14 @@ typedef enum { } virDomainEventID; +/** Event IDs are computed in the following way: + virEventNamespaceID << 8 + vir*EventId + */ +typedef enum { + VIR_EVENT_NAMESPACE_DOMAIN = 0, /* 0 to keep value of virDomainEventId unchanged */ +} virEventNamespaceID; + + /* Use VIR_DOMAIN_EVENT_CALLBACK() to cast the 'cb' parameter */ int virConnectDomainEventRegisterAny(virConnectPtr conn, virDomainPtr dom, /* Optional, to filter */ diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index d4ecc23..d78f3ea 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -1844,11 +1844,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); } -- 1.8.4.2

--- src/conf/domain_event.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index d78f3ea..b0c9050 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -825,7 +825,7 @@ virObjectEventStateFree(virObjectEventStatePtr state) static void virObjectEventStateFlush(virObjectEventStatePtr state); static void -virDomainEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque) +virObjectEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque) { virObjectEventStatePtr state = opaque; @@ -1922,7 +1922,7 @@ virObjectEventStateRegisterID(virConnectPtr conn, if ((state->callbacks->count == 0) && (state->timer == -1) && (state->timer = virEventAddTimeout(-1, - virDomainEventTimer, + virObjectEventTimer, state, NULL)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -1974,7 +1974,7 @@ virDomainEventStateRegister(virConnectPtr conn, if ((state->callbacks->count == 0) && (state->timer == -1) && (state->timer = virEventAddTimeout(-1, - virDomainEventTimer, + virObjectEventTimer, state, NULL)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", -- 1.8.4.2

--- src/conf/domain_event.c | 102 ++++++++++++++++++++++++++++-------------------- 1 file changed, 59 insertions(+), 43 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index b0c9050..0c38352 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -79,6 +79,8 @@ struct _virObjectEventCallback { static virClassPtr virObjectEventClass; +static virClassPtr virClassForObjectEvent(void); + static virClassPtr virDomainEventLifecycleClass; static virClassPtr virDomainEventRTCChangeClass; static virClassPtr virDomainEventWatchdogClass; @@ -211,62 +213,76 @@ static int virObjectEventOnceInit(void) sizeof(virObjectEvent), virObjectEventDispose))) return -1; + return 0; +} + +VIR_ONCE_GLOBAL_INIT(virObjectEvent) + +virClassPtr virClassForObjectEvent(void) +{ + if (virObjectEventInitialize() < 0) + return NULL; + return virObjectEventClass; +} + +static int virDomainEventsOnceInit(void) +{ if (!(virDomainEventLifecycleClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventLifecycle", sizeof(virDomainEventLifecycle), virDomainEventLifecycleDispose))) return -1; if (!(virDomainEventRTCChangeClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventRTCChange", sizeof(virDomainEventRTCChange), virDomainEventRTCChangeDispose))) return -1; if (!(virDomainEventWatchdogClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventWatchdog", sizeof(virDomainEventWatchdog), virDomainEventWatchdogDispose))) return -1; if (!(virDomainEventIOErrorClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventIOError", sizeof(virDomainEventIOError), virDomainEventIOErrorDispose))) return -1; if (!(virDomainEventGraphicsClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventGraphics", sizeof(virDomainEventGraphics), virDomainEventGraphicsDispose))) return -1; if (!(virDomainEventBlockJobClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventBlockJob", sizeof(virDomainEventBlockJob), virDomainEventBlockJobDispose))) return -1; if (!(virDomainEventDiskChangeClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventDiskChange", sizeof(virDomainEventDiskChange), virDomainEventDiskChangeDispose))) return -1; if (!(virDomainEventTrayChangeClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventTrayChange", sizeof(virDomainEventTrayChange), virDomainEventTrayChangeDispose))) return -1; if (!(virDomainEventBalloonChangeClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventBalloonChange", sizeof(virDomainEventBalloonChange), virDomainEventBalloonChangeDispose))) return -1; if (!(virDomainEventDeviceRemovedClass = virClassNew( - virObjectEventClass, + virClassForObjectEvent(), "virDomainEventDeviceRemoved", sizeof(virDomainEventDeviceRemoved), virDomainEventDeviceRemovedDispose))) @@ -274,13 +290,13 @@ static int virObjectEventOnceInit(void) return 0; } -VIR_ONCE_GLOBAL_INIT(virObjectEvent) +VIR_ONCE_GLOBAL_INIT(virDomainEvents) static int virObjectEventGetEventID(void *anyobj) { virObjectEventPtr obj = anyobj; - if (!virObjectIsClass(obj, virObjectEventClass)) { + if (!virObjectIsClass(obj, virClassForObjectEvent())) { VIR_WARN("Object %p (%s) is not a virObjectEvent instance", obj, obj ? virClassName(obj->parent.klass) : "(unknown)"); return -1; @@ -905,7 +921,7 @@ void *virDomainEventLifecycleNew(int id, const char *name, { virDomainEventLifecyclePtr event; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(event = virObjectEventNew(virDomainEventLifecycleClass, @@ -939,30 +955,30 @@ void *virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detai void *virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid) { - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; - return virObjectEventNew(virObjectEventClass, + return virObjectEventNew(virClassForObjectEvent(), VIR_DOMAIN_EVENT_ID_REBOOT, id, name, uuid); } void *virDomainEventRebootNewFromDom(virDomainPtr dom) { - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; - return virObjectEventNew(virObjectEventClass, + return virObjectEventNew(virClassForObjectEvent(), VIR_DOMAIN_EVENT_ID_REBOOT, dom->id, dom->name, dom->uuid); } void *virDomainEventRebootNewFromObj(virDomainObjPtr obj) { - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; - return virObjectEventNew(virObjectEventClass, + return virObjectEventNew(virClassForObjectEvent(), VIR_DOMAIN_EVENT_ID_REBOOT, obj->def->id, obj->def->name, obj->def->uuid); } @@ -972,7 +988,7 @@ void *virDomainEventRTCChangeNewFromDom(virDomainPtr dom, { virDomainEventRTCChangePtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventRTCChangeClass, @@ -989,7 +1005,7 @@ void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, { virDomainEventRTCChangePtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventRTCChangeClass, @@ -1007,7 +1023,7 @@ void *virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action) { virDomainEventWatchdogPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventWatchdogClass, @@ -1023,7 +1039,7 @@ void *virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action) { virDomainEventWatchdogPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventWatchdogClass, @@ -1046,7 +1062,7 @@ static void *virDomainEventIOErrorNewFromDomImpl(int event, { virDomainEventIOErrorPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventIOErrorClass, event, @@ -1073,7 +1089,7 @@ static void *virDomainEventIOErrorNewFromObjImpl(int event, { virDomainEventIOErrorPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventIOErrorClass, event, @@ -1144,7 +1160,7 @@ void *virDomainEventGraphicsNewFromDom(virDomainPtr dom, { virDomainEventGraphicsPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventGraphicsClass, @@ -1173,7 +1189,7 @@ void *virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, { virDomainEventGraphicsPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventGraphicsClass, @@ -1200,7 +1216,7 @@ void * virDomainEventBlockJobNew(int id, const char *name, unsigned char *uuid, { virDomainEventBlockJobPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventBlockJobClass, @@ -1240,10 +1256,10 @@ void *virDomainEventControlErrorNewFromDom(virDomainPtr dom) { virObjectEventPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; - if (!(ev = virObjectEventNew(virObjectEventClass, + if (!(ev = virObjectEventNew(virClassForObjectEvent(), VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, dom->id, dom->name, dom->uuid))) return NULL; @@ -1255,10 +1271,10 @@ void *virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) { virObjectEventPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; - if (!(ev = virObjectEventNew(virObjectEventClass, + if (!(ev = virObjectEventNew(virClassForObjectEvent(), VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, obj->def->id, obj->def->name, obj->def->uuid))) @@ -1275,7 +1291,7 @@ void *virDomainEventDiskChangeNew(int id, const char *name, { virDomainEventDiskChangePtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventDiskChangeClass, @@ -1331,7 +1347,7 @@ void *virDomainEventTrayChangeNew(int id, const char *name, { virDomainEventTrayChangePtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventTrayChangeClass, @@ -1375,10 +1391,10 @@ static void *virDomainEventPMWakeupNew(int id, const char *name, { virObjectEventPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; - if (!(ev = virObjectEventNew(virObjectEventClass, + if (!(ev = virObjectEventNew(virClassForObjectEvent(), VIR_DOMAIN_EVENT_ID_PMWAKEUP, id, name, uuid))) return NULL; @@ -1403,10 +1419,10 @@ static void *virDomainEventPMSuspendNew(int id, const char *name, { virObjectEventPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; - if (!(ev = virObjectEventNew(virObjectEventClass, + if (!(ev = virObjectEventNew(virClassForObjectEvent(), VIR_DOMAIN_EVENT_ID_PMSUSPEND, id, name, uuid))) return NULL; @@ -1431,10 +1447,10 @@ static void *virDomainEventPMSuspendDiskNew(int id, const char *name, { virObjectEventPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; - if (!(ev = virObjectEventNew(virObjectEventClass, + if (!(ev = virObjectEventNew(virClassForObjectEvent(), VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK, id, name, uuid))) return NULL; @@ -1458,7 +1474,7 @@ void *virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, { virDomainEventBalloonChangePtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventBalloonChangeClass, @@ -1475,7 +1491,7 @@ void *virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, { virDomainEventBalloonChangePtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventBalloonChangeClass, @@ -1495,7 +1511,7 @@ static void *virDomainEventDeviceRemovedNew(int id, { virDomainEventDeviceRemovedPtr ev; - if (virObjectEventInitialize() < 0) + if (virDomainEventsInitialize() < 0) return NULL; if (!(ev = virObjectEventNew(virDomainEventDeviceRemovedClass, -- 1.8.4.2

On Fri, Nov 29, 2013 at 05:21:21PM +0000, Daniel P. Berrange wrote: Oh ignore me. I should have remembered that I suggested splitting this into two separate source files. ACK 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 :|

On Fri, Nov 29, 2013 at 04:19:04PM +0100, Cédric Bosdonnat wrote: Again not seeing this used anywhere in public API. The rest of the APIs make sense. 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 :|