[libvirt] [PATCH 00/34] network events feature v2
This patch serie is replacing the previous one I sent. The improvements that were made in between are: * splitting the 2 huge commits into smaller reviewable ones. * Get rid of the huge union in virDomainEvent and use virObjects instead. * No domain events-related code in object_event.c. I left the network events related code there as it would be pretty small in a separate set of files. * Rebased on the python split repository I saw something weird in the domain events code when working on this: VIR_DOMAIN_EVENT_LAST is defined if VIR_ENUM_SENTINELS is defined, but is generally used independently of it. I did the same for the VIR_NETWORK_EVENT_LAST thought I'm not sure that's the correct thing to do. These changes are all about bringing events for network object like the ones existing for domains. This feature is needed for virt-manager to refresh its UI when networks are started/destroyed/defined/undefined. The network events are implemented in the test, bridge network and remote drivers ATM. Cédric Bosdonnat (34): Added domain start/stop/define/undefine event unit tests Rename virDomainEventCallback to virObjectEventCallback Renamed virDomainMeta to virObjectMeta Renamed virDomainEventQueue to virObjectEventQueue Renamed virDomainEventState to virObjectEventState Renamed virDomainEventCallbackList* to virObjectEventCallbackList* Created virObjectEventStateRegisterID virObject-ified virDomainEvent Create virDomainEventLifecycle to start removing the huge union Renamed virDomainEventNew* to virDomainEventLifecycleNew* Renamed virDomainEventNewInternal to virDomainEventNew Create virDomainEventRTCChange to get rid of the huge union Created virDomainEventWatchdog to get rid of the huge union Created virDomainEventIOError Created virDomainEventGraphics Created virDomainEventBlockJob Create virDomainEventDiskChange Created virDomainEventTrayChange Created virDomainEventBalloonChange Created virDomainEventDeviceRemoved and removed the huge union Changed the remaining domain event creation methods results to void* Removed virDomainEventPtr in favor of virObjectEventPtr Add object event namespaces for the event IDs Renamed virDomainEventTimer to virObjectEventTimer Split the virObjectEvent and virDomainEvent* to separate them after Extracted common parts of domain_event.[ch] to object_event.[ch] Added virNetworkEventLifecycle object Added API for network events similar to the one from Domain events test driver: renamed testDomainEventQueue into testObjectEventQueue test driver: implemented network events Add network events unit tests daemon/remote.c: renamed remoteDispatchDomainEventSend Add network events to the remote driver Added network events to the bridged network driver .gitignore | 1 + cfg.mk | 6 +- daemon/libvirtd.h | 1 + daemon/remote.c | 175 ++- include/libvirt/libvirt.h.in | 86 ++ src/Makefile.am | 6 + src/conf/domain_event.c | 1954 ++++++++++++++-------------------- src/conf/domain_event.h | 219 ++-- src/conf/object_event.c | 903 ++++++++++++++++ src/conf/object_event.h | 113 ++ src/conf/object_event_private.h | 113 ++ src/driver.h | 14 + src/libvirt.c | 133 +++ src/libvirt_private.syms | 25 +- src/libvirt_public.syms | 7 + src/libxl/libxl_conf.h | 2 +- src/libxl/libxl_driver.c | 46 +- src/lxc/lxc_conf.h | 2 +- src/lxc/lxc_driver.c | 54 +- src/lxc/lxc_process.c | 20 +- src/network/bridge_driver.c | 89 ++ src/network/bridge_driver_platform.h | 3 + src/parallels/parallels_utils.h | 2 +- src/qemu/qemu_conf.h | 2 +- src/qemu/qemu_domain.c | 6 +- src/qemu/qemu_domain.h | 2 +- src/qemu/qemu_driver.c | 116 +- src/qemu/qemu_hotplug.c | 10 +- src/qemu/qemu_migration.c | 38 +- src/qemu/qemu_process.c | 70 +- src/remote/remote_driver.c | 178 +++- src/remote/remote_protocol.x | 46 +- src/test/test_driver.c | 197 ++-- src/uml/uml_conf.h | 2 +- src/uml/uml_driver.c | 44 +- src/vbox/vbox_tmpl.c | 22 +- src/xen/xen_driver.c | 10 +- src/xen/xen_driver.h | 4 +- src/xen/xen_inotify.c | 10 +- src/xen/xs_internal.c | 20 +- tests/Makefile.am | 7 + tests/objecteventtest.c | 407 +++++++ tests/qemuhotplugtest.c | 2 +- 43 files changed, 3525 insertions(+), 1642 deletions(-) create mode 100644 src/conf/object_event.c create mode 100644 src/conf/object_event.h create mode 100644 src/conf/object_event_private.h create mode 100644 tests/objecteventtest.c -- 1.8.4.2
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@suse.com> + */ + +#include <config.h> + +#include "testutils.h" + +#include "virerror.h" +#include "virxml.h" + +#define VIR_FROM_THIS VIR_FROM_NONE + + +static const char domainDef[] = +"<domain type='test'>" +" <name>test-domain</name>" +" <uuid>77a6fc12-07b5-9415-8abb-a803613f2a40</uuid>" +" <memory>8388608</memory>" +" <currentMemory>2097152</currentMemory>" +" <vcpu>2</vcpu>" +" <os>" +" <type>hvm</type>" +" </os>" +"</domain>"; + +struct lifecycleEventCounter { + int startEvents; + int stopEvents; + int defineEvents; + int undefineEvents; +}; + +static void lifecycleEventCounter_reset(struct lifecycleEventCounter* counter) +{ + counter->startEvents = 0; + counter->stopEvents = 0; + counter->defineEvents = 0; + counter->undefineEvents = 0; +} + +struct objecteventTest { + virConnectPtr conn; +}; + + +static int domainLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED, + virDomainPtr dom ATTRIBUTE_UNUSED, + int event, + int detail ATTRIBUTE_UNUSED, + void *opaque) +{ + struct lifecycleEventCounter *counter = opaque; + + switch (event) { + case VIR_DOMAIN_EVENT_STARTED: + counter->startEvents++; + break; + case VIR_DOMAIN_EVENT_STOPPED: + counter->stopEvents++; + break; + case VIR_DOMAIN_EVENT_DEFINED: + counter->defineEvents++; + break; + case VIR_DOMAIN_EVENT_UNDEFINED: + counter->undefineEvents++; + break; + default: + /* Ignore other events */ + break; + } + return 0; +} + +static int +testDomainCreateXML(const void *data) +{ + const struct objecteventTest *test = data; + struct lifecycleEventCounter counter; + int eventId = VIR_DOMAIN_EVENT_ID_LIFECYCLE; + virDomainPtr dom; + int id; + int ret = 0; + + lifecycleEventCounter_reset(&counter); + + id = virConnectDomainEventRegisterAny(test->conn, NULL, eventId, + VIR_DOMAIN_EVENT_CALLBACK(&domainLifecycleCb), + &counter, NULL); + dom = virDomainCreateXML(test->conn, domainDef, 0); + + if (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
On Fri, Nov 29, 2013 at 04:18:37PM +0100, Cédric Bosdonnat wrote:
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
Cool, nice approach to testing this.
+ dom = virDomainCreateXML(test->conn, domainDef, 0);
Should check for dom == NULL
+ + if (virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.startEvents != 1) { + ret = -1; + goto cleanup; + } + +cleanup: + virConnectDomainEventDeregisterAny(test->conn, id); + virDomainDestroy(dom); + + virDomainFree(dom);
and void calling destroy/free if dom == NULL
+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);
Same comment as before, and few more places - won't repeat myself for the others. Regards, 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 | 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
On Fri, Nov 29, 2013 at 04:18:38PM +0100, Cédric Bosdonnat wrote:
--- src/conf/domain_event.c | 8 ++++---- src/conf/domain_event.h | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-)
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 :|
--- 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
On Fri, Nov 29, 2013 at 04:18:39PM +0100, Cédric Bosdonnat wrote:
--- src/conf/domain_event.c | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-)
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 :|
--- 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
On Fri, Nov 29, 2013 at 04:18:40PM +0100, Cédric Bosdonnat wrote:
--- src/conf/domain_event.c | 46 +++++++++++++++++++++++----------------------- src/conf/domain_event.h | 4 ++-- 2 files changed, 25 insertions(+), 25 deletions(-)
Interesting that the header file change didn't cause problems elsewhere in the codebase. This is a sign that we should just move the typedef out of the header and into .c file instead as nothing needs it publicised.
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;
eg move these into domain_event.c 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 :|
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
On Fri, Nov 29, 2013 at 04:18:41PM +0100, Cédric Bosdonnat wrote:
but left virDomainEventRegister and its Deregister brother as these are legacy functions only for domain lifecycle events.
s/but left/Leave/ since it is usual that the description isn't a part of the subject line sentance 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 :|
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
On Fri, Nov 29, 2013 at 04:18:42PM +0100, Cédric Bosdonnat wrote:
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.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;
Another case where we can move the typedef out of the header Regards, 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 :|
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
On Fri, Nov 29, 2013 at 04:18:43PM +0100, Cédric Bosdonnat wrote:
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(-) /** + * 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],
I think I'd declare that as 'unsigned char *uuid' instead
+ const char *name, + int id, + int eventID, + virConnectObjectEventGenericCallback cb, + void *opaque, + virFreeCallback freecb, + int *callbackID)
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 :|
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
On Fri, Nov 29, 2013 at 04:18:44PM +0100, Cédric Bosdonnat wrote:
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/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 +static void virDomainEventDispose(void *obj) +{ + virDomainEventPtr event = obj; + + VIR_DEBUG("obj=%p", event); + + if (!event) + return;
We guarantee that 'obj' != NULL for dispose handlers I believe.
+ + 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); +}
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 | 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, Nov 29, 2013 at 04:18:45PM +0100, Cédric Bosdonnat wrote:
--- 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; };
+ +
Nit-pick: add these 2 lines in the previous patch when you rebase next
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;
@@ -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)
I think I'd prefer these to return 'virObjectEventPtr' rather than void *, since that's the shared base class of all these event types 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, 2013-11-29 at 17:09 +0000, Daniel P. Berrange wrote:
On Fri, Nov 29, 2013 at 04:18:45PM +0100, Cédric Bosdonnat wrote:
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;
@@ -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)
I think I'd prefer these to return 'virObjectEventPtr' rather than void *, since that's the shared base class of all these event types
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
to have some consistency with other domain events --- src/conf/domain_event.c | 16 ++++++----- src/conf/domain_event.h | 18 ++++++++++--- src/libvirt_private.syms | 8 +++--- src/libxl/libxl_driver.c | 18 ++++++------- src/lxc/lxc_driver.c | 16 +++++------ src/lxc/lxc_process.c | 8 +++--- src/qemu/qemu_driver.c | 66 +++++++++++++++++++++++----------------------- src/qemu/qemu_migration.c | 26 +++++++++--------- src/qemu/qemu_process.c | 22 ++++++++-------- src/remote/remote_driver.c | 2 +- src/test/test_driver.c | 46 ++++++++++++++++---------------- src/uml/uml_driver.c | 18 ++++++------- src/vbox/vbox_tmpl.c | 4 +-- src/xen/xen_inotify.c | 2 +- src/xen/xs_internal.c | 16 +++++------ 15 files changed, 149 insertions(+), 137 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index a69ce11..1c5dcd3 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -786,7 +786,7 @@ static void *virDomainEventNewInternal(virClassPtr klass, return event; } -void *virDomainEventNew(int id, const char *name, +void *virDomainEventLifecycleNew(int id, const char *name, const unsigned char *uuid, int type, int detail) { @@ -806,19 +806,21 @@ void *virDomainEventNew(int id, const char *name, return event; } -void *virDomainEventNewFromDom(virDomainPtr dom, int type, int detail) +void *virDomainEventLifecycleNewFromDom(virDomainPtr dom, int type, int detail) { - return virDomainEventNew(dom->id, dom->name, dom->uuid, type, detail); + return virDomainEventLifecycleNew(dom->id, dom->name, dom->uuid, + type, detail); } -void *virDomainEventNewFromObj(virDomainObjPtr obj, int type, int detail) +void *virDomainEventLifecycleNewFromObj(virDomainObjPtr obj, int type, int detail) { - return virDomainEventNewFromDef(obj->def, type, detail); + return virDomainEventLifecycleNewFromDef(obj->def, type, detail); } -void *virDomainEventNewFromDef(virDomainDefPtr def, int type, int detail) +void *virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detail) { - return virDomainEventNew(def->id, def->name, def->uuid, type, detail); + return virDomainEventLifecycleNew(def->id, def->name, def->uuid, + type, detail); } virDomainEventPtr virDomainEventRebootNew(int id, const char *name, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 04b846e..2349b54 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -50,10 +50,20 @@ typedef virObjectEventQueue *virObjectEventQueuePtr; typedef struct _virObjectEventState virObjectEventState; typedef virObjectEventState *virObjectEventStatePtr; -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); +void *virDomainEventLifecycleNew(int id, + const char *name, + const unsigned char *uuid, + int type, + int detail); +void *virDomainEventLifecycleNewFromDom(virDomainPtr dom, + int type, + int detail); +void *virDomainEventLifecycleNewFromObj(virDomainObjPtr obj, + int type, + int detail); +void *virDomainEventLifecycleNewFromDef(virDomainDefPtr def, + int type, + int detail); virDomainEventPtr virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid); virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom); diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index a7bbc79..d098d3e 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -427,10 +427,10 @@ virDomainEventIOErrorNewFromDom; virDomainEventIOErrorNewFromObj; virDomainEventIOErrorReasonNewFromDom; virDomainEventIOErrorReasonNewFromObj; -virDomainEventNew; -virDomainEventNewFromDef; -virDomainEventNewFromDom; -virDomainEventNewFromObj; +virDomainEventLifecycleNew; +virDomainEventLifecycleNewFromDef; +virDomainEventLifecycleNewFromDom; +virDomainEventLifecycleNewFromObj; virDomainEventPMSuspendDiskNewFromDom; virDomainEventPMSuspendDiskNewFromObj; virDomainEventPMSuspendNewFromDom; diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c index bc5f653..9a598a9 100644 --- a/src/libxl/libxl_driver.c +++ b/src/libxl/libxl_driver.c @@ -380,7 +380,7 @@ libxlEventHandler(void *data, VIR_LIBXL_EVENT_CONST libxl_event *event) case LIBXL_SHUTDOWN_REASON_POWEROFF: case LIBXL_SHUTDOWN_REASON_CRASH: if (xl_reason == LIBXL_SHUTDOWN_REASON_CRASH) { - dom_event = virDomainEventNewFromObj(vm, + dom_event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_CRASHED); reason = VIR_DOMAIN_SHUTOFF_CRASHED; @@ -675,7 +675,7 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback) driver->inhibitCallback(true, driver->inhibitOpaque); - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, restore_fd < 0 ? VIR_DOMAIN_EVENT_STARTED_BOOTED : VIR_DOMAIN_EVENT_STARTED_RESTORED); @@ -1324,7 +1324,7 @@ libxlDomainSuspend(virDomainPtr dom) virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); } @@ -1377,7 +1377,7 @@ libxlDomainResume(virDomainPtr dom) virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED); - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_UNPAUSED); } @@ -1501,7 +1501,7 @@ libxlDomainDestroyFlags(virDomainPtr dom, goto cleanup; } - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); if (libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED) != 0) { @@ -1821,7 +1821,7 @@ libxlDoDomainSave(libxlDriverPrivatePtr driver, virDomainObjPtr vm, goto cleanup; } - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SAVED); if (libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_SAVED) != 0) { @@ -2009,7 +2009,7 @@ libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags) goto cleanup_unpause; } - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_CRASHED); if (!vm->persistent) { virDomainObjListRemove(driver->domains, vm); @@ -2699,7 +2699,7 @@ libxlDomainDefineXML(virConnectPtr conn, const char *xml) if (dom) dom->id = vm->def->id; - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, !oldDef ? VIR_DOMAIN_EVENT_DEFINED_ADDED : VIR_DOMAIN_EVENT_DEFINED_UPDATED); @@ -2766,7 +2766,7 @@ libxlDomainUndefineFlags(virDomainPtr dom, if (virDomainDeleteConfig(cfg->configDir, cfg->autostartDir, vm) < 0) goto cleanup; - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_UNDEFINED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_UNDEFINED, VIR_DOMAIN_EVENT_UNDEFINED_REMOVED); if (virDomainObjIsActive(vm)) { diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index 391226b..57d64b8 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -480,7 +480,7 @@ static virDomainPtr lxcDomainDefineXML(virConnectPtr conn, const char *xml) goto cleanup; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, !oldDef ? VIR_DOMAIN_EVENT_DEFINED_ADDED : @@ -530,7 +530,7 @@ static int lxcDomainUndefineFlags(virDomainPtr dom, vm) < 0) goto cleanup; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_UNDEFINED, VIR_DOMAIN_EVENT_UNDEFINED_REMOVED); @@ -932,7 +932,7 @@ static int lxcDomainCreateWithFiles(virDomainPtr dom, VIR_DOMAIN_RUNNING_BOOTED); if (ret == 0) { - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); virDomainAuditStart(vm, "booted", true); @@ -1040,7 +1040,7 @@ lxcDomainCreateXMLWithFiles(virConnectPtr conn, goto cleanup; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); virDomainAuditStart(vm, "booted", true); @@ -1288,7 +1288,7 @@ lxcDomainDestroyFlags(virDomainPtr dom, priv = vm->privateData; ret = virLXCProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); priv->doneStopEvent = true; @@ -1482,7 +1482,7 @@ static void lxcNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque) if (newVM) { virDomainEventPtr event = - virDomainEventNewFromObj(vm, + virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, VIR_DOMAIN_EVENT_DEFINED_ADDED); if (event) @@ -2361,7 +2361,7 @@ static int lxcDomainSuspend(virDomainPtr dom) } virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); } @@ -2411,7 +2411,7 @@ static int lxcDomainResume(virDomainPtr dom) virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_UNPAUSED); } diff --git a/src/lxc/lxc_process.c b/src/lxc/lxc_process.c index 8214f62..9b5f3f2 100644 --- a/src/lxc/lxc_process.c +++ b/src/lxc/lxc_process.c @@ -71,7 +71,7 @@ lxcProcessAutoDestroy(virDomainObjPtr dom, VIR_DEBUG("Killing domain"); virLXCProcessStop(driver, dom, VIR_DOMAIN_SHUTOFF_DESTROYED); virDomainAuditStop(dom, "destroyed"); - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); priv->doneStopEvent = true; @@ -502,7 +502,7 @@ static void virLXCProcessMonitorEOFNotify(virLXCMonitorPtr mon, if (!priv->wantReboot) { virLXCProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN); if (!priv->doneStopEvent) { - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, priv->stopReason); virDomainAuditStop(vm, "shutdown"); @@ -520,7 +520,7 @@ static void virLXCProcessMonitorEOFNotify(virLXCMonitorPtr mon, if (ret == 0) { event = virDomainEventRebootNewFromObj(vm); } else { - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, priv->stopReason); if (!vm->persistent) { @@ -1395,7 +1395,7 @@ virLXCProcessAutostartDomain(virDomainObjPtr vm, err ? err->message : ""); } else { virDomainEventPtr event = - virDomainEventNewFromObj(vm, + virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); if (event) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index ab6004d..b6be9a8 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -879,7 +879,7 @@ static void qemuNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque) if (newVM) { virDomainEventPtr event = - virDomainEventNewFromObj(vm, + virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, VIR_DOMAIN_EVENT_DEFINED_ADDED); if (event) @@ -1627,7 +1627,7 @@ static virDomainPtr qemuDomainCreateXML(virConnectPtr conn, goto cleanup; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); if (event && (flags & VIR_DOMAIN_START_PAUSED)) { @@ -1636,7 +1636,7 @@ static virDomainPtr qemuDomainCreateXML(virConnectPtr conn, * no matter what, but don't care about suspend events), and * those that also care about running/paused. To satisfy both * client types, we have to send two events. */ - event2 = virDomainEventNewFromObj(vm, + event2 = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); } @@ -1721,7 +1721,7 @@ static int qemuDomainSuspend(virDomainPtr dom) { } if (eventDetail >= 0) { - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, eventDetail); } @@ -1785,7 +1785,7 @@ static int qemuDomainResume(virDomainPtr dom) { "%s", _("resume operation failed")); goto endjob; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_UNPAUSED); } @@ -2124,7 +2124,7 @@ qemuDomainDestroyFlags(virDomainPtr dom, } qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED, 0); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); virDomainAuditStop(vm, "destroyed"); @@ -3107,7 +3107,7 @@ qemuDomainSaveInternal(virQEMUDriverPtr driver, virDomainPtr dom, /* Shut it down */ qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_SAVED, 0); virDomainAuditStop(vm, "saved"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SAVED); if (!vm->persistent) { @@ -3125,7 +3125,7 @@ endjob: QEMU_ASYNC_JOB_SAVE); if (rc < 0) { VIR_WARN("Unable to resume guest CPUs after save failure"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR); } @@ -3568,7 +3568,7 @@ endjob: if ((ret == 0) && (flags & VIR_DUMP_CRASH)) { qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_CRASHED, 0); virDomainAuditStop(vm, "crashed"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_CRASHED); } @@ -3588,7 +3588,7 @@ endjob: if (resume && qemuProcessStartCPUs(driver, vm, dom->conn, VIR_DOMAIN_RUNNING_UNPAUSED, QEMU_ASYNC_JOB_DUMP) < 0) { - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR); if (virGetLastError() == NULL) @@ -3835,7 +3835,7 @@ processGuestPanicEvent(virQEMUDriverPtr driver, VIR_DOMAIN_CRASHED, VIR_DOMAIN_CRASHED_PANICKED); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_CRASHED, VIR_DOMAIN_EVENT_CRASHED_PANICKED); @@ -3875,7 +3875,7 @@ processGuestPanicEvent(virQEMUDriverPtr driver, } qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_CRASHED, 0); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_CRASHED); @@ -5394,7 +5394,7 @@ qemuDomainSaveImageStartVM(virConnectPtr conn, goto cleanup; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_RESTORED); virDomainAuditStart(vm, "restored", true); @@ -5419,7 +5419,7 @@ qemuDomainSaveImageStartVM(virConnectPtr conn, } else { int detail = (start_paused ? VIR_DOMAIN_EVENT_SUSPENDED_PAUSED : VIR_DOMAIN_EVENT_SUSPENDED_RESTORED); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, detail); if (event) @@ -6059,13 +6059,13 @@ qemuDomainObjStart(virConnectPtr conn, virDomainAuditStart(vm, "booted", ret >= 0); if (ret >= 0) { virDomainEventPtr event = - virDomainEventNewFromObj(vm, + virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); if (event) { qemuDomainEventQueue(driver, event); if (start_paused) { - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); if (event) @@ -6197,7 +6197,7 @@ static virDomainPtr qemuDomainDefineXML(virConnectPtr conn, const char *xml) { goto cleanup; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, !oldDef ? VIR_DOMAIN_EVENT_DEFINED_ADDED : @@ -6285,7 +6285,7 @@ qemuDomainUndefineFlags(virDomainPtr dom, if (virDomainDeleteConfig(cfg->configDir, cfg->autostartDir, vm) < 0) goto cleanup; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_UNDEFINED, VIR_DOMAIN_EVENT_UNDEFINED_REMOVED); @@ -11700,7 +11700,7 @@ qemuDomainSnapshotCreateActiveInternal(virConnectPtr conn, goto cleanup; if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) { - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT); qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT, 0); virDomainAuditStop(vm, "from-snapshot"); @@ -11716,7 +11716,7 @@ cleanup: qemuProcessStartCPUs(driver, vm, conn, VIR_DOMAIN_RUNNING_UNPAUSED, QEMU_ASYNC_JOB_NONE) < 0) { - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR); if (virGetLastError() == NULL) { @@ -12251,7 +12251,7 @@ qemuDomainSnapshotCreateActiveExternal(virConnectPtr conn, if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) { virDomainEventPtr event; - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT); qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT, 0); virDomainAuditStop(vm, "from-snapshot"); @@ -12271,7 +12271,7 @@ qemuDomainSnapshotCreateActiveExternal(virConnectPtr conn, virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_FROM_SNAPSHOT); - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT); if (event) qemuDomainEventQueue(driver, event); @@ -12285,7 +12285,7 @@ endjob: VIR_DOMAIN_RUNNING_UNPAUSED, QEMU_ASYNC_JOB_SNAPSHOT) < 0) { virDomainEventPtr event = NULL; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR); if (event) @@ -13081,7 +13081,7 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT, 0); virDomainAuditStop(vm, "from-snapshot"); detail = VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, detail); if (event) @@ -13101,7 +13101,7 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, * that user will be alerted that they are now paused. * If restore later succeeds, we might replace this. */ detail = VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, detail); if (!virDomainObjIsActive(vm)) { @@ -13133,7 +13133,7 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, VIR_QEMU_PROCESS_START_PAUSED); virDomainAuditStart(vm, "from-snapshot", rc >= 0); detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, detail); if (rc < 0) @@ -13150,7 +13150,7 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, if (was_stopped) { /* Transition 3, use event as-is and add event2 */ detail = VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT; - event2 = virDomainEventNewFromObj(vm, + event2 = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, detail); } /* else transition 6 and 9 use event as-is */ @@ -13171,13 +13171,13 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, if (was_stopped) { /* Transition 2 */ detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, detail); } else if (was_running) { /* Transition 8 */ detail = VIR_DOMAIN_EVENT_RESUMED; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, detail); } @@ -13194,7 +13194,7 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT, 0); virDomainAuditStop(vm, "from-snapshot"); detail = VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, detail); } @@ -13236,12 +13236,12 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, goto endjob; } detail = VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, detail); if (paused) { detail = VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT; - event2 = virDomainEventNewFromObj(vm, + event2 = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, detail); } @@ -13901,7 +13901,7 @@ cleanup: VIR_DOMAIN_RUNNING_UNPAUSED, QEMU_ASYNC_JOB_NONE) < 0) { virDomainEventPtr event = NULL; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR); if (event) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index ef6f1c5..221beea 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -1513,7 +1513,7 @@ qemuMigrationSetOffline(virQEMUDriverPtr driver, if (ret == 0) { virDomainEventPtr event; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED); if (event) @@ -2422,7 +2422,7 @@ done: if (!(flags & VIR_MIGRATE_OFFLINE)) { virDomainAuditStart(vm, "migrated", true); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_MIGRATED); } @@ -2736,7 +2736,7 @@ qemuMigrationConfirmPhase(virQEMUDriverPtr driver, VIR_QEMU_PROCESS_STOP_MIGRATED); virDomainAuditStop(vm, "migrated"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_MIGRATED); } else { @@ -2757,7 +2757,7 @@ qemuMigrationConfirmPhase(virQEMUDriverPtr driver, goto cleanup; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_MIGRATED); if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) { @@ -4100,7 +4100,7 @@ qemuMigrationPerformJob(virQEMUDriverPtr driver, qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_MIGRATED, VIR_QEMU_PROCESS_STOP_MIGRATED); virDomainAuditStop(vm, "migrated"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_MIGRATED); } @@ -4123,7 +4123,7 @@ endjob: vm->def->name); } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_MIGRATED); } @@ -4205,7 +4205,7 @@ qemuMigrationPerformPhase(virQEMUDriverPtr driver, vm->def->name); } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_MIGRATED); } @@ -4418,7 +4418,7 @@ qemuMigrationFinish(virQEMUDriverPtr driver, qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED, VIR_QEMU_PROCESS_STOP_MIGRATED); virDomainAuditStop(vm, "failed"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FAILED); goto endjob; @@ -4469,7 +4469,7 @@ qemuMigrationFinish(virQEMUDriverPtr driver, goto endjob; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, newVM ? VIR_DOMAIN_EVENT_DEFINED_ADDED : @@ -4507,7 +4507,7 @@ qemuMigrationFinish(virQEMUDriverPtr driver, qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED, VIR_QEMU_PROCESS_STOP_MIGRATED); virDomainAuditStop(vm, "failed"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FAILED); } @@ -4518,7 +4518,7 @@ qemuMigrationFinish(virQEMUDriverPtr driver, dom = virGetDomain(dconn, vm->def->name, vm->def->uuid); if (!(flags & VIR_MIGRATE_OFFLINE)) { - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_MIGRATED); if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { @@ -4526,7 +4526,7 @@ qemuMigrationFinish(virQEMUDriverPtr driver, VIR_DOMAIN_PAUSED_USER); if (event) qemuDomainEventQueue(driver, event); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); } @@ -4544,7 +4544,7 @@ qemuMigrationFinish(virQEMUDriverPtr driver, qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED, VIR_QEMU_PROCESS_STOP_MIGRATED); virDomainAuditStop(vm, "failed"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FAILED); } diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index a26c079..7904ee5 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -316,7 +316,7 @@ qemuProcessHandleMonitorEOF(qemuMonitorPtr mon ATTRIBUTE_UNUSED, auditReason = "failed"; } - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, eventReason); qemuProcessStop(driver, vm, stopReason, 0); @@ -589,7 +589,7 @@ qemuProcessFakeReboot(void *opaque) goto endjob; } priv->gotShutdown = false; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_UNPAUSED); @@ -672,7 +672,7 @@ qemuProcessHandleShutdown(qemuMonitorPtr mon ATTRIBUTE_UNUSED, virDomainObjSetState(vm, VIR_DOMAIN_SHUTDOWN, VIR_DOMAIN_SHUTDOWN_UNKNOWN); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SHUTDOWN, VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED); @@ -718,7 +718,7 @@ qemuProcessHandleStop(qemuMonitorPtr mon ATTRIBUTE_UNUSED, vm->def->name); virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_UNKNOWN); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); @@ -766,7 +766,7 @@ qemuProcessHandleResume(qemuMonitorPtr mon ATTRIBUTE_UNUSED, virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_UNPAUSED); @@ -857,7 +857,7 @@ qemuProcessHandleWatchdog(qemuMonitorPtr mon ATTRIBUTE_UNUSED, VIR_DEBUG("Transitioned guest %s to paused state due to watchdog", vm->def->name); virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_WATCHDOG); - lifecycleEvent = virDomainEventNewFromObj(vm, + lifecycleEvent = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG); @@ -939,7 +939,7 @@ qemuProcessHandleIOError(qemuMonitorPtr mon ATTRIBUTE_UNUSED, VIR_DEBUG("Transitioned guest %s to paused state due to IO error", vm->def->name); virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_IOERROR); - lifecycleEvent = virDomainEventNewFromObj(vm, + lifecycleEvent = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_IOERROR); @@ -1156,7 +1156,7 @@ qemuProcessHandlePMWakeup(qemuMonitorPtr mon ATTRIBUTE_UNUSED, virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_WAKEUP); - lifecycleEvent = virDomainEventNewFromObj(vm, + lifecycleEvent = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_WAKEUP); @@ -1196,7 +1196,7 @@ qemuProcessHandlePMSuspend(qemuMonitorPtr mon ATTRIBUTE_UNUSED, virDomainObjSetState(vm, VIR_DOMAIN_PMSUSPENDED, VIR_DOMAIN_PMSUSPENDED_UNKNOWN); lifecycleEvent = - virDomainEventNewFromObj(vm, + virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_PMSUSPENDED, VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY); @@ -1268,7 +1268,7 @@ qemuProcessHandlePMSuspendDisk(qemuMonitorPtr mon ATTRIBUTE_UNUSED, virDomainObjSetState(vm, VIR_DOMAIN_PMSUSPENDED, VIR_DOMAIN_PMSUSPENDED_UNKNOWN); lifecycleEvent = - virDomainEventNewFromObj(vm, + virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_PMSUSPENDED, VIR_DOMAIN_EVENT_PMSUSPENDED_DISK); @@ -4648,7 +4648,7 @@ qemuProcessAutoDestroy(virDomainObjPtr dom, VIR_QEMU_PROCESS_STOP_MIGRATED); virDomainAuditStop(dom, "destroyed"); - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index e7c319e..9d1a7c5 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -4386,7 +4386,7 @@ remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, if (!dom) return; - event = virDomainEventNewFromDom(dom, msg->event, msg->detail); + event = virDomainEventLifecycleNewFromDom(dom, msg->event, msg->detail); virDomainFree(dom); remoteDomainEventQueue(priv, event); diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 04de78b..fdd1d3e 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -1638,7 +1638,7 @@ testDomainCreateXML(virConnectPtr conn, const char *xml, if (testDomainStartState(privconn, dom, VIR_DOMAIN_RUNNING_BOOTED) < 0) goto cleanup; - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); @@ -1766,7 +1766,7 @@ static int testDomainDestroy(virDomainPtr domain) } testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_DESTROYED); - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); @@ -1811,7 +1811,7 @@ static int testDomainResume(virDomainPtr domain) virDomainObjSetState(privdom, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED); - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_UNPAUSED); ret = 0; @@ -1853,7 +1853,7 @@ static int testDomainSuspend(virDomainPtr domain) } virDomainObjSetState(privdom, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); ret = 0; @@ -1896,7 +1896,7 @@ static int testDomainShutdownFlags(virDomainPtr domain, } testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_SHUTDOWN); - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); @@ -1971,7 +1971,7 @@ static int testDomainReboot(virDomainPtr domain, if (virDomainObjGetState(privdom, NULL) == VIR_DOMAIN_SHUTOFF) { testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_SHUTDOWN); - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); @@ -2135,7 +2135,7 @@ testDomainSaveFlags(virDomainPtr domain, const char *path, fd = -1; testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_SAVED); - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SAVED); @@ -2253,7 +2253,7 @@ testDomainRestoreFlags(virConnectPtr conn, if (testDomainStartState(privconn, dom, VIR_DOMAIN_RUNNING_RESTORED) < 0) goto cleanup; - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_RESTORED); ret = 0; @@ -2319,7 +2319,7 @@ static int testDomainCoreDump(virDomainPtr domain, if (flags & VIR_DUMP_CRASH) { testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_CRASHED); - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_CRASHED); if (!privdom->persistent) { @@ -2803,7 +2803,7 @@ static virDomainPtr testDomainDefineXML(virConnectPtr conn, def = NULL; dom->persistent = 1; - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_DEFINED, !oldDef ? VIR_DOMAIN_EVENT_DEFINED_ADDED : @@ -2946,7 +2946,7 @@ static int testDomainCreateWithFlags(virDomainPtr domain, unsigned int flags) { goto cleanup; domain->id = privdom->def->id; - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); ret = 0; @@ -3011,7 +3011,7 @@ static int testDomainUndefineFlags(virDomainPtr domain, * behavior here. */ } - event = virDomainEventNewFromObj(privdom, + event = virDomainEventLifecycleNewFromObj(privdom, VIR_DOMAIN_EVENT_UNDEFINED, VIR_DOMAIN_EVENT_UNDEFINED_REMOVED); privdom->hasManagedSave = false; @@ -6180,7 +6180,7 @@ testDomainManagedSave(virDomainPtr dom, unsigned int flags) } testDomainShutdownState(dom, vm, VIR_DOMAIN_SHUTOFF_SAVED); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SAVED); vm->hasManagedSave = true; @@ -6719,7 +6719,7 @@ testDomainSnapshotCreateXML(virDomainPtr domain, virDomainObjIsActive(vm)) { testDomainShutdownState(domain, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT); - event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT); } } @@ -6985,7 +6985,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, virResetError(err); testDomainShutdownState(snapshot->domain, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT); if (event) @@ -7001,7 +7001,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, /* Create an event now in case the restore fails, so * that user will be alerted that they are now paused. * If restore later succeeds, we might replace this. */ - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT); } @@ -7015,7 +7015,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, if (testDomainStartState(privconn, vm, VIR_DOMAIN_RUNNING_FROM_SNAPSHOT) < 0) goto cleanup; - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT); } @@ -7029,7 +7029,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, VIR_DOMAIN_PAUSED_FROM_SNAPSHOT); if (was_stopped) { /* Transition 3, use event as-is and add event2 */ - event2 = virDomainEventNewFromObj(vm, + event2 = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT); } /* else transition 6 and 9 use event as-is */ @@ -7040,12 +7040,12 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, if (was_stopped) { /* Transition 2 */ - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT); } else if (was_running) { /* Transition 8 */ - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED); } @@ -7058,7 +7058,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, /* Transitions 4, 7 */ testDomainShutdownState(snapshot->domain, vm, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT); } @@ -7070,11 +7070,11 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, if (event) testDomainEventQueue(privconn, event); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT); if (paused) { - event2 = virDomainEventNewFromObj(vm, + event2 = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT); } diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c index e9bc6d4..4c5bac5 100644 --- a/src/uml/uml_driver.c +++ b/src/uml/uml_driver.c @@ -195,7 +195,7 @@ umlAutostartDomain(virDomainObjPtr vm, vm->def->name, err ? err->message : _("unknown error")); } else { virDomainEventPtr event = - virDomainEventNewFromObj(vm, + virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); if (event) @@ -347,7 +347,7 @@ reread: umlShutdownVMDaemon(driver, dom, VIR_DOMAIN_SHUTOFF_SHUTDOWN); virDomainAuditStop(dom, "shutdown"); - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); if (!dom->persistent) { @@ -381,7 +381,7 @@ reread: umlShutdownVMDaemon(driver, dom, VIR_DOMAIN_SHUTOFF_FAILED); virDomainAuditStop(dom, "failed"); - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FAILED); if (!dom->persistent) { @@ -394,7 +394,7 @@ reread: umlShutdownVMDaemon(driver, dom, VIR_DOMAIN_SHUTOFF_FAILED); virDomainAuditStop(dom, "failed"); - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FAILED); if (!dom->persistent) { @@ -605,7 +605,7 @@ static void umlNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque) if (newVM) { virDomainEventPtr event = - virDomainEventNewFromObj(vm, + virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, VIR_DOMAIN_EVENT_DEFINED_ADDED); if (event) @@ -737,7 +737,7 @@ static void umlProcessAutoDestroyDom(void *payload, VIR_DEBUG("Killing domain"); umlShutdownVMDaemon(data->driver, dom, VIR_DOMAIN_SHUTOFF_DESTROYED); virDomainAuditStop(dom, "destroyed"); - event = virDomainEventNewFromObj(dom, + event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); @@ -1600,7 +1600,7 @@ static virDomainPtr umlDomainCreateXML(virConnectPtr conn, const char *xml, goto cleanup; } virDomainAuditStart(vm, "booted", true); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); @@ -1685,7 +1685,7 @@ umlDomainDestroyFlags(virDomainPtr dom, umlShutdownVMDaemon(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED); virDomainAuditStop(vm, "destroyed"); - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); if (!vm->persistent) { @@ -2014,7 +2014,7 @@ static int umlDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) { (flags & VIR_DOMAIN_START_AUTODESTROY)); virDomainAuditStart(vm, "booted", ret >= 0); if (ret == 0) - event = virDomainEventNewFromObj(vm, + event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index cfb2ca0..6e930ee 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -6985,7 +6985,7 @@ vboxCallbackOnMachineStateChange(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED, detail = VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN; } - ev = virDomainEventNewFromDom(dom, event, detail); + ev = virDomainEventLifecycleNewFromDom(dom, event, detail); if (ev) virObjectEventStateQueue(g_pVBoxGlobalData->domainEvents, ev); @@ -7089,7 +7089,7 @@ vboxCallbackOnMachineRegistered(IVirtualBoxCallback *pThis ATTRIBUTE_UNUSED, detail = VIR_DOMAIN_EVENT_UNDEFINED_REMOVED; } - ev = virDomainEventNewFromDom(dom, event, detail); + ev = virDomainEventLifecycleNewFromDom(dom, event, detail); if (ev) virObjectEventStateQueue(g_pVBoxGlobalData->domainEvents, ev); diff --git a/src/xen/xen_inotify.c b/src/xen/xen_inotify.c index 755be8f..defbe44 100644 --- a/src/xen/xen_inotify.c +++ b/src/xen/xen_inotify.c @@ -148,7 +148,7 @@ xenInotifyDomainEventFromFile(virConnectPtr conn, if (xenInotifyDomainLookup(conn, filename, &name, uuid) < 0) return NULL; - event = virDomainEventNew(-1, name, uuid, type, detail); + event = virDomainEventLifecycleNew(-1, name, uuid, type, detail); VIR_FREE(name); return event; } diff --git a/src/xen/xs_internal.c b/src/xen/xs_internal.c index 9748a77..c12e123 100644 --- a/src/xen/xs_internal.c +++ b/src/xen/xs_internal.c @@ -849,9 +849,9 @@ retry: continue; } - event = virDomainEventNew(new_domids[i], name, uuid, - VIR_DOMAIN_EVENT_STARTED, - VIR_DOMAIN_EVENT_STARTED_BOOTED); + event = virDomainEventLifecycleNew(new_domids[i], name, uuid, + VIR_DOMAIN_EVENT_STARTED, + VIR_DOMAIN_EVENT_STARTED_BOOTED); if (event) xenUnifiedDomainEventDispatch(priv, event); @@ -919,11 +919,11 @@ retry: if (!found) { virDomainEventPtr event = - virDomainEventNew(-1, - priv->activeDomainList->doms[j]->name, - priv->activeDomainList->doms[j]->uuid, - VIR_DOMAIN_EVENT_STOPPED, - VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); + virDomainEventLifecycleNew(-1, + priv->activeDomainList->doms[j]->name, + priv->activeDomainList->doms[j]->uuid, + VIR_DOMAIN_EVENT_STOPPED, + VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); if (event) xenUnifiedDomainEventDispatch(priv, event); -- 1.8.4.2
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
--- src/conf/domain_event.c | 53 +++++++++++++++++++++++++++++++++++-------------- src/conf/domain_event.h | 4 ++-- 2 files changed, 40 insertions(+), 17 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 07c8100..31699b1 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -81,9 +81,11 @@ struct _virObjectEventCallback { static virClassPtr virObjectEventClass; static virClassPtr virDomainEventClass; static virClassPtr virDomainEventLifecycleClass; +static virClassPtr virDomainEventRTCChangeClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); +static void virDomainEventRTCChangeDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -97,9 +99,6 @@ struct _virDomainEvent { union { struct { - long long offset; - } rtcChange; - struct { int action; } watchdog; struct { @@ -149,6 +148,13 @@ struct _virDomainEventLifecycle { typedef struct _virDomainEventLifecycle virDomainEventLifecycle; typedef virDomainEventLifecycle *virDomainEventLifecyclePtr; +struct _virDomainEventRTCChange { + virDomainEvent parent; + + long long offset; +}; +typedef struct _virDomainEventRTCChange virDomainEventRTCChange; +typedef virDomainEventRTCChange *virDomainEventRTCChangePtr; static int virObjectEventOnceInit(void) { @@ -168,6 +174,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventLifecycle), virDomainEventLifecycleDispose))) return -1; + if (!(virDomainEventRTCChangeClass = virClassNew( + virDomainEventClass, + "virDomainEventRTCChange", + sizeof(virDomainEventRTCChange), + virDomainEventRTCChangeDispose))) + return -1; return 0; } @@ -257,6 +269,12 @@ static void virDomainEventLifecycleDispose(void *obj) VIR_DEBUG("obj=%p", event); } +static void virDomainEventRTCChangeDispose(void *obj) +{ + virDomainEventRTCChangePtr event = obj; + VIR_DEBUG("obj=%p", event); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -854,38 +872,38 @@ virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) obj->def->id, obj->def->name, obj->def->uuid); } -virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, +void *virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset) { - virDomainEventPtr ev; + virDomainEventRTCChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventRTCChangeClass, VIR_DOMAIN_EVENT_ID_RTC_CHANGE, dom->id, dom->name, dom->uuid))) return NULL; - ev->data.rtcChange.offset = offset; + ev->offset = offset; return ev; } -virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, +void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset) { - virDomainEventPtr ev; + virDomainEventRTCChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventRTCChangeClass, VIR_DOMAIN_EVENT_ID_RTC_CHANGE, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - ev->data.rtcChange.offset = offset; + ev->offset = offset; return ev; } @@ -1495,10 +1513,15 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, goto cleanup; case VIR_DOMAIN_EVENT_ID_RTC_CHANGE: - ((virConnectDomainEventRTCChangeCallback)cb)(conn, dom, - event->data.rtcChange.offset, - cbopaque); - goto cleanup; + { + virDomainEventRTCChangePtr rtcChangeEvent; + + rtcChangeEvent = (virDomainEventRTCChangePtr)event; + ((virConnectDomainEventRTCChangeCallback)cb)(conn, dom, + rtcChangeEvent->offset, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_WATCHDOG: ((virConnectDomainEventWatchdogCallback)cb)(conn, dom, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 2349b54..7c16a48 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -69,8 +69,8 @@ virDomainEventPtr virDomainEventRebootNew(int id, const char *name, const unsign virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom); virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj); -virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset); -virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset); +void *virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset); +void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset); virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action); virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action); -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:18:48PM +0100, Cédric Bosdonnat wrote:
--- src/conf/domain_event.c | 53 +++++++++++++++++++++++++++++++++++-------------- src/conf/domain_event.h | 4 ++-- 2 files changed, 40 insertions(+), 17 deletions(-) diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 2349b54..7c16a48 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -69,8 +69,8 @@ virDomainEventPtr virDomainEventRebootNew(int id, const char *name, const unsign virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom); virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset); -virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset); +void *virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset); +void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset);
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 | 56 ++++++++++++++++++++++++++++++++++--------------- src/conf/domain_event.h | 4 ++-- 2 files changed, 41 insertions(+), 19 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 31699b1..8d08d2f 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -82,10 +82,12 @@ static virClassPtr virObjectEventClass; static virClassPtr virDomainEventClass; static virClassPtr virDomainEventLifecycleClass; static virClassPtr virDomainEventRTCChangeClass; +static virClassPtr virDomainEventWatchdogClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); static void virDomainEventRTCChangeDispose(void *obj); +static void virDomainEventWatchdogDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -99,9 +101,6 @@ struct _virDomainEvent { union { struct { - int action; - } watchdog; - struct { char *srcPath; char *devAlias; int action; @@ -156,6 +155,14 @@ struct _virDomainEventRTCChange { typedef struct _virDomainEventRTCChange virDomainEventRTCChange; typedef virDomainEventRTCChange *virDomainEventRTCChangePtr; +struct _virDomainEventWatchdog { + virDomainEvent parent; + + int action; +}; +typedef struct _virDomainEventWatchdog virDomainEventWatchdog; +typedef virDomainEventWatchdog *virDomainEventWatchdogPtr; + static int virObjectEventOnceInit(void) { if (!(virObjectEventClass = virClassNew(virClassForObject(), @@ -180,6 +187,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventRTCChange), virDomainEventRTCChangeDispose))) return -1; + if (!(virDomainEventWatchdogClass = virClassNew( + virDomainEventClass, + "virDomainEventWatchdog", + sizeof(virDomainEventWatchdog), + virDomainEventWatchdogDispose))) + return -1; return 0; } @@ -275,6 +288,12 @@ static void virDomainEventRTCChangeDispose(void *obj) VIR_DEBUG("obj=%p", event); } +static void virDomainEventWatchdogDispose(void *obj) +{ + virDomainEventWatchdogPtr event = obj; + VIR_DEBUG("obj=%p", event); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -908,38 +927,36 @@ void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, return ev; } -virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, - int action) +void *virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action) { - virDomainEventPtr ev; + virDomainEventWatchdogPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventWatchdogClass, VIR_DOMAIN_EVENT_ID_WATCHDOG, dom->id, dom->name, dom->uuid))) return NULL; - ev->data.watchdog.action = action; + ev->action = action; return ev; } -virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, - int action) +void *virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action) { - virDomainEventPtr ev; + virDomainEventWatchdogPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventWatchdogClass, VIR_DOMAIN_EVENT_ID_WATCHDOG, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - ev->data.watchdog.action = action; + ev->action = action; return ev; } @@ -1524,10 +1541,15 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, } case VIR_DOMAIN_EVENT_ID_WATCHDOG: - ((virConnectDomainEventWatchdogCallback)cb)(conn, dom, - event->data.watchdog.action, - cbopaque); - goto cleanup; + { + virDomainEventWatchdogPtr watchdogEvent; + + watchdogEvent = (virDomainEventWatchdogPtr)event; + ((virConnectDomainEventWatchdogCallback)cb)(conn, dom, + watchdogEvent->action, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_IO_ERROR: ((virConnectDomainEventIOErrorCallback)cb)(conn, dom, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 7c16a48..b51ec97 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -72,8 +72,8 @@ virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj); void *virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset); void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset); -virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action); -virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action); +void *virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action); +void *virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action); virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom, const char *srcPath, -- 1.8.4.2
--- 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 | 148 +++++++++++++++++++++++++++--------------------- src/conf/domain_event.h | 24 ++++---- 2 files changed, 97 insertions(+), 75 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 21494e5..dea8729 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -84,12 +84,14 @@ static virClassPtr virDomainEventLifecycleClass; static virClassPtr virDomainEventRTCChangeClass; static virClassPtr virDomainEventWatchdogClass; static virClassPtr virDomainEventIOErrorClass; +static virClassPtr virDomainEventGraphicsClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); static void virDomainEventRTCChangeDispose(void *obj); static void virDomainEventWatchdogDispose(void *obj); static void virDomainEventIOErrorDispose(void *obj); +static void virDomainEventGraphicsDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -103,13 +105,6 @@ struct _virDomainEvent { union { struct { - int phase; - virDomainEventGraphicsAddressPtr local; - virDomainEventGraphicsAddressPtr remote; - char *authScheme; - virDomainEventGraphicsSubjectPtr subject; - } graphics; - struct { char *path; int type; int status; @@ -170,6 +165,18 @@ struct _virDomainEventIOError { typedef struct _virDomainEventIOError virDomainEventIOError; typedef virDomainEventIOError *virDomainEventIOErrorPtr; +struct _virDomainEventGraphics { + virDomainEvent parent; + + int phase; + virDomainEventGraphicsAddressPtr local; + virDomainEventGraphicsAddressPtr remote; + char *authScheme; + virDomainEventGraphicsSubjectPtr subject; +}; +typedef struct _virDomainEventGraphics virDomainEventGraphics; +typedef virDomainEventGraphics *virDomainEventGraphicsPtr; + static int virObjectEventOnceInit(void) { if (!(virObjectEventClass = virClassNew(virClassForObject(), @@ -206,6 +213,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventIOError), virDomainEventIOErrorDispose))) return -1; + if (!(virDomainEventGraphicsClass = virClassNew( + virDomainEventClass, + "virDomainEventGraphics", + sizeof(virDomainEventGraphics), + virDomainEventGraphicsDispose))) + return -1; return 0; } @@ -241,28 +254,6 @@ static void virDomainEventDispose(void *obj) switch (virObjectEventGetEventID(event)) { - case VIR_DOMAIN_EVENT_ID_GRAPHICS: - if (event->data.graphics.local) { - VIR_FREE(event->data.graphics.local->node); - VIR_FREE(event->data.graphics.local->service); - VIR_FREE(event->data.graphics.local); - } - if (event->data.graphics.remote) { - VIR_FREE(event->data.graphics.remote->node); - VIR_FREE(event->data.graphics.remote->service); - VIR_FREE(event->data.graphics.remote); - } - VIR_FREE(event->data.graphics.authScheme); - if (event->data.graphics.subject) { - size_t i; - for (i = 0; i < event->data.graphics.subject->nidentity; i++) { - VIR_FREE(event->data.graphics.subject->identities[i].type); - VIR_FREE(event->data.graphics.subject->identities[i].name); - } - VIR_FREE(event->data.graphics.subject); - } - break; - case VIR_DOMAIN_EVENT_ID_BLOCK_JOB: VIR_FREE(event->data.blockJob.path); break; @@ -311,6 +302,32 @@ static void virDomainEventIOErrorDispose(void *obj) VIR_FREE(event->reason); } +static void virDomainEventGraphicsDispose(void *obj) +{ + virDomainEventGraphicsPtr event = obj; + VIR_DEBUG("obj=%p", event); + + if (event->local) { + VIR_FREE(event->local->node); + VIR_FREE(event->local->service); + VIR_FREE(event->local); + } + if (event->remote) { + VIR_FREE(event->remote->node); + VIR_FREE(event->remote->service); + VIR_FREE(event->remote); + } + VIR_FREE(event->authScheme); + if (event->subject) { + size_t i; + for (i = 0; i < event->subject->nidentity; i++) { + VIR_FREE(event->subject->identities[i].type); + VIR_FREE(event->subject->identities[i].name); + } + VIR_FREE(event->subject); + } +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1076,61 +1093,61 @@ void *virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, } -virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, - int phase, - virDomainEventGraphicsAddressPtr local, - virDomainEventGraphicsAddressPtr remote, - const char *authScheme, - virDomainEventGraphicsSubjectPtr subject) +void *virDomainEventGraphicsNewFromDom(virDomainPtr dom, + int phase, + virDomainEventGraphicsAddressPtr local, + virDomainEventGraphicsAddressPtr remote, + const char *authScheme, + virDomainEventGraphicsSubjectPtr subject) { - virDomainEventPtr ev; + virDomainEventGraphicsPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventGraphicsClass, VIR_DOMAIN_EVENT_ID_GRAPHICS, dom->id, dom->name, dom->uuid))) return NULL; - ev->data.graphics.phase = phase; - if (VIR_STRDUP(ev->data.graphics.authScheme, authScheme) < 0) { + ev->phase = phase; + if (VIR_STRDUP(ev->authScheme, authScheme) < 0) { virObjectUnref(ev); return NULL; } - ev->data.graphics.local = local; - ev->data.graphics.remote = remote; - ev->data.graphics.subject = subject; + ev->local = local; + ev->remote = remote; + ev->subject = subject; return ev; } -virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, - int phase, - virDomainEventGraphicsAddressPtr local, - virDomainEventGraphicsAddressPtr remote, - const char *authScheme, - virDomainEventGraphicsSubjectPtr subject) +void *virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, + int phase, + virDomainEventGraphicsAddressPtr local, + virDomainEventGraphicsAddressPtr remote, + const char *authScheme, + virDomainEventGraphicsSubjectPtr subject) { - virDomainEventPtr ev; + virDomainEventGraphicsPtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventGraphicsClass, VIR_DOMAIN_EVENT_ID_GRAPHICS, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - ev->data.graphics.phase = phase; - if (VIR_STRDUP(ev->data.graphics.authScheme, authScheme) < 0) { + ev->phase = phase; + if (VIR_STRDUP(ev->authScheme, authScheme) < 0) { virObjectUnref(ev); return NULL; } - ev->data.graphics.local = local; - ev->data.graphics.remote = remote; - ev->data.graphics.subject = subject; + ev->local = local; + ev->remote = remote; + ev->subject = subject; return ev; } @@ -1596,14 +1613,19 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, } case VIR_DOMAIN_EVENT_ID_GRAPHICS: - ((virConnectDomainEventGraphicsCallback)cb)(conn, dom, - event->data.graphics.phase, - event->data.graphics.local, - event->data.graphics.remote, - event->data.graphics.authScheme, - event->data.graphics.subject, - cbopaque); - goto cleanup; + { + virDomainEventGraphicsPtr graphicsEvent; + + graphicsEvent = (virDomainEventGraphicsPtr)event; + ((virConnectDomainEventGraphicsCallback)cb)(conn, dom, + graphicsEvent->phase, + graphicsEvent->local, + graphicsEvent->remote, + graphicsEvent->authScheme, + graphicsEvent->subject, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_CONTROL_ERROR: (cb)(conn, dom, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 45819dc..c7b0347 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -94,18 +94,18 @@ void *virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj, int action, const char *reason); -virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom, - int phase, - virDomainEventGraphicsAddressPtr local, - virDomainEventGraphicsAddressPtr remote, - const char *authScheme, - virDomainEventGraphicsSubjectPtr subject); -virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, - int phase, - virDomainEventGraphicsAddressPtr local, - virDomainEventGraphicsAddressPtr remote, - const char *authScheme, - virDomainEventGraphicsSubjectPtr subject); +void *virDomainEventGraphicsNewFromDom(virDomainPtr dom, + int phase, + virDomainEventGraphicsAddressPtr local, + virDomainEventGraphicsAddressPtr remote, + const char *authScheme, + virDomainEventGraphicsSubjectPtr subject); +void *virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, + int phase, + virDomainEventGraphicsAddressPtr local, + virDomainEventGraphicsAddressPtr remote, + const char *authScheme, + virDomainEventGraphicsSubjectPtr subject); virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom); virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj); -- 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 | 105 ++++++++++++++++++++++++++++++------------------ src/conf/domain_event.h | 20 ++++----- 2 files changed, 75 insertions(+), 50 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 5d56fe5..8497b9a 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -86,6 +86,8 @@ static virClassPtr virDomainEventWatchdogClass; static virClassPtr virDomainEventIOErrorClass; static virClassPtr virDomainEventGraphicsClass; static virClassPtr virDomainEventBlockJobClass; +static virClassPtr virDomainEventDiskChangeClass; + static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); @@ -94,6 +96,7 @@ static void virDomainEventWatchdogDispose(void *obj); static void virDomainEventIOErrorDispose(void *obj); static void virDomainEventGraphicsDispose(void *obj); static void virDomainEventBlockJobDispose(void *obj); +static void virDomainEventDiskChangeDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -107,12 +110,6 @@ struct _virDomainEvent { union { struct { - char *oldSrcPath; - char *newSrcPath; - char *devAlias; - int reason; - } diskChange; - struct { char *devAlias; int reason; } trayChange; @@ -184,6 +181,18 @@ struct _virDomainEventGraphics { typedef struct _virDomainEventGraphics virDomainEventGraphics; typedef virDomainEventGraphics *virDomainEventGraphicsPtr; +struct _virDomainEventDiskChange { + virDomainEvent parent; + + char *oldSrcPath; + char *newSrcPath; + char *devAlias; + int reason; +}; +typedef struct _virDomainEventDiskChange virDomainEventDiskChange; +typedef virDomainEventDiskChange *virDomainEventDiskChangePtr; + + static int virObjectEventOnceInit(void) { if (!(virObjectEventClass = virClassNew(virClassForObject(), @@ -232,6 +241,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventBlockJob), virDomainEventBlockJobDispose))) return -1; + if (!(virDomainEventDiskChangeClass = virClassNew( + virDomainEventClass, + "virDomainEventDiskChange", + sizeof(virDomainEventDiskChange), + virDomainEventDiskChangeDispose))) + return -1; return 0; } @@ -267,11 +282,6 @@ static void virDomainEventDispose(void *obj) switch (virObjectEventGetEventID(event)) { - case VIR_DOMAIN_EVENT_ID_DISK_CHANGE: - VIR_FREE(event->data.diskChange.oldSrcPath); - VIR_FREE(event->data.diskChange.newSrcPath); - VIR_FREE(event->data.diskChange.devAlias); - break; case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE: VIR_FREE(event->data.trayChange.devAlias); break; @@ -345,6 +355,16 @@ static void virDomainEventBlockJobDispose(void *obj) VIR_FREE(event->path); } +static void virDomainEventDiskChangeDispose(void *obj) +{ + virDomainEventDiskChangePtr event = obj; + VIR_DEBUG("obj=%p", event); + + VIR_FREE(event->oldSrcPath); + VIR_FREE(event->newSrcPath); + VIR_FREE(event->devAlias); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1241,33 +1261,33 @@ virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) return ev; } -static virDomainEventPtr -virDomainEventDiskChangeNew(int id, const char *name, - unsigned char *uuid, - const char *oldSrcPath, - const char *newSrcPath, - const char *devAlias, int reason) +static +void *virDomainEventDiskChangeNew(int id, const char *name, + unsigned char *uuid, + const char *oldSrcPath, + const char *newSrcPath, + const char *devAlias, int reason) { - virDomainEventPtr ev; + virDomainEventDiskChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventDiskChangeClass, VIR_DOMAIN_EVENT_ID_DISK_CHANGE, id, name, uuid))) return NULL; - if (VIR_STRDUP(ev->data.diskChange.devAlias, devAlias) < 0) + if (VIR_STRDUP(ev->devAlias, devAlias) < 0) goto error; - if (VIR_STRDUP(ev->data.diskChange.oldSrcPath, oldSrcPath) < 0) + if (VIR_STRDUP(ev->oldSrcPath, oldSrcPath) < 0) goto error; - if (VIR_STRDUP(ev->data.diskChange.newSrcPath, newSrcPath) < 0) + if (VIR_STRDUP(ev->newSrcPath, newSrcPath) < 0) goto error; - ev->data.diskChange.reason = reason; + ev->reason = reason; return ev; @@ -1276,22 +1296,22 @@ error: return NULL; } -virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj, - const char *oldSrcPath, - const char *newSrcPath, - const char *devAlias, - int reason) +void *virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj, + const char *oldSrcPath, + const char *newSrcPath, + const char *devAlias, + int reason) { return virDomainEventDiskChangeNew(obj->def->id, obj->def->name, obj->def->uuid, oldSrcPath, newSrcPath, devAlias, reason); } -virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom, - const char *oldSrcPath, - const char *newSrcPath, - const char *devAlias, - int reason) +void *virDomainEventDiskChangeNewFromDom(virDomainPtr dom, + const char *oldSrcPath, + const char *newSrcPath, + const char *devAlias, + int reason) { return virDomainEventDiskChangeNew(dom->id, dom->name, dom->uuid, oldSrcPath, newSrcPath, @@ -1663,13 +1683,18 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, } case VIR_DOMAIN_EVENT_ID_DISK_CHANGE: - ((virConnectDomainEventDiskChangeCallback)cb)(conn, dom, - event->data.diskChange.oldSrcPath, - event->data.diskChange.newSrcPath, - event->data.diskChange.devAlias, - event->data.diskChange.reason, - cbopaque); - goto cleanup; + { + virDomainEventDiskChangePtr diskChangeEvent; + + diskChangeEvent = (virDomainEventDiskChangePtr)event; + ((virConnectDomainEventDiskChangeCallback)cb)(conn, dom, + diskChangeEvent->oldSrcPath, + diskChangeEvent->newSrcPath, + diskChangeEvent->devAlias, + diskChangeEvent->reason, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE: ((virConnectDomainEventTrayChangeCallback)cb)(conn, dom, diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 1aa1455..965af57 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -118,16 +118,16 @@ void *virDomainEventBlockJobNewFromDom(virDomainPtr dom, int type, int status); -virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj, - const char *oldSrcPath, - const char *newSrcPath, - const char *devAlias, - int reason); -virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom, - const char *oldSrcPath, - const char *newSrcPath, - const char *devAlias, - int reason); +void *virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj, + const char *oldSrcPath, + const char *newSrcPath, + const char *devAlias, + int reason); +void *virDomainEventDiskChangeNewFromDom(virDomainPtr dom, + const char *oldSrcPath, + const char *newSrcPath, + const char *devAlias, + int reason); virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, const char *devAlias, int reason); -- 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
--- src/conf/domain_event.c | 60 ++++++++++++++++++++++++++++++++++--------------- src/conf/domain_event.h | 4 ++-- 2 files changed, 44 insertions(+), 20 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 24291b9..ac7828e 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -88,6 +88,7 @@ static virClassPtr virDomainEventGraphicsClass; static virClassPtr virDomainEventBlockJobClass; static virClassPtr virDomainEventDiskChangeClass; static virClassPtr virDomainEventTrayChangeClass; +static virClassPtr virDomainEventBalloonChangeClass; static void virObjectEventDispose(void *obj); static void virDomainEventDispose(void *obj); @@ -99,6 +100,7 @@ static void virDomainEventGraphicsDispose(void *obj); static void virDomainEventBlockJobDispose(void *obj); static void virDomainEventDiskChangeDispose(void *obj); static void virDomainEventTrayChangeDispose(void *obj); +static void virDomainEventBalloonChangeDispose(void *obj); struct _virObjectEvent { virObject parent; @@ -112,10 +114,6 @@ struct _virDomainEvent { union { struct { - /* In unit of 1024 bytes */ - unsigned long long actual; - } balloonChange; - struct { char *devAlias; } deviceRemoved; } data; @@ -199,6 +197,15 @@ struct _virDomainEventTrayChange { typedef struct _virDomainEventTrayChange virDomainEventTrayChange; typedef virDomainEventTrayChange *virDomainEventTrayChangePtr; +struct _virDomainEventBalloonChange { + virDomainEvent parent; + + /* In unit of 1024 bytes */ + unsigned long long actual; +}; +typedef struct _virDomainEventBalloonChange virDomainEventBalloonChange; +typedef virDomainEventBalloonChange *virDomainEventBalloonChangePtr; + static int virObjectEventOnceInit(void) { @@ -260,6 +267,12 @@ static int virObjectEventOnceInit(void) sizeof(virDomainEventTrayChange), virDomainEventTrayChangeDispose))) return -1; + if (!(virDomainEventBalloonChangeClass = virClassNew( + virDomainEventClass, + "virDomainEventBalloonChange", + sizeof(virDomainEventBalloonChange), + virDomainEventBalloonChangeDispose))) + return -1; return 0; } @@ -383,6 +396,12 @@ static void virDomainEventTrayChangeDispose(void *obj) VIR_FREE(event->devAlias); } +static void virDomainEventBalloonChangeDispose(void *obj) +{ + virDomainEventBalloonChangePtr event = obj; + VIR_DEBUG("obj=%p", event); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -1475,37 +1494,37 @@ virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom) return virDomainEventPMSuspendDiskNew(dom->id, dom->name, dom->uuid); } -virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, - unsigned long long actual) +void *virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, + unsigned long long actual) { - virDomainEventPtr ev; + virDomainEventBalloonChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventBalloonChangeClass, VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, dom->id, dom->name, dom->uuid))) return NULL; - ev->data.balloonChange.actual = actual; + ev->actual = actual; return ev; } -virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, - unsigned long long actual) +void *virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, + unsigned long long actual) { - virDomainEventPtr ev; + virDomainEventBalloonChangePtr ev; if (virObjectEventInitialize() < 0) return NULL; - if (!(ev = virDomainEventNew(virDomainEventClass, + if (!(ev = virDomainEventNew(virDomainEventBalloonChangeClass, VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, obj->def->id, obj->def->name, obj->def->uuid))) return NULL; - ev->data.balloonChange.actual = actual; + ev->actual = actual; return ev; } @@ -1735,10 +1754,15 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, goto cleanup; case VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE: - ((virConnectDomainEventBalloonChangeCallback)cb)(conn, dom, - event->data.balloonChange.actual, - cbopaque); - goto cleanup; + { + virDomainEventBalloonChangePtr balloonChangeEvent; + + balloonChangeEvent = (virDomainEventBalloonChangePtr)event; + ((virConnectDomainEventBalloonChangeCallback)cb)(conn, dom, + balloonChangeEvent->actual, + cbopaque); + goto cleanup; + } case VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK: ((virConnectDomainEventPMSuspendDiskCallback)cb)(conn, dom, 0, cbopaque); diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 5a684eb..f4a344c 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -139,8 +139,8 @@ virDomainEventPtr virDomainEventPMWakeupNewFromDom(virDomainPtr dom); virDomainEventPtr virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj); virDomainEventPtr virDomainEventPMSuspendNewFromDom(virDomainPtr dom); -virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual); -virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual); +void *virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual); +void *virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual); virDomainEventPtr virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj); virDomainEventPtr virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom); -- 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
for consistency with other functions --- src/conf/domain_event.c | 43 +++++++++++++++++-------------------------- src/conf/domain_event.h | 22 +++++++++++----------- 2 files changed, 28 insertions(+), 37 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 4bd81d9..7694fcc 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -979,7 +979,7 @@ void *virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detai type, detail); } -virDomainEventPtr virDomainEventRebootNew(int id, const char *name, +void *virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid) { if (virObjectEventInitialize() < 0) @@ -990,7 +990,7 @@ virDomainEventPtr virDomainEventRebootNew(int id, const char *name, id, name, uuid); } -virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom) +void *virDomainEventRebootNewFromDom(virDomainPtr dom) { if (virObjectEventInitialize() < 0) return NULL; @@ -1000,7 +1000,7 @@ virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom) dom->id, dom->name, dom->uuid); } -virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj) +void *virDomainEventRebootNewFromObj(virDomainObjPtr obj) { if (virObjectEventInitialize() < 0) return NULL; @@ -1279,7 +1279,7 @@ void *virDomainEventBlockJobNewFromDom(virDomainPtr dom, path, type, status); } -virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom) +void *virDomainEventControlErrorNewFromDom(virDomainPtr dom) { virDomainEventPtr ev; @@ -1294,7 +1294,7 @@ virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom) } -virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) +void *virDomainEventControlErrorNewFromObj(virDomainObjPtr obj) { virDomainEventPtr ev; @@ -1413,9 +1413,8 @@ void *virDomainEventTrayChangeNewFromDom(virDomainPtr dom, devAlias, reason); } -static virDomainEventPtr -virDomainEventPMWakeupNew(int id, const char *name, - unsigned char *uuid) +static void *virDomainEventPMWakeupNew(int id, const char *name, + unsigned char *uuid) { virDomainEventPtr ev; @@ -1430,23 +1429,20 @@ virDomainEventPMWakeupNew(int id, const char *name, return ev; } -virDomainEventPtr -virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj) +void *virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj) { return virDomainEventPMWakeupNew(obj->def->id, obj->def->name, obj->def->uuid); } -virDomainEventPtr -virDomainEventPMWakeupNewFromDom(virDomainPtr dom) +void *virDomainEventPMWakeupNewFromDom(virDomainPtr dom) { return virDomainEventPMWakeupNew(dom->id, dom->name, dom->uuid); } -static virDomainEventPtr -virDomainEventPMSuspendNew(int id, const char *name, - unsigned char *uuid) +static void *virDomainEventPMSuspendNew(int id, const char *name, + unsigned char *uuid) { virDomainEventPtr ev; @@ -1461,23 +1457,20 @@ virDomainEventPMSuspendNew(int id, const char *name, return ev; } -virDomainEventPtr -virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj) +void *virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj) { return virDomainEventPMSuspendNew(obj->def->id, obj->def->name, obj->def->uuid); } -virDomainEventPtr -virDomainEventPMSuspendNewFromDom(virDomainPtr dom) +void *virDomainEventPMSuspendNewFromDom(virDomainPtr dom) { return virDomainEventPMSuspendNew(dom->id, dom->name, dom->uuid); } -static virDomainEventPtr -virDomainEventPMSuspendDiskNew(int id, const char *name, - unsigned char *uuid) +static void *virDomainEventPMSuspendDiskNew(int id, const char *name, + unsigned char *uuid) { virDomainEventPtr ev; @@ -1491,16 +1484,14 @@ virDomainEventPMSuspendDiskNew(int id, const char *name, return ev; } -virDomainEventPtr -virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj) +void *virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj) { return virDomainEventPMSuspendDiskNew(obj->def->id, obj->def->name, obj->def->uuid); } -virDomainEventPtr -virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom) +void *virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom) { return virDomainEventPMSuspendDiskNew(dom->id, dom->name, dom->uuid); } diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index f13c716..06443a0 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -65,9 +65,9 @@ void *virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detail); -virDomainEventPtr virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid); -virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom); -virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj); +void *virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid); +void *virDomainEventRebootNewFromDom(virDomainPtr dom); +void *virDomainEventRebootNewFromObj(virDomainObjPtr obj); void *virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset); void *virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset); @@ -106,8 +106,8 @@ void *virDomainEventGraphicsNewFromObj(virDomainObjPtr obj, virDomainEventGraphicsAddressPtr remote, const char *authScheme, virDomainEventGraphicsSubjectPtr subject); -virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom); -virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj); +void *virDomainEventControlErrorNewFromDom(virDomainPtr dom); +void *virDomainEventControlErrorNewFromObj(virDomainObjPtr obj); void *virDomainEventBlockJobNewFromObj(virDomainObjPtr obj, const char *path, @@ -134,16 +134,16 @@ void *virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, void *virDomainEventTrayChangeNewFromDom(virDomainPtr dom, const char *devAlias, int reason); -virDomainEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj); -virDomainEventPtr virDomainEventPMWakeupNewFromDom(virDomainPtr dom); -virDomainEventPtr virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj); -virDomainEventPtr virDomainEventPMSuspendNewFromDom(virDomainPtr dom); +void *virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj); +void *virDomainEventPMWakeupNewFromDom(virDomainPtr dom); +void *virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj); +void *virDomainEventPMSuspendNewFromDom(virDomainPtr dom); void *virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual); void *virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual); -virDomainEventPtr virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj); -virDomainEventPtr virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom); +void *virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj); +void *virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom); void *virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, const char *devAlias); -- 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, Nov 29, 2013 at 04:18:58PM +0100, Cédric Bosdonnat wrote:
The virDomainEvent class wasn't defining anything special, thus it has been dropped.
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
@@ -107,16 +105,11 @@ static void virDomainEventDeviceRemovedDispose(void *obj); struct _virObjectEvent { virObject parent; int eventID; -}; - -struct _virDomainEvent { - virObjectEvent parent; - virObjectMeta meta; };
Ok, so you're merging virObjectMeta into the parent class. I understand why you want to keep a single set of metadata for all object types. This does mostly work. We should be aware of the fact that different objects have a different set of valid attributes - virDomainPtr - id, name, uuid - virNetworkPtr - name, uuid - virStoragePoolPtr - name, uuid - virInterfacePtr - name - virSecretPtr - uuid - virNodeDevicePtr - name - virNWfilterPtr - name, uuid Even if we don't store any custom data in the virDomainEvent class its existance does tell you information about the metadata attributes that are valid for this class. Even if we don't use it right now, this feels like a useful class representation to have available. 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, 2013-11-29 at 17:18 +0000, Daniel P. Berrange wrote:
On Fri, Nov 29, 2013 at 04:18:58PM +0100, Cédric Bosdonnat wrote:
The virDomainEvent class wasn't defining anything special, thus it has been dropped.
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
@@ -107,16 +105,11 @@ static void virDomainEventDeviceRemovedDispose(void *obj); struct _virObjectEvent { virObject parent; int eventID; -}; - -struct _virDomainEvent { - virObjectEvent parent; - virObjectMeta meta; };
Ok, so you're merging virObjectMeta into the parent class. I understand why you want to keep a single set of metadata for all object types. This does mostly work. We should be aware of the fact that different objects have a different set of valid attributes
- virDomainPtr - id, name, uuid - virNetworkPtr - name, uuid - virStoragePoolPtr - name, uuid - virInterfacePtr - name - virSecretPtr - uuid - virNodeDevicePtr - name - virNWfilterPtr - name, uuid
In most of the cases, the uuid is used for the filtering... but that can be improved later for virInterfacePtr and virInterfacePtr.
Even if we don't store any custom data in the virDomainEvent class its existance does tell you information about the metadata attributes that are valid for this class. Even if we don't use it right now, this feels like a useful class representation to have available.
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
On Mon, Dec 02, 2013 at 01:50:58PM +0100, Cedric Bosdonnat wrote:
On Fri, 2013-11-29 at 17:18 +0000, Daniel P. Berrange wrote:
On Fri, Nov 29, 2013 at 04:18:58PM +0100, Cédric Bosdonnat wrote:
The virDomainEvent class wasn't defining anything special, thus it has been dropped.
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
@@ -107,16 +105,11 @@ static void virDomainEventDeviceRemovedDispose(void *obj); struct _virObjectEvent { virObject parent; int eventID; -}; - -struct _virDomainEvent { - virObjectEvent parent; - virObjectMeta meta; };
Ok, so you're merging virObjectMeta into the parent class. I understand why you want to keep a single set of metadata for all object types. This does mostly work. We should be aware of the fact that different objects have a different set of valid attributes
- virDomainPtr - id, name, uuid - virNetworkPtr - name, uuid - virStoragePoolPtr - name, uuid - virInterfacePtr - name - virSecretPtr - uuid - virNodeDevicePtr - name - virNWfilterPtr - name, uuid
In most of the cases, the uuid is used for the filtering... but that can be improved later for virInterfacePtr and virInterfacePtr.
Even if we don't store any custom data in the virDomainEvent class its existance does tell you information about the metadata attributes that are valid for this class. Even if we don't use it right now, this feels like a useful class representation to have available.
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?
Actually that check has caught quite a few bugs in the past so would rather not relax that. Just add a unused 'bool dummy' field to it. 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 :|
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
On Fri, Nov 29, 2013 at 04:18:59PM +0100, Cédric Bosdonnat wrote:
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;
I'm not sure I see why we need to expose this in the libvirt.h.in public header. Is it not sufficient to hide this in object_event.h instead ? 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 | 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
On Fri, Nov 29, 2013 at 04:19:00PM +0100, Cédric Bosdonnat wrote:
--- src/conf/domain_event.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
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 :|
--- 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 04:19:01PM +0100, Cédric Bosdonnat wrote:
--- 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)
Not sure I see the reason for have separate global initializers here. Feels like a single global initializers for all types of events should be fine. A single process is ultimately going to need all of them.. 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 05:21:21PM +0000, Daniel P. Berrange wrote:
On Fri, Nov 29, 2013 at 04:19:01PM +0100, Cédric Bosdonnat wrote:
--- 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)
Not sure I see the reason for have separate global initializers here. Feels like a single global initializers for all types of events should be fine. A single process is ultimately going to need all of them..
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 :|
--- src/Makefile.am | 6 + src/conf/domain_event.c | 806 +--------------------------------------- src/conf/domain_event.h | 70 +--- src/conf/object_event.c | 786 +++++++++++++++++++++++++++++++++++++++ src/conf/object_event.h | 96 +++++ src/conf/object_event_private.h | 113 ++++++ src/libvirt_private.syms | 15 +- 7 files changed, 1023 insertions(+), 869 deletions(-) create mode 100644 src/conf/object_event.c create mode 100644 src/conf/object_event.h create mode 100644 src/conf/object_event_private.h diff --git a/src/Makefile.am b/src/Makefile.am index 87f5101..a3ea55c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -241,6 +241,10 @@ DOMAIN_CONF_SOURCES = \ conf/domain_nwfilter.c conf/domain_nwfilter.h \ conf/snapshot_conf.c conf/snapshot_conf.h +OBJECT_EVENT_SOURCES = \ + conf/object_event.c conf/object_event.h \ + conf/object_event_private.h + DOMAIN_EVENT_SOURCES = \ conf/domain_event.c conf/domain_event.h @@ -292,6 +296,7 @@ DEVICE_CONF_SOURCES = \ CONF_SOURCES = \ $(NETDEV_CONF_SOURCES) \ $(DOMAIN_CONF_SOURCES) \ + $(OBJECT_EVENT_SOURCES) \ $(DOMAIN_EVENT_SOURCES) \ $(NETWORK_CONF_SOURCES) \ $(NWFILTER_CONF_SOURCES) \ @@ -2021,6 +2026,7 @@ libvirt_setuid_rpc_client_la_SOURCES = \ util/virutil.c \ util/viruuid.c \ conf/domain_event.c \ + conf/object_event.c \ rpc/virnetsocket.c \ rpc/virnetsocket.h \ rpc/virnetmessage.h \ diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 0c38352..a806ffa 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -3,6 +3,7 @@ * * Copyright (C) 2010-2013 Red Hat, Inc. * Copyright (C) 2008 VirtualIron + * 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 @@ -24,6 +25,8 @@ #include <config.h> #include "domain_event.h" +#include "object_event.h" +#include "object_event_private.h" #include "virlog.h" #include "datatypes.h" #include "viralloc.h" @@ -32,55 +35,6 @@ #define VIR_FROM_THIS VIR_FROM_NONE -#define VIR_OBJECT_EVENT_CALLBACK(cb) ((virConnectObjectEventGenericCallback)(cb)) - -struct _virObjectMeta { - int id; - char *name; - unsigned char uuid[VIR_UUID_BUFLEN]; -}; -typedef struct _virObjectMeta virObjectMeta; -typedef virObjectMeta *virObjectMetaPtr; - -struct _virObjectEventCallbackList { - unsigned int nextID; - unsigned int count; - virObjectEventCallbackPtr *callbacks; -}; - -struct _virObjectEventQueue { - unsigned int count; - virObjectEventPtr *events; -}; - -struct _virObjectEventState { - /* The list of domain event callbacks */ - virObjectEventCallbackListPtr callbacks; - /* The queue of object events */ - virObjectEventQueuePtr queue; - /* Timer for flushing events queue */ - int timer; - /* Flag if we're in process of dispatching */ - bool isDispatching; - virMutex lock; -}; - -struct _virObjectEventCallback { - int callbackID; - int eventID; - virConnectPtr conn; - virObjectMetaPtr meta; - virConnectObjectEventGenericCallback cb; - void *opaque; - virFreeCallback freecb; - int deleted; -}; - - - -static virClassPtr virObjectEventClass; -static virClassPtr virClassForObjectEvent(void); - static virClassPtr virDomainEventLifecycleClass; static virClassPtr virDomainEventRTCChangeClass; static virClassPtr virDomainEventWatchdogClass; @@ -92,7 +46,6 @@ static virClassPtr virDomainEventTrayChangeClass; static virClassPtr virDomainEventBalloonChangeClass; static virClassPtr virDomainEventDeviceRemovedClass; -static void virObjectEventDispose(void *obj); static void virDomainEventLifecycleDispose(void *obj); static void virDomainEventRTCChangeDispose(void *obj); static void virDomainEventWatchdogDispose(void *obj); @@ -104,11 +57,6 @@ static void virDomainEventTrayChangeDispose(void *obj); static void virDomainEventBalloonChangeDispose(void *obj); static void virDomainEventDeviceRemovedDispose(void *obj); -struct _virObjectEvent { - virObject parent; - int eventID; - virObjectMeta meta; -}; struct _virDomainEventLifecycle { virObjectEvent parent; @@ -206,25 +154,6 @@ typedef struct _virDomainEventDeviceRemoved virDomainEventDeviceRemoved; typedef virDomainEventDeviceRemoved *virDomainEventDeviceRemovedPtr; -static int virObjectEventOnceInit(void) -{ - if (!(virObjectEventClass = virClassNew(virClassForObject(), - "virObjectEvent", - 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( @@ -292,27 +221,6 @@ static int virDomainEventsOnceInit(void) VIR_ONCE_GLOBAL_INIT(virDomainEvents) -static int virObjectEventGetEventID(void *anyobj) -{ - virObjectEventPtr obj = anyobj; - - if (!virObjectIsClass(obj, virClassForObjectEvent())) { - 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); - - VIR_FREE(event->meta.name); -} - static void virDomainEventLifecycleDispose(void *obj) { virDomainEventLifecyclePtr event = obj; @@ -407,29 +315,6 @@ static void virDomainEventDeviceRemovedDispose(void *obj) VIR_FREE(event->devAlias); } -/** - * virObjectEventCallbackListFree: - * @list: event callback list head - * - * Free the memory in the domain event callback list - */ -static void -virObjectEventCallbackListFree(virObjectEventCallbackListPtr list) -{ - size_t i; - if (!list) - return; - - for (i=0; i<list->count; i++) { - virFreeCallback freecb = list->callbacks[i]->freecb; - if (freecb) - (*freecb)(list->callbacks[i]->opaque); - VIR_FREE(list->callbacks[i]); - } - VIR_FREE(list->callbacks); - VIR_FREE(list); -} - /** * virDomainEventCallbackListRemove: @@ -482,56 +367,6 @@ virDomainEventCallbackListRemove(virConnectPtr conn, } -/** - * virObjectEventCallbackListRemoveID: - * @conn: pointer to the connection - * @cbList: the list - * @callback: the callback to remove - * - * Internal function to remove a callback from a virObjectEventCallbackListPtr - */ -static int -virObjectEventCallbackListRemoveID(virConnectPtr conn, - virObjectEventCallbackListPtr cbList, - int callbackID) -{ - int ret = 0; - size_t i; - for (i = 0; i < cbList->count; i++) { - if (cbList->callbacks[i]->callbackID == callbackID && - cbList->callbacks[i]->conn == conn) { - virFreeCallback freecb = cbList->callbacks[i]->freecb; - if (freecb) - (*freecb)(cbList->callbacks[i]->opaque); - virObjectUnref(cbList->callbacks[i]->conn); - VIR_FREE(cbList->callbacks[i]); - - if (i < (cbList->count - 1)) - memmove(cbList->callbacks + i, - cbList->callbacks + i + 1, - sizeof(*(cbList->callbacks)) * - (cbList->count - (i + 1))); - - if (VIR_REALLOC_N(cbList->callbacks, - cbList->count - 1) < 0) { - ; /* Failure to reduce memory allocation isn't fatal */ - } - cbList->count--; - - for (i = 0; i < cbList->count; i++) { - if (!cbList->callbacks[i]->deleted) - ret++; - } - return ret; - } - } - - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("could not find event callback for removal")); - return -1; -} - - static int virDomainEventCallbackListMarkDelete(virConnectPtr conn, virObjectEventCallbackListPtr cbList, @@ -558,162 +393,6 @@ virDomainEventCallbackListMarkDelete(virConnectPtr conn, } -static int -virObjectEventCallbackListMarkDeleteID(virConnectPtr conn, - virObjectEventCallbackListPtr cbList, - int callbackID) -{ - int ret = 0; - size_t i; - for (i = 0; i < cbList->count; i++) { - if (cbList->callbacks[i]->callbackID == callbackID && - cbList->callbacks[i]->conn == conn) { - cbList->callbacks[i]->deleted = 1; - for (i = 0; i < cbList->count; i++) { - if (!cbList->callbacks[i]->deleted) - ret++; - } - return ret; - } - } - - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("could not find event callback for deletion")); - return -1; -} - - -static int -virObjectEventCallbackListPurgeMarked(virObjectEventCallbackListPtr cbList) -{ - int old_count = cbList->count; - int n; - for (n = 0; n < cbList->count; n++) { - if (cbList->callbacks[n]->deleted) { - virFreeCallback freecb = cbList->callbacks[n]->freecb; - if (freecb) - (*freecb)(cbList->callbacks[n]->opaque); - virObjectUnref(cbList->callbacks[n]->conn); - VIR_FREE(cbList->callbacks[n]); - - if (n < (cbList->count - 1)) - memmove(cbList->callbacks + n, - cbList->callbacks + n + 1, - sizeof(*(cbList->callbacks)) * - (cbList->count - (n + 1))); - cbList->count--; - n--; - } - } - if (cbList->count < old_count && - VIR_REALLOC_N(cbList->callbacks, cbList->count) < 0) { - ; /* Failure to reduce memory allocation isn't fatal */ - } - return 0; -} - - -/** - * virObjectEventCallbackListAddID: - * @conn: pointer to the connection - * @cbList: the list - * @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 virObjectEventCallbackListPtr - */ -static int -virObjectEventCallbackListAddID(virConnectPtr conn, - virObjectEventCallbackListPtr cbList, - unsigned char uuid[VIR_UUID_BUFLEN], - const char *name, - int id, - int eventID, - virConnectObjectEventGenericCallback callback, - void *opaque, - virFreeCallback freecb, - int *callbackID) -{ - virObjectEventCallbackPtr event; - size_t i; - int ret = 0; - - /* Check incoming */ - if (!cbList) { - return -1; - } - - /* check if we already have this callback on our list */ - for (i = 0; i < cbList->count; i++) { - if (cbList->callbacks[i]->cb == VIR_OBJECT_EVENT_CALLBACK(callback) && - cbList->callbacks[i]->eventID == eventID && - cbList->callbacks[i]->conn == conn && - ((uuid && cbList->callbacks[i]->meta && - memcmp(cbList->callbacks[i]->meta->uuid, - uuid, VIR_UUID_BUFLEN) == 0) || - (!uuid && !cbList->callbacks[i]->meta))) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("event callback already tracked")); - return -1; - } - } - /* Allocate new event */ - if (VIR_ALLOC(event) < 0) - goto error; - event->conn = conn; - event->cb = callback; - event->eventID = eventID; - event->opaque = opaque; - event->freecb = freecb; - - if (name && uuid && id > 0) { - if (VIR_ALLOC(event->meta) < 0) - goto error; - if (VIR_STRDUP(event->meta->name, name) < 0) - goto error; - memcpy(event->meta->uuid, uuid, VIR_UUID_BUFLEN); - event->meta->id = id; - } - - /* Make space on list */ - if (VIR_REALLOC_N(cbList->callbacks, cbList->count + 1) < 0) - goto error; - - virObjectRef(event->conn); - - cbList->callbacks[cbList->count] = event; - cbList->count++; - - event->callbackID = cbList->nextID++; - - for (i = 0; i < cbList->count; i++) { - if (cbList->callbacks[i]->eventID == eventID && - cbList->callbacks[i]->conn == conn && - !cbList->callbacks[i]->deleted) - ret++; - } - - if (callbackID) - *callbackID = event->callbackID; - - return ret; - -error: - if (event) { - if (event->meta) - VIR_FREE(event->meta->name); - VIR_FREE(event->meta); - } - VIR_FREE(event); - return -1; -} - - /** * virDomainEventCallbackListAdd: * @conn: pointer to the connection @@ -737,184 +416,6 @@ virDomainEventCallbackListAdd(virConnectPtr conn, } - -static int -virObjectEventCallbackListEventID(virConnectPtr conn, - virObjectEventCallbackListPtr cbList, - int callbackID) -{ - size_t i; - - for (i = 0; i < cbList->count; i++) { - if (cbList->callbacks[i]->deleted) - continue; - - if (cbList->callbacks[i]->callbackID == callbackID && - cbList->callbacks[i]->conn == conn) - return cbList->callbacks[i]->eventID; - } - - return -1; -} - - -/** - * virObjectEventQueueClear: - * @queue: pointer to the queue - * - * Removes all elements from the queue - */ -static void -virObjectEventQueueClear(virObjectEventQueuePtr queue) -{ - size_t i; - if (!queue) - return; - - for (i = 0; i < queue->count; i++) { - virObjectUnref(queue->events[i]); - } - VIR_FREE(queue->events); - queue->count = 0; -} - -/** - * virObjectEventQueueFree: - * @queue: pointer to the queue - * - * Free the memory in the queue. We process this like a list here - */ -static void -virObjectEventQueueFree(virObjectEventQueuePtr queue) -{ - if (!queue) - return; - - virObjectEventQueueClear(queue); - VIR_FREE(queue); -} - -static virObjectEventQueuePtr -virObjectEventQueueNew(void) -{ - virObjectEventQueuePtr ret; - - ignore_value(VIR_ALLOC(ret)); - return ret; -} - -static void -virObjectEventStateLock(virObjectEventStatePtr state) -{ - virMutexLock(&state->lock); -} - -static void -virObjectEventStateUnlock(virObjectEventStatePtr state) -{ - virMutexUnlock(&state->lock); -} - -/** - * virObjectEventStateFree: - * @list: virObjectEventStatePtr to free - * - * Free a virObjectEventStatePtr and its members, and unregister the timer. - */ -void -virObjectEventStateFree(virObjectEventStatePtr state) -{ - if (!state) - return; - - virObjectEventCallbackListFree(state->callbacks); - virObjectEventQueueFree(state->queue); - - if (state->timer != -1) - virEventRemoveTimeout(state->timer); - - virMutexDestroy(&state->lock); - VIR_FREE(state); -} - - -static void virObjectEventStateFlush(virObjectEventStatePtr state); - -static void -virObjectEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque) -{ - virObjectEventStatePtr state = opaque; - - virObjectEventStateFlush(state); -} - -/** - * virObjectEventStateNew: - */ -virObjectEventStatePtr -virObjectEventStateNew(void) -{ - virObjectEventStatePtr state = NULL; - - if (VIR_ALLOC(state) < 0) - goto error; - - if (virMutexInit(&state->lock) < 0) { - virReportSystemError(errno, "%s", - _("unable to initialize state mutex")); - VIR_FREE(state); - goto error; - } - - if (VIR_ALLOC(state->callbacks) < 0) - goto error; - - if (!(state->queue = virObjectEventQueueNew())) - goto error; - - state->timer = -1; - - return state; - -error: - virObjectEventStateFree(state); - return NULL; -} - -static void *virObjectEventNew(virClassPtr klass, - int eventID, - int id, - const char *name, - const unsigned char *uuid) -{ - virObjectEventPtr event; - - 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; - - if (VIR_STRDUP(event->meta.name, name) < 0) { - VIR_FREE(event); - return NULL; - } - event->meta.id = id; - memcpy(event->meta.uuid, uuid, VIR_UUID_BUFLEN); - - VIR_DEBUG("obj=%p", event); - return event; -} - void *virDomainEventLifecycleNew(int id, const char *name, const unsigned char *uuid, int type, int detail) @@ -1543,42 +1044,8 @@ void *virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, devAlias); } -/** - * virObjectEventQueuePush: - * @evtQueue: the object event queue - * @event: the event to add - * - * Internal function to push to the back of a virObjectEventQueue - * - * Returns: 0 on success, -1 on failure - */ -static int -virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, - virObjectEventPtr event) -{ - if (!evtQueue) { - return -1; - } - - /* Make space on queue */ - if (VIR_REALLOC_N(evtQueue->events, - evtQueue->count + 1) < 0) - return -1; - - evtQueue->events[evtQueue->count] = event; - evtQueue->count++; - return 0; -} - -typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, - virObjectEventPtr event, - virConnectObjectEventGenericCallback cb, - void *cbopaque, - void *opaque); - - -static void +void virDomainEventDispatchDefaultFunc(virConnectPtr conn, virObjectEventPtr event, virConnectDomainEventGenericCallback cb, @@ -1762,207 +1229,6 @@ cleanup: } -static int virObjectEventDispatchMatchCallback(virObjectEventPtr event, - virObjectEventCallbackPtr cb) -{ - if (!cb) - return 0; - if (cb->deleted) - return 0; - if (cb->eventID != virObjectEventGetEventID(event)) - return 0; - - 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->meta.uuid, cb->meta->uuid, VIR_UUID_BUFLEN) == 0) - return 1; - - return 0; - } else { - return 1; - } -} - - -static void -virObjectEventDispatch(virObjectEventPtr event, - virObjectEventCallbackListPtr callbacks, - virObjectEventDispatchFunc dispatch, - void *opaque) -{ - size_t i; - /* Cache this now, since we may be dropping the lock, - and have more callbacks added. We're guaranteed not - to have any removed */ - int cbCount = callbacks->count; - - for (i = 0; i < cbCount; i++) { - if (!virObjectEventDispatchMatchCallback(event, callbacks->callbacks[i])) - continue; - - (*dispatch)(callbacks->callbacks[i]->conn, - event, - callbacks->callbacks[i]->cb, - callbacks->callbacks[i]->opaque, - opaque); - } -} - - -static void -virObjectEventQueueDispatch(virObjectEventQueuePtr queue, - virObjectEventCallbackListPtr callbacks, - virObjectEventDispatchFunc dispatch, - void *opaque) -{ - size_t i; - - for (i = 0; i < queue->count; i++) { - virObjectEventDispatch(queue->events[i], callbacks, dispatch, opaque); - virObjectUnref(queue->events[i]); - } - VIR_FREE(queue->events); - queue->count = 0; -} - -void -virObjectEventStateQueue(virObjectEventStatePtr state, - virObjectEventPtr event) -{ - if (state->timer < 0) { - virObjectUnref(event); - return; - } - - virObjectEventStateLock(state); - - if (virObjectEventQueuePush(state->queue, event) < 0) { - VIR_DEBUG("Error adding event to queue"); - virObjectUnref(event); - } - - if (state->queue->count == 1) - virEventUpdateTimeout(state->timer, 0); - virObjectEventStateUnlock(state); -} - - -static void -virObjectEventStateDispatchFunc(virConnectPtr conn, - virObjectEventPtr event, - virConnectObjectEventGenericCallback cb, - void *cbopaque, - void *opaque) -{ - virObjectEventStatePtr state = opaque; - virEventNamespaceID namespace = (event->eventID & 0xFF00) >> 8; - - /* Drop the lock whle dispatching, for sake of re-entrancy */ - virObjectEventStateUnlock(state); - switch (namespace) - { - case VIR_EVENT_NAMESPACE_DOMAIN: - virDomainEventDispatchDefaultFunc(conn, event, - VIR_DOMAIN_EVENT_CALLBACK(cb), cbopaque, NULL); - break; - } - virObjectEventStateLock(state); -} - - -static void -virObjectEventStateFlush(virObjectEventStatePtr state) -{ - virObjectEventQueue tempQueue; - - virObjectEventStateLock(state); - state->isDispatching = true; - - /* Copy the queue, so we're reentrant safe when dispatchFunc drops the - * driver lock */ - tempQueue.count = state->queue->count; - tempQueue.events = state->queue->events; - state->queue->count = 0; - state->queue->events = NULL; - virEventUpdateTimeout(state->timer, -1); - - virObjectEventQueueDispatch(&tempQueue, - state->callbacks, - virObjectEventStateDispatchFunc, - state); - - /* Purge any deleted callbacks */ - virObjectEventCallbackListPurgeMarked(state->callbacks); - - state->isDispatching = false; - virObjectEventStateUnlock(state); -} - - -/** - * virObjectEventStateRegisterID: - * @conn: connection to associate with callback - * @state: domain event state - * @eventID: ID of the event type to register for - * @cb: function to remove from event - * @opaque: data blob to pass to callback - * @freecb: callback to free @opaque - * @callbackID: filled with callback ID - * - * Register the function @callbackID with connection @conn, - * from @state, for events of type @eventID. - * - * Returns: the number of callbacks now registered, or -1 on error - */ -int -virObjectEventStateRegisterID(virConnectPtr conn, - virObjectEventStatePtr state, - unsigned char uuid[VIR_UUID_BUFLEN], - const char *name, - int id, - int eventID, - virConnectObjectEventGenericCallback cb, - void *opaque, - virFreeCallback freecb, - int *callbackID) -{ - int ret = -1; - - virObjectEventStateLock(state); - - if ((state->callbacks->count == 0) && - (state->timer == -1) && - (state->timer = virEventAddTimeout(-1, - virObjectEventTimer, - state, - NULL)) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("could not initialize domain event timer")); - goto cleanup; - } - - ret = virObjectEventCallbackListAddID(conn, state->callbacks, - uuid, name, id, eventID, cb, opaque, freecb, - callbackID); - - if (ret == -1 && - state->callbacks->count == 0 && - state->timer != -1) { - virEventRemoveTimeout(state->timer); - state->timer = -1; - } - -cleanup: - virObjectEventStateUnlock(state); - return ret; -} - - /** * virDomainEventStateRegister: * @conn: connection to associate with callback @@ -2087,67 +1353,3 @@ virDomainEventStateDeregister(virConnectPtr conn, virObjectEventStateUnlock(state); return ret; } - - -/** - * virObjectEventStateDeregisterID: - * @conn: connection to associate with callback - * @state: object event state - * @callbackID: ID of the function to remove from event - * - * Unregister the function @callbackID with connection @conn, - * from @state, for events. - * - * Returns: the number of callbacks still registered, or -1 on error - */ -int -virObjectEventStateDeregisterID(virConnectPtr conn, - virObjectEventStatePtr state, - int callbackID) -{ - int ret; - - virObjectEventStateLock(state); - if (state->isDispatching) - ret = virObjectEventCallbackListMarkDeleteID(conn, - state->callbacks, callbackID); - else - ret = virObjectEventCallbackListRemoveID(conn, - state->callbacks, callbackID); - - if (state->callbacks->count == 0 && - state->timer != -1) { - virEventRemoveTimeout(state->timer); - state->timer = -1; - virObjectEventQueueClear(state->queue); - } - - virObjectEventStateUnlock(state); - return ret; -} - - -/** - * virObjectEventStateEventID: - * @conn: connection associated with the callback - * @state: object event state - * @callbackID: the callback to query - * - * Query what event ID type is associated with the - * callback @callbackID for connection @conn - * - * Returns 0 on success, -1 on error - */ -int -virObjectEventStateEventID(virConnectPtr conn, - virObjectEventStatePtr state, - int callbackID) -{ - int ret; - - virObjectEventStateLock(state); - ret = virObjectEventCallbackListEventID(conn, - state->callbacks, callbackID); - virObjectEventStateUnlock(state); - return ret; -} diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 4e438f2..0fa2715 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -3,6 +3,7 @@ * * Copyright (C) 2012 Red Hat, Inc. * Copyright (C) 2008 VirtualIron + * 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 @@ -26,26 +27,9 @@ #ifndef __DOMAIN_EVENT_H__ # define __DOMAIN_EVENT_H__ +# include "object_event.h" # include "domain_conf.h" -typedef struct _virObjectEventCallback virObjectEventCallback; -typedef virObjectEventCallback *virObjectEventCallbackPtr; - -typedef struct _virObjectEventCallbackList virObjectEventCallbackList; -typedef virObjectEventCallbackList *virObjectEventCallbackListPtr; - -/** - * Dispatching domain events that come in while - * in a call / response rpc - */ -typedef struct _virObjectEvent virObjectEvent; -typedef virObjectEvent *virObjectEventPtr; - -typedef struct _virObjectEventQueue virObjectEventQueue; -typedef virObjectEventQueue *virObjectEventQueuePtr; - -typedef struct _virObjectEventState virObjectEventState; -typedef virObjectEventState *virObjectEventStatePtr; void *virDomainEventLifecycleNew(int id, const char *name, @@ -147,27 +131,6 @@ void *virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj, void *virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom, const char *devAlias); -void virObjectEventStateFree(virObjectEventStatePtr state); -virObjectEventStatePtr -virObjectEventStateNew(void); - -/* - * virConnectObjectEventGenericCallback: - * @conn: the connection pointer - * @obj: the object pointer - * @opaque: application specified data - * - * A generic object event callback handler. Specific events usually - * have a customization with extra parameters - */ -typedef void (*virConnectObjectEventGenericCallback)(virConnectPtr conn, - void *obj, - void *opaque); - -void -virObjectEventStateQueue(virObjectEventStatePtr state, - virObjectEventPtr event) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); int virDomainEventStateRegister(virConnectPtr conn, virObjectEventStatePtr state, virConnectDomainEventCallback callback, @@ -188,27 +151,12 @@ virDomainEventStateDeregister(virConnectPtr conn, virObjectEventStatePtr state, 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) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); -int -virObjectEventStateEventID(virConnectPtr conn, - virObjectEventStatePtr state, - int callbackID) - ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); + +void +virDomainEventDispatchDefaultFunc(virConnectPtr conn, + virObjectEventPtr event, + virConnectDomainEventGenericCallback cb, + void *cbopaque, + void *opaque); #endif diff --git a/src/conf/object_event.c b/src/conf/object_event.c new file mode 100644 index 0000000..e6cebec --- /dev/null +++ b/src/conf/object_event.c @@ -0,0 +1,786 @@ +/* + * object_event.c: object event queue processing helpers + * + * Copyright (C) 2010-2013 Red Hat, Inc. + * Copyright (C) 2008 VirtualIron + * 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: Ben Guthro + */ + +#include <config.h> + +#include "domain_event.h" +#include "object_event.h" +#include "object_event_private.h" +#include "virlog.h" +#include "datatypes.h" +#include "viralloc.h" +#include "virerror.h" +#include "virstring.h" + +#define VIR_FROM_THIS VIR_FROM_NONE + +static virClassPtr virObjectEventClass; + +static void virObjectEventDispose(void *obj); + +static int virObjectEventOnceInit(void) +{ + if (!(virObjectEventClass = virClassNew(virClassForObject(), + "virObjectEvent", + sizeof(virObjectEvent), + virObjectEventDispose))) + return -1; + return 0; +} + +VIR_ONCE_GLOBAL_INIT(virObjectEvent) + +virClassPtr virClassForObjectEvent(void) +{ + if (virObjectEventInitialize() < 0) + return NULL; + return virObjectEventClass; +} + +int virObjectEventGetEventID(void *anyobj) +{ + virObjectEventPtr obj = anyobj; + + if (!virObjectIsClass(obj, virClassForObjectEvent())) { + 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); + + VIR_FREE(event->meta.name); +} + +/** + * virObjectEventCallbackListFree: + * @list: event callback list head + * + * Free the memory in the domain event callback list + */ +static void +virObjectEventCallbackListFree(virObjectEventCallbackListPtr list) +{ + size_t i; + if (!list) + return; + + for (i=0; i<list->count; i++) { + virFreeCallback freecb = list->callbacks[i]->freecb; + if (freecb) + (*freecb)(list->callbacks[i]->opaque); + VIR_FREE(list->callbacks[i]); + } + VIR_FREE(list->callbacks); + VIR_FREE(list); +} + + +/** + * virObjectEventCallbackListRemoveID: + * @conn: pointer to the connection + * @cbList: the list + * @callback: the callback to remove + * + * Internal function to remove a callback from a virObjectEventCallbackListPtr + */ +static int +virObjectEventCallbackListRemoveID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, + int callbackID) +{ + int ret = 0; + size_t i; + for (i = 0; i < cbList->count; i++) { + if (cbList->callbacks[i]->callbackID == callbackID && + cbList->callbacks[i]->conn == conn) { + virFreeCallback freecb = cbList->callbacks[i]->freecb; + if (freecb) + (*freecb)(cbList->callbacks[i]->opaque); + virObjectUnref(cbList->callbacks[i]->conn); + VIR_FREE(cbList->callbacks[i]); + + if (i < (cbList->count - 1)) + memmove(cbList->callbacks + i, + cbList->callbacks + i + 1, + sizeof(*(cbList->callbacks)) * + (cbList->count - (i + 1))); + + if (VIR_REALLOC_N(cbList->callbacks, + cbList->count - 1) < 0) { + ; /* Failure to reduce memory allocation isn't fatal */ + } + cbList->count--; + + for (i = 0; i < cbList->count; i++) { + if (!cbList->callbacks[i]->deleted) + ret++; + } + return ret; + } + } + + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("could not find event callback for removal")); + return -1; +} + + +static int +virObjectEventCallbackListMarkDeleteID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, + int callbackID) +{ + int ret = 0; + size_t i; + for (i = 0; i < cbList->count; i++) { + if (cbList->callbacks[i]->callbackID == callbackID && + cbList->callbacks[i]->conn == conn) { + cbList->callbacks[i]->deleted = 1; + for (i = 0; i < cbList->count; i++) { + if (!cbList->callbacks[i]->deleted) + ret++; + } + return ret; + } + } + + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("could not find event callback for deletion")); + return -1; +} + + +static int +virObjectEventCallbackListPurgeMarked(virObjectEventCallbackListPtr cbList) +{ + int old_count = cbList->count; + int n; + for (n = 0; n < cbList->count; n++) { + if (cbList->callbacks[n]->deleted) { + virFreeCallback freecb = cbList->callbacks[n]->freecb; + if (freecb) + (*freecb)(cbList->callbacks[n]->opaque); + virObjectUnref(cbList->callbacks[n]->conn); + VIR_FREE(cbList->callbacks[n]); + + if (n < (cbList->count - 1)) + memmove(cbList->callbacks + n, + cbList->callbacks + n + 1, + sizeof(*(cbList->callbacks)) * + (cbList->count - (n + 1))); + cbList->count--; + n--; + } + } + if (cbList->count < old_count && + VIR_REALLOC_N(cbList->callbacks, cbList->count) < 0) { + ; /* Failure to reduce memory allocation isn't fatal */ + } + return 0; +} + + +/** + * virObjectEventCallbackListAddID: + * @conn: pointer to the connection + * @cbList: the list + * @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 virObjectEventCallbackListPtr + */ +int +virObjectEventCallbackListAddID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, + unsigned char uuid[VIR_UUID_BUFLEN], + const char *name, + int id, + int eventID, + virConnectObjectEventGenericCallback callback, + void *opaque, + virFreeCallback freecb, + int *callbackID) +{ + virObjectEventCallbackPtr event; + size_t i; + int ret = 0; + + /* Check incoming */ + if (!cbList) { + return -1; + } + + /* check if we already have this callback on our list */ + for (i = 0; i < cbList->count; i++) { + if (cbList->callbacks[i]->cb == VIR_OBJECT_EVENT_CALLBACK(callback) && + cbList->callbacks[i]->eventID == eventID && + cbList->callbacks[i]->conn == conn && + ((uuid && cbList->callbacks[i]->meta && + memcmp(cbList->callbacks[i]->meta->uuid, + uuid, VIR_UUID_BUFLEN) == 0) || + (!uuid && !cbList->callbacks[i]->meta))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("event callback already tracked")); + return -1; + } + } + /* Allocate new event */ + if (VIR_ALLOC(event) < 0) + goto error; + event->conn = conn; + event->cb = callback; + event->eventID = eventID; + event->opaque = opaque; + event->freecb = freecb; + + if (name && uuid && id > 0) { + if (VIR_ALLOC(event->meta) < 0) + goto error; + if (VIR_STRDUP(event->meta->name, name) < 0) + goto error; + memcpy(event->meta->uuid, uuid, VIR_UUID_BUFLEN); + event->meta->id = id; + } + + /* Make space on list */ + if (VIR_REALLOC_N(cbList->callbacks, cbList->count + 1) < 0) + goto error; + + virObjectRef(event->conn); + + cbList->callbacks[cbList->count] = event; + cbList->count++; + + event->callbackID = cbList->nextID++; + + for (i = 0; i < cbList->count; i++) { + if (cbList->callbacks[i]->eventID == eventID && + cbList->callbacks[i]->conn == conn && + !cbList->callbacks[i]->deleted) + ret++; + } + + if (callbackID) + *callbackID = event->callbackID; + + return ret; + +error: + if (event) { + if (event->meta) + VIR_FREE(event->meta->name); + VIR_FREE(event->meta); + } + VIR_FREE(event); + return -1; +} + + +static int +virObjectEventCallbackListEventID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, + int callbackID) +{ + size_t i; + + for (i = 0; i < cbList->count; i++) { + if (cbList->callbacks[i]->deleted) + continue; + + if (cbList->callbacks[i]->callbackID == callbackID && + cbList->callbacks[i]->conn == conn) + return cbList->callbacks[i]->eventID; + } + + return -1; +} + + +/** + * virObjectEventQueueClear: + * @queue: pointer to the queue + * + * Removes all elements from the queue + */ +void +virObjectEventQueueClear(virObjectEventQueuePtr queue) +{ + size_t i; + if (!queue) + return; + + for (i = 0; i < queue->count; i++) { + virObjectUnref(queue->events[i]); + } + VIR_FREE(queue->events); + queue->count = 0; +} + +/** + * virObjectEventQueueFree: + * @queue: pointer to the queue + * + * Free the memory in the queue. We process this like a list here + */ +static void +virObjectEventQueueFree(virObjectEventQueuePtr queue) +{ + if (!queue) + return; + + virObjectEventQueueClear(queue); + VIR_FREE(queue); +} + +static virObjectEventQueuePtr +virObjectEventQueueNew(void) +{ + virObjectEventQueuePtr ret; + + ignore_value(VIR_ALLOC(ret)); + return ret; +} + +void +virObjectEventStateLock(virObjectEventStatePtr state) +{ + virMutexLock(&state->lock); +} + +void +virObjectEventStateUnlock(virObjectEventStatePtr state) +{ + virMutexUnlock(&state->lock); +} + +/** + * virObjectEventStateFree: + * @list: virObjectEventStatePtr to free + * + * Free a virObjectEventStatePtr and its members, and unregister the timer. + */ +void +virObjectEventStateFree(virObjectEventStatePtr state) +{ + if (!state) + return; + + virObjectEventCallbackListFree(state->callbacks); + virObjectEventQueueFree(state->queue); + + if (state->timer != -1) + virEventRemoveTimeout(state->timer); + + virMutexDestroy(&state->lock); + VIR_FREE(state); +} + + +static void virObjectEventStateFlush(virObjectEventStatePtr state); + +void +virObjectEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque) +{ + virObjectEventStatePtr state = opaque; + + virObjectEventStateFlush(state); +} + +/** + * virObjectEventStateNew: + */ +virObjectEventStatePtr +virObjectEventStateNew(void) +{ + virObjectEventStatePtr state = NULL; + + if (VIR_ALLOC(state) < 0) + goto error; + + if (virMutexInit(&state->lock) < 0) { + virReportSystemError(errno, "%s", + _("unable to initialize state mutex")); + VIR_FREE(state); + goto error; + } + + if (VIR_ALLOC(state->callbacks) < 0) + goto error; + + if (!(state->queue = virObjectEventQueueNew())) + goto error; + + state->timer = -1; + + return state; + +error: + virObjectEventStateFree(state); + return NULL; +} + +void *virObjectEventNew(virClassPtr klass, + int eventID, + int id, + const char *name, + const unsigned char *uuid) +{ + virObjectEventPtr event; + + 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; + + if (VIR_STRDUP(event->meta.name, name) < 0) { + VIR_FREE(event); + return NULL; + } + event->meta.id = id; + memcpy(event->meta.uuid, uuid, VIR_UUID_BUFLEN); + + VIR_DEBUG("obj=%p", event); + return event; +} + +/** + * virObjectEventQueuePush: + * @evtQueue: the object event queue + * @event: the event to add + * + * Internal function to push to the back of a virObjectEventQueue + * + * Returns: 0 on success, -1 on failure + */ +static int +virObjectEventQueuePush(virObjectEventQueuePtr evtQueue, + virObjectEventPtr event) +{ + if (!evtQueue) { + return -1; + } + + /* Make space on queue */ + if (VIR_REALLOC_N(evtQueue->events, + evtQueue->count + 1) < 0) + return -1; + + evtQueue->events[evtQueue->count] = event; + evtQueue->count++; + return 0; +} + + +typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, + virObjectEventPtr event, + virConnectObjectEventGenericCallback cb, + void *cbopaque, + void *opaque); + + +static int virObjectEventDispatchMatchCallback(virObjectEventPtr event, + virObjectEventCallbackPtr cb) +{ + if (!cb) + return 0; + if (cb->deleted) + return 0; + if (cb->eventID != virObjectEventGetEventID(event)) + return 0; + + 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->meta.uuid, cb->meta->uuid, VIR_UUID_BUFLEN) == 0) + return 1; + + return 0; + } else { + return 1; + } +} + + +static void +virObjectEventDispatch(virObjectEventPtr event, + virObjectEventCallbackListPtr callbacks, + virObjectEventDispatchFunc dispatch, + void *opaque) +{ + size_t i; + /* Cache this now, since we may be dropping the lock, + and have more callbacks added. We're guaranteed not + to have any removed */ + int cbCount = callbacks->count; + + for (i = 0; i < cbCount; i++) { + if (!virObjectEventDispatchMatchCallback(event, callbacks->callbacks[i])) + continue; + + (*dispatch)(callbacks->callbacks[i]->conn, + event, + callbacks->callbacks[i]->cb, + callbacks->callbacks[i]->opaque, + opaque); + } +} + + +static void +virObjectEventQueueDispatch(virObjectEventQueuePtr queue, + virObjectEventCallbackListPtr callbacks, + virObjectEventDispatchFunc dispatch, + void *opaque) +{ + size_t i; + + for (i = 0; i < queue->count; i++) { + virObjectEventDispatch(queue->events[i], callbacks, dispatch, opaque); + virObjectUnref(queue->events[i]); + } + VIR_FREE(queue->events); + queue->count = 0; +} + +void +virObjectEventStateQueue(virObjectEventStatePtr state, + virObjectEventPtr event) +{ + if (state->timer < 0) { + virObjectUnref(event); + return; + } + + virObjectEventStateLock(state); + + if (virObjectEventQueuePush(state->queue, event) < 0) { + VIR_DEBUG("Error adding event to queue"); + virObjectUnref(event); + } + + if (state->queue->count == 1) + virEventUpdateTimeout(state->timer, 0); + virObjectEventStateUnlock(state); +} + + +static void +virObjectEventStateDispatchFunc(virConnectPtr conn, + virObjectEventPtr event, + virConnectObjectEventGenericCallback cb, + void *cbopaque, + void *opaque) +{ + virObjectEventStatePtr state = opaque; + virEventNamespaceID namespace = (event->eventID & 0xFF00) >> 8; + + /* Drop the lock whle dispatching, for sake of re-entrancy */ + virObjectEventStateUnlock(state); + switch (namespace) + { + case VIR_EVENT_NAMESPACE_DOMAIN: + virDomainEventDispatchDefaultFunc(conn, event, + VIR_DOMAIN_EVENT_CALLBACK(cb), cbopaque, NULL); + break; + } + virObjectEventStateLock(state); +} + + +static void +virObjectEventStateFlush(virObjectEventStatePtr state) +{ + virObjectEventQueue tempQueue; + + virObjectEventStateLock(state); + state->isDispatching = true; + + /* Copy the queue, so we're reentrant safe when dispatchFunc drops the + * driver lock */ + tempQueue.count = state->queue->count; + tempQueue.events = state->queue->events; + state->queue->count = 0; + state->queue->events = NULL; + virEventUpdateTimeout(state->timer, -1); + + virObjectEventQueueDispatch(&tempQueue, + state->callbacks, + virObjectEventStateDispatchFunc, + state); + + /* Purge any deleted callbacks */ + virObjectEventCallbackListPurgeMarked(state->callbacks); + + state->isDispatching = false; + virObjectEventStateUnlock(state); +} + + +/** + * virObjectEventStateRegisterID: + * @conn: connection to associate with callback + * @state: domain event state + * @eventID: ID of the event type to register for + * @cb: function to remove from event + * @opaque: data blob to pass to callback + * @freecb: callback to free @opaque + * @callbackID: filled with callback ID + * + * Register the function @callbackID with connection @conn, + * from @state, for events of type @eventID. + * + * Returns: the number of callbacks now registered, or -1 on error + */ +int +virObjectEventStateRegisterID(virConnectPtr conn, + virObjectEventStatePtr state, + unsigned char uuid[VIR_UUID_BUFLEN], + const char *name, + int id, + int eventID, + virConnectObjectEventGenericCallback cb, + void *opaque, + virFreeCallback freecb, + int *callbackID) +{ + int ret = -1; + + virObjectEventStateLock(state); + + if ((state->callbacks->count == 0) && + (state->timer == -1) && + (state->timer = virEventAddTimeout(-1, + virObjectEventTimer, + state, + NULL)) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("could not initialize domain event timer")); + goto cleanup; + } + + ret = virObjectEventCallbackListAddID(conn, state->callbacks, + uuid, name, id, eventID, cb, opaque, freecb, + callbackID); + + if (ret == -1 && + state->callbacks->count == 0 && + state->timer != -1) { + virEventRemoveTimeout(state->timer); + state->timer = -1; + } + +cleanup: + virObjectEventStateUnlock(state); + return ret; +} + + +/** + * virObjectEventStateDeregisterID: + * @conn: connection to associate with callback + * @state: object event state + * @callbackID: ID of the function to remove from event + * + * Unregister the function @callbackID with connection @conn, + * from @state, for events. + * + * Returns: the number of callbacks still registered, or -1 on error + */ +int +virObjectEventStateDeregisterID(virConnectPtr conn, + virObjectEventStatePtr state, + int callbackID) +{ + int ret; + + virObjectEventStateLock(state); + if (state->isDispatching) + ret = virObjectEventCallbackListMarkDeleteID(conn, + state->callbacks, callbackID); + else + ret = virObjectEventCallbackListRemoveID(conn, + state->callbacks, callbackID); + + if (state->callbacks->count == 0 && + state->timer != -1) { + virEventRemoveTimeout(state->timer); + state->timer = -1; + virObjectEventQueueClear(state->queue); + } + + virObjectEventStateUnlock(state); + return ret; +} + + +/** + * virObjectEventStateEventID: + * @conn: connection associated with the callback + * @state: object event state + * @callbackID: the callback to query + * + * Query what event ID type is associated with the + * callback @callbackID for connection @conn + * + * Returns 0 on success, -1 on error + */ +int +virObjectEventStateEventID(virConnectPtr conn, + virObjectEventStatePtr state, + int callbackID) +{ + int ret; + + virObjectEventStateLock(state); + ret = virObjectEventCallbackListEventID(conn, + state->callbacks, callbackID); + virObjectEventStateUnlock(state); + return ret; +} diff --git a/src/conf/object_event.h b/src/conf/object_event.h new file mode 100644 index 0000000..8081cea --- /dev/null +++ b/src/conf/object_event.h @@ -0,0 +1,96 @@ +/* + * object_event.h: object event queue processing helpers + * + * Copyright (C) 2012 Red Hat, Inc. + * Copyright (C) 2008 VirtualIron + * 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: Ben Guthro + */ + +#include "internal.h" + +#ifndef __OBJECT_EVENT_H__ +# define __OBJECT_EVENT_H__ + +typedef struct _virObjectEventCallback virObjectEventCallback; +typedef virObjectEventCallback *virObjectEventCallbackPtr; + +typedef struct _virObjectEventCallbackList virObjectEventCallbackList; +typedef virObjectEventCallbackList *virObjectEventCallbackListPtr; + +/** + * Dispatching domain events that come in while + * in a call / response rpc + */ +typedef struct _virObjectEvent virObjectEvent; +typedef virObjectEvent *virObjectEventPtr; + +typedef struct _virObjectEventQueue virObjectEventQueue; +typedef virObjectEventQueue *virObjectEventQueuePtr; + +typedef struct _virObjectEventState virObjectEventState; +typedef virObjectEventState *virObjectEventStatePtr; + + +void 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); + +#define VIR_OBJECT_EVENT_CALLBACK(cb) ((virConnectObjectEventGenericCallback)(cb)) + +void +virObjectEventStateQueue(virObjectEventStatePtr state, + virObjectEventPtr event) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); +int +virObjectEventStateRegisterID(virConnectPtr conn, + virObjectEventStatePtr state, + unsigned char uuid[VIR_UUID_BUFLEN], + const char *name, + int id, + int eventID, + virConnectObjectEventGenericCallback cb, + void *opaque, + virFreeCallback freecb, + int *callbackID) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(7); +int +virObjectEventStateDeregisterID(virConnectPtr conn, + virObjectEventStatePtr state, + int callbackID) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); +int +virObjectEventStateEventID(virConnectPtr conn, + virObjectEventStatePtr state, + int callbackID) + ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); + +#endif diff --git a/src/conf/object_event_private.h b/src/conf/object_event_private.h new file mode 100644 index 0000000..c981a29 --- /dev/null +++ b/src/conf/object_event_private.h @@ -0,0 +1,113 @@ +/* + * object_event_private.h: object event queue processing helpers + * + * Copyright (C) 2012 Red Hat, Inc. + * Copyright (C) 2008 VirtualIron + * 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: Ben Guthro + */ + +#include "datatypes.h" + +#ifndef __OBJECT_EVENT_PRIVATE_H__ +# define __OBJECT_EVENT_PRIVATE_H__ + +struct _virObjectMeta { + int id; + char *name; + unsigned char uuid[VIR_UUID_BUFLEN]; +}; +typedef struct _virObjectMeta virObjectMeta; +typedef virObjectMeta *virObjectMetaPtr; + +struct _virObjectEventCallbackList { + unsigned int nextID; + unsigned int count; + virObjectEventCallbackPtr *callbacks; +}; + +struct _virObjectEventQueue { + unsigned int count; + virObjectEventPtr *events; +}; + +struct _virObjectEventState { + /* The list of domain event callbacks */ + virObjectEventCallbackListPtr callbacks; + /* The queue of object events */ + virObjectEventQueuePtr queue; + /* Timer for flushing events queue */ + int timer; + /* Flag if we're in process of dispatching */ + bool isDispatching; + virMutex lock; +}; + +struct _virObjectEventCallback { + int callbackID; + int eventID; + virConnectPtr conn; + virObjectMetaPtr meta; + virConnectObjectEventGenericCallback cb; + void *opaque; + virFreeCallback freecb; + int deleted; +}; + +struct _virObjectEvent { + virObject parent; + int eventID; + virObjectMeta meta; +}; + +virClassPtr virClassForObjectEvent(void); + +int virObjectEventGetEventID(void *anyobj); + +int +virObjectEventCallbackListAddID(virConnectPtr conn, + virObjectEventCallbackListPtr cbList, + unsigned char uuid[VIR_UUID_BUFLEN], + const char *name, + int id, + int eventID, + virConnectObjectEventGenericCallback callback, + void *opaque, + virFreeCallback freecb, + int *callbackID); + +void +virObjectEventQueueClear(virObjectEventQueuePtr queue); + +void +virObjectEventStateLock(virObjectEventStatePtr state); + +void +virObjectEventStateUnlock(virObjectEventStatePtr state); + +void +virObjectEventTimer(int timer, void *opaque); + +void *virObjectEventNew(virClassPtr klass, + int eventID, + int id, + const char *name, + const unsigned char *uuid); + + +#endif diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index d098d3e..b511c8a 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -449,12 +449,6 @@ virDomainEventTrayChangeNewFromDom; virDomainEventTrayChangeNewFromObj; virDomainEventWatchdogNewFromDom; virDomainEventWatchdogNewFromObj; -virObjectEventStateDeregisterID; -virObjectEventStateEventID; -virObjectEventStateFree; -virObjectEventStateNew; -virObjectEventStateQueue; -virObjectEventStateRegisterID; # conf/domain_nwfilter.h @@ -626,6 +620,15 @@ virNWFilterVarValueGetNthValue; virNWFilterVarValueGetSimple; +# conf/object_event.h +virObjectEventStateDeregisterID; +virObjectEventStateEventID; +virObjectEventStateFree; +virObjectEventStateNew; +virObjectEventStateQueue; +virObjectEventStateRegisterID; + + # conf/secret_conf.h virSecretDefFormat; virSecretDefFree; -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:02PM +0100, Cédric Bosdonnat wrote:
--- src/Makefile.am | 6 + src/conf/domain_event.c | 806 +--------------------------------------- src/conf/domain_event.h | 70 +--- src/conf/object_event.c | 786 +++++++++++++++++++++++++++++++++++++++ src/conf/object_event.h | 96 +++++ src/conf/object_event_private.h | 113 ++++++ src/libvirt_private.syms | 15 +- 7 files changed, 1023 insertions(+), 869 deletions(-) create mode 100644 src/conf/object_event.c create mode 100644 src/conf/object_event.h create mode 100644 src/conf/object_event_private.h
diff --git a/src/conf/object_event_private.h b/src/conf/object_event_private.h new file mode 100644 index 0000000..c981a29 --- /dev/null +++ b/src/conf/object_event_private.h + +#include "datatypes.h" + +#ifndef __OBJECT_EVENT_PRIVATE_H__ +# define __OBJECT_EVENT_PRIVATE_H__ + +struct _virObjectMeta { + int id; + char *name; + unsigned char uuid[VIR_UUID_BUFLEN]; +}; +typedef struct _virObjectMeta virObjectMeta; +typedef virObjectMeta *virObjectMetaPtr; + +struct _virObjectEventCallbackList { + unsigned int nextID; + unsigned int count; + virObjectEventCallbackPtr *callbacks; +}; + +struct _virObjectEventQueue { + unsigned int count; + virObjectEventPtr *events; +}; + +struct _virObjectEventState { + /* The list of domain event callbacks */ + virObjectEventCallbackListPtr callbacks; + /* The queue of object events */ + virObjectEventQueuePtr queue; + /* Timer for flushing events queue */ + int timer; + /* Flag if we're in process of dispatching */ + bool isDispatching; + virMutex lock; +}; + +struct _virObjectEventCallback { + int callbackID; + int eventID; + virConnectPtr conn; + virObjectMetaPtr meta; + virConnectObjectEventGenericCallback cb; + void *opaque; + virFreeCallback freecb; + int deleted; +}; + +struct _virObjectEvent { + virObject parent; + int eventID; + virObjectMeta meta; +};
I wondering if all of these structs need to be exposed here. I'd go for the minimum required to let domain_events.c compile, if this can be made smaller. 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 :|
This object is still unused, but not for long. --- src/conf/object_event.c | 43 ++++++++++++++++++++++++++++++++++++++++++- src/conf/object_event.h | 4 ++++ src/libvirt_private.syms | 1 + 3 files changed, 47 insertions(+), 1 deletion(-) diff --git a/src/conf/object_event.c b/src/conf/object_event.c index e6cebec..c6538c0 100644 --- a/src/conf/object_event.c +++ b/src/conf/object_event.c @@ -35,9 +35,18 @@ #define VIR_FROM_THIS VIR_FROM_NONE -static virClassPtr virObjectEventClass; +struct _virNetworkEventLifecycle { + virObjectEvent parent; + + int type; +}; +typedef struct _virNetworkEventLifecycle virNetworkEventLifecycle; +typedef virNetworkEventLifecycle *virNetworkEventLifecyclePtr; +static virClassPtr virObjectEventClass; +static virClassPtr virNetworkEventLifecycleClass; static void virObjectEventDispose(void *obj); +static void virNetworkEventLifecycleDispose(void *obj); static int virObjectEventOnceInit(void) { @@ -46,6 +55,12 @@ static int virObjectEventOnceInit(void) sizeof(virObjectEvent), virObjectEventDispose))) return -1; + if (!(virNetworkEventLifecycleClass = virClassNew( + virObjectEventClass, + "virNetworkEventLifecycle", + sizeof(virNetworkEventLifecycle), + virNetworkEventLifecycleDispose))) + return -1; return 0; } @@ -79,6 +94,12 @@ static void virObjectEventDispose(void *obj) VIR_FREE(event->meta.name); } +void virNetworkEventLifecycleDispose(void *obj) +{ + virNetworkEventLifecyclePtr event = obj; + VIR_DEBUG("obj=%p", event); +} + /** * virObjectEventCallbackListFree: * @list: event callback list head @@ -784,3 +805,23 @@ virObjectEventStateEventID(virConnectPtr conn, virObjectEventStateUnlock(state); return ret; } + +void *virNetworkEventLifecycleNew(int id, const char *name, + const unsigned char *uuid, + int type) +{ + virNetworkEventLifecyclePtr event; + int eventId = (VIR_EVENT_NAMESPACE_NETWORK << 8) + VIR_NETWORK_EVENT_ID_LIFECYCLE; + + if (virObjectEventInitialize() < 0) + return NULL; + + if (!(event = virObjectEventNew(virNetworkEventLifecycleClass, + eventId, + id, name, uuid))) + return NULL; + + event->type = type; + + return event; +} diff --git a/src/conf/object_event.h b/src/conf/object_event.h index 8081cea..3fdd8c5 100644 --- a/src/conf/object_event.h +++ b/src/conf/object_event.h @@ -93,4 +93,8 @@ virObjectEventStateEventID(virConnectPtr conn, int callbackID) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); +void *virNetworkEventLifecycleNew(int id, + const char *name, + const unsigned char *uuid, + int type); #endif diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index b511c8a..6977324 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -621,6 +621,7 @@ virNWFilterVarValueGetSimple; # conf/object_event.h +virNetworkEventLifecycleNew; virObjectEventStateDeregisterID; virObjectEventStateEventID; virObjectEventStateFree; -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:03PM +0100, Cédric Bosdonnat wrote:
This object is still unused, but not for long. --- src/conf/object_event.c | 43 ++++++++++++++++++++++++++++++++++++++++++- src/conf/object_event.h | 4 ++++ src/libvirt_private.syms | 1 + 3 files changed, 47 insertions(+), 1 deletion(-)
Think this should be adding a network_event.{c,h} file to match domain_event.{c,h}. It'll be small for now, but I can forsee it expanding in the future to reflect other changes related to networks. 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 :|
--- include/libvirt/libvirt.h.in | 78 +++++++++++++++++++++++++ src/conf/object_event.c | 80 +++++++++++++++++++++++++- src/conf/object_event.h | 21 +++++-- src/driver.h | 14 +++++ src/libvirt.c | 133 +++++++++++++++++++++++++++++++++++++++++++ src/libvirt_private.syms | 1 + src/libvirt_public.syms | 7 +++ 7 files changed, 328 insertions(+), 6 deletions(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 25ab777..50fa3f7 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -4966,6 +4966,7 @@ typedef enum { */ typedef enum { VIR_EVENT_NAMESPACE_DOMAIN = 0, /* 0 to keep value of virDomainEventId unchanged */ + VIR_EVENT_NAMESPACE_NETWORK = 1, } virEventNamespaceID; @@ -4980,6 +4981,83 @@ int virConnectDomainEventRegisterAny(virConnectPtr conn, int virConnectDomainEventDeregisterAny(virConnectPtr conn, int callbackID); +/** + * virNetworkEventLifecycleType: + * + * a virNetworkEventLifecycleType is emitted during network lifecycle events + */ +typedef enum { + VIR_NETWORK_EVENT_DEFINED = 0, + VIR_NETWORK_EVENT_UNDEFINED = 1, + VIR_NETWORK_EVENT_STARTED = 2, + VIR_NETWORK_EVENT_STOPPED = 3, + +#ifdef VIR_ENUM_SENTINELS + VIR_NETWORK_EVENT_LAST +#endif +} virNetworkEventLifecycleType; + +/** + * virConnectNetworkEventLifecycleCallback: + * @conn: connection object + * @net: network on which the event occurred + * @event: The specific virNetworkEventLifeCycleType which occurred + * @opaque: application specified data + * + * This callback occurs when the network is started or stopped. + * + * The callback signature to use when registering for an event of type + * VIR_NETWORK_EVENT_ID_LIFECYCLE with virConnectNetworkEventRegisterAny() + */ +typedef void (*virConnectNetworkEventLifecycleCallback)(virConnectPtr conn, + virNetworkPtr net, + int event, + void *opaque); + +/** + * VIR_NETWORK_EVENT_CALLBACK: + * + * Used to cast the event specific callback into the generic one + * for use for virNetworkEventRegister + */ +#define VIR_NETWORK_EVENT_CALLBACK(cb) ((virConnectNetworkEventGenericCallback)(cb)) + +typedef enum { + VIR_NETWORK_EVENT_ID_LIFECYCLE = 0, /* virConnectNetworkEventLifecycleCallback */ + +#ifdef VIR_ENUM_SENTINELS + VIR_NETWORK_EVENT_ID_LAST + /* + * NB: this enum value will increase over time as new events are + * added to the libvirt API. It reflects the last event ID supported + * by this version of the libvirt API. + */ +#endif +} virNetworkEventID; + +/* + * virConnectNetworkEventGenericCallback: + * @conn: the connection pointer + * @net: the network pointer + * @opaque: application specified data + * + * A generic network event callback handler. Specific events usually + * have a customization with extra parameters + */ +typedef void (*virConnectNetworkEventGenericCallback)(virConnectPtr conn, + virNetworkPtr net, + void *opaque); + +/* Use VIR_NETWORK_EVENT_CALLBACK() to cast the 'cb' parameter */ +int virConnectNetworkEventRegisterAny(virConnectPtr conn, + virNetworkPtr net, /* Optional, to filter */ + int eventID, + virConnectNetworkEventGenericCallback cb, + void *opaque, + virFreeCallback freecb); + +int virConnectNetworkEventDeregisterAny(virConnectPtr conn, + int callbackID); /** * virNWFilter: diff --git a/src/conf/object_event.c b/src/conf/object_event.c index c6538c0..2d5cf8c 100644 --- a/src/conf/object_event.c +++ b/src/conf/object_event.c @@ -542,6 +542,41 @@ typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn, void *opaque); +static void +virNetworkEventDispatchDefaultFunc(virConnectPtr conn, + virObjectEventPtr event, + virConnectNetworkEventGenericCallback cb ATTRIBUTE_UNUSED, + void *cbopaque ATTRIBUTE_UNUSED, + void *opaque ATTRIBUTE_UNUSED) +{ + virNetworkPtr net = virGetNetwork(conn, event->meta.name, event->meta.uuid); + if (!net) + return; + + switch ((virNetworkEventID) (event->eventID &0xFF) ) { + case VIR_NETWORK_EVENT_ID_LIFECYCLE: + { + virNetworkEventLifecyclePtr networkLifecycleEvent; + + networkLifecycleEvent = (virNetworkEventLifecyclePtr)event; + ((virConnectNetworkEventLifecycleCallback)cb)(conn, net, + networkLifecycleEvent->type, + cbopaque); + goto cleanup; + } + +#ifdef VIR_ENUM_SENTINELS + case VIR_NETWORK_EVENT_ID_LAST: + break; +#endif + } + VIR_WARN("Unexpected event ID %d", event->eventID); + +cleanup: + virNetworkFree(net); +} + + static int virObjectEventDispatchMatchCallback(virObjectEventPtr event, virObjectEventCallbackPtr cb) { @@ -650,6 +685,10 @@ virObjectEventStateDispatchFunc(virConnectPtr conn, virDomainEventDispatchDefaultFunc(conn, event, VIR_DOMAIN_EVENT_CALLBACK(cb), cbopaque, NULL); break; + case VIR_EVENT_NAMESPACE_NETWORK: + virNetworkEventDispatchDefaultFunc(conn, event, + VIR_NETWORK_EVENT_CALLBACK(cb), cbopaque, NULL); + break; } virObjectEventStateLock(state); } @@ -806,7 +845,44 @@ virObjectEventStateEventID(virConnectPtr conn, return ret; } -void *virNetworkEventLifecycleNew(int id, const char *name, + +/** + * virNetworkEventStateRegisterID: + * @conn: connection to associate with callback + * @state: object event state + * @net: network to filter on or NULL for all networks + * @eventID: ID of the event type to register for + * @cb: function to add to 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 +virNetworkEventStateRegisterID(virConnectPtr conn, + virObjectEventStatePtr state, + virNetworkPtr net, + int eventID, + virConnectObjectEventGenericCallback cb, + void *opaque, + virFreeCallback freecb, + int *callbackID) +{ + if (net) + return virObjectEventStateRegisterID(conn, state, + net->uuid, net->name, 0, eventID, + cb, opaque, freecb, callbackID); + else + return virObjectEventStateRegisterID(conn, state, + NULL, NULL, 0, eventID, + cb, opaque, freecb, callbackID); +} + +void *virNetworkEventLifecycleNew(const char *name, const unsigned char *uuid, int type) { @@ -818,7 +894,7 @@ void *virNetworkEventLifecycleNew(int id, const char *name, if (!(event = virObjectEventNew(virNetworkEventLifecycleClass, eventId, - id, name, uuid))) + 0, name, uuid))) return NULL; event->type = type; diff --git a/src/conf/object_event.h b/src/conf/object_event.h index 3fdd8c5..181a798 100644 --- a/src/conf/object_event.h +++ b/src/conf/object_event.h @@ -93,8 +93,21 @@ virObjectEventStateEventID(virConnectPtr conn, int callbackID) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); -void *virNetworkEventLifecycleNew(int id, - const char *name, - const unsigned char *uuid, - int type); +/* + * Network events + */ + +int +virNetworkEventStateRegisterID(virConnectPtr conn, + virObjectEventStatePtr state, + virNetworkPtr net, + int eventID, + virConnectObjectEventGenericCallback cb, + void *opaque, + virFreeCallback freecb, + int *callbackID); + +void *virNetworkEventLifecycleNew(const char *name, + const unsigned char *uuid, + int type); #endif diff --git a/src/driver.h b/src/driver.h index 8cd164a..3c7b536 100644 --- a/src/driver.h +++ b/src/driver.h @@ -1366,6 +1366,18 @@ typedef int virNetworkPtr **nets, unsigned int flags); +typedef int +(*virDrvConnectNetworkEventRegisterAny)(virConnectPtr conn, + virNetworkPtr dom, + int eventID, + virConnectNetworkEventGenericCallback cb, + void *opaque, + virFreeCallback freecb); + +typedef int +(*virDrvConnectNetworkEventDeregisterAny)(virConnectPtr conn, + int callbackID); + typedef virNetworkPtr (*virDrvNetworkLookupByUUID)(virConnectPtr conn, const unsigned char *uuid); @@ -1444,6 +1456,8 @@ struct _virNetworkDriver { virDrvConnectNumOfDefinedNetworks connectNumOfDefinedNetworks; virDrvConnectListDefinedNetworks connectListDefinedNetworks; virDrvConnectListAllNetworks connectListAllNetworks; + virDrvConnectNetworkEventRegisterAny connectNetworkEventRegisterAny; + virDrvConnectNetworkEventDeregisterAny connectNetworkEventDeregisterAny; virDrvNetworkLookupByUUID networkLookupByUUID; virDrvNetworkLookupByName networkLookupByName; virDrvNetworkCreateXML networkCreateXML; diff --git a/src/libvirt.c b/src/libvirt.c index eff44eb..576ce96 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -19176,6 +19176,139 @@ error: } /** + * virConnectNetworkEventRegisterAny: + * @conn: pointer to the connection + * @net: pointer to the network + * @eventID: the event type to receive + * @cb: callback to the function handling network events + * @opaque: opaque data to pass on to the callback + * @freecb: optional function to deallocate opaque when not used anymore + * + * Adds a callback to receive notifications of arbitrary network events + * occurring on a network. + * + * If net is NULL, then events will be monitored for any network. If net + * is non-NULL, then only the specific network will be monitored + * + * Most types of event have a callback providing a custom set of parameters + * for the event. When registering an event, it is thus necessary to use + * the VIR_NETWORK_EVENT_CALLBACK() macro to cast the supplied function pointer + * to match the signature of this method. + * + * The virNetworkPtr object handle passed into the callback upon delivery + * of an event is only valid for the duration of execution of the callback. + * If the callback wishes to keep the network object after the callback + * returns, it shall take a reference to it, by calling virNetworkRef. + * The reference can be released once the object is no longer required + * by calling virNetworkFree. + * + * The return value from this method is a positive integer identifier + * for the callback. To unregister a callback, this callback ID should + * be passed to the virNetworkEventUnregisterAny method + * + * Returns a callback identifier on success, -1 on failure + */ +int +virConnectNetworkEventRegisterAny(virConnectPtr conn, + virNetworkPtr net, + int eventID, + virConnectNetworkEventGenericCallback cb, + void *opaque, + virFreeCallback freecb) +{ + VIR_DEBUG("conn=%p, eventID=%d, cb=%p, opaque=%p, freecb=%p", + conn, eventID, cb, opaque, freecb); + + virResetLastError(); + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + if (net != NULL && + !(VIR_IS_CONNECTED_NETWORK(net) && net->conn == conn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + virDispatchError(conn); + return -1; + } + virCheckNonNullArgGoto(cb, error); + virCheckNonNegativeArgGoto(eventID, error); + if (((eventID & 0xFF00) >> 8) != VIR_EVENT_NAMESPACE_NETWORK) { + virReportInvalidArg(eventID, + _("eventID in %s must be have network namespace flags %d"), + __FUNCTION__, VIR_EVENT_NAMESPACE_NETWORK << 8); + goto error; + } + +#ifdef VIR_ENUM_SENTINELS + if ((eventID & 0xFF) >= VIR_NETWORK_EVENT_ID_LAST) { + virReportInvalidArg(eventID, + _("eventID in %s must be less than %d"), + __FUNCTION__, VIR_NETWORK_EVENT_ID_LAST); + goto error; + } +#endif + + if ((conn->networkDriver) && (conn->networkDriver->connectNetworkEventRegisterAny)) { + int ret; + ret = conn->networkDriver->connectNetworkEventRegisterAny(conn, net, + eventID, cb, + opaque, + freecb); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); +error: + virDispatchError(conn); + return -1; +} + +/** + * virConnectNetworkEventDeregisterAny: + * @conn: pointer to the connection + * @callbackID: the callback identifier + * + * Removes an event callback. The callbackID parameter should be the + * vaule obtained from a previous virNetworkEventRegisterAny method. + * + * Returns 0 on success, -1 on failure + */ +int +virConnectNetworkEventDeregisterAny(virConnectPtr conn, + int callbackID) +{ + VIR_DEBUG("conn=%p, callbackID=%d", conn, callbackID); + + virResetLastError(); + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + virCheckNonNegativeArgGoto(callbackID, error); + + if ((conn->networkDriver) && + (conn->networkDriver->connectNetworkEventDeregisterAny)) { + int ret; + ret = conn->networkDriver->connectNetworkEventDeregisterAny(conn, + callbackID); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); +error: + virDispatchError(conn); + return -1; +} + +/** * virDomainManagedSave: * @dom: pointer to the domain * @flags: bitwise-OR of virDomainSaveRestoreFlags diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 6977324..22ec0ab 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -622,6 +622,7 @@ virNWFilterVarValueGetSimple; # conf/object_event.h virNetworkEventLifecycleNew; +virNetworkEventStateRegisterID; virObjectEventStateDeregisterID; virObjectEventStateEventID; virObjectEventStateFree; diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index fe9b497..6ed6ce6 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -639,4 +639,11 @@ LIBVIRT_1.1.3 { virConnectGetCPUModelNames; } LIBVIRT_1.1.1; +LIBVIRT_1.2.1 { + global: + virConnectNetworkEventRegisterAny; + virConnectNetworkEventDeregisterAny; +} LIBVIRT_1.1.3; + + # .... define new API here using predicted next version number .... -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:04PM +0100, Cédric Bosdonnat wrote:
--- include/libvirt/libvirt.h.in | 78 +++++++++++++++++++++++++ src/conf/object_event.c | 80 +++++++++++++++++++++++++- src/conf/object_event.h | 21 +++++-- src/driver.h | 14 +++++ src/libvirt.c | 133 +++++++++++++++++++++++++++++++++++++++++++ src/libvirt_private.syms | 1 + src/libvirt_public.syms | 7 +++ 7 files changed, 328 insertions(+), 6 deletions(-)
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 25ab777..50fa3f7 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -4966,6 +4966,7 @@ typedef enum { */ typedef enum { VIR_EVENT_NAMESPACE_DOMAIN = 0, /* 0 to keep value of virDomainEventId unchanged */ + VIR_EVENT_NAMESPACE_NETWORK = 1, } virEventNamespaceID;
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 :|
--- src/test/test_driver.c | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 6d2a0e2..4972e3d 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -121,7 +121,7 @@ static const virNodeInfo defaultNodeInfo = { static int testConnectClose(virConnectPtr conn); -static void testDomainEventQueue(testConnPtr driver, +static void testObjectEventQueue(testConnPtr driver, virObjectEventPtr event); @@ -1650,7 +1650,7 @@ cleanup: if (dom) virObjectUnlock(dom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); virDomainDefFree(def); testDriverUnlock(privconn); return ret; @@ -1781,7 +1781,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -1821,7 +1821,7 @@ cleanup: virObjectUnlock(privdom); if (event) { testDriverLock(privconn); - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); } return ret; @@ -1864,7 +1864,7 @@ cleanup: if (event) { testDriverLock(privconn); - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); } return ret; @@ -1911,7 +1911,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -1987,7 +1987,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2159,7 +2159,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2265,7 +2265,7 @@ cleanup: if (dom) virObjectUnlock(dom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2335,7 +2335,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2819,7 +2819,7 @@ cleanup: if (dom) virObjectUnlock(dom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -2955,7 +2955,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -3030,7 +3030,7 @@ cleanup: if (privdom) virObjectUnlock(privdom); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); return ret; } @@ -6028,7 +6028,7 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn, /* driver must be locked before calling */ -static void testDomainEventQueue(testConnPtr driver, +static void testObjectEventQueue(testConnPtr driver, virObjectEventPtr event) { virObjectEventStateQueue(driver->domainEventState, event); @@ -6191,7 +6191,7 @@ cleanup: virObjectUnlock(vm); if (event) { testDriverLock(privconn); - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); } @@ -6743,7 +6743,7 @@ cleanup: } if (event) { testDriverLock(privconn); - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); testDriverUnlock(privconn); } virDomainSnapshotDefFree(def); @@ -6989,7 +6989,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT); if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); goto load; } @@ -7069,7 +7069,7 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, bool paused = (flags & VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED) != 0; if (event) - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT); @@ -7085,9 +7085,9 @@ testDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, ret = 0; cleanup: if (event) { - testDomainEventQueue(privconn, event); + testObjectEventQueue(privconn, event); if (event2) - testDomainEventQueue(privconn, event2); + testObjectEventQueue(privconn, event2); } else { virObjectUnref(event2); } -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:05PM +0100, Cédric Bosdonnat wrote:
--- src/test/test_driver.c | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-)
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 :|
--- src/test/test_driver.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 4972e3d..2c18cef 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -3529,6 +3529,7 @@ static virNetworkPtr testNetworkCreateXML(virConnectPtr conn, const char *xml) { virNetworkDefPtr def; virNetworkObjPtr net = NULL; virNetworkPtr ret = NULL; + virObjectEventPtr event = NULL; testDriverLock(privconn); if ((def = virNetworkDefParseString(xml)) == NULL) @@ -3539,10 +3540,15 @@ static virNetworkPtr testNetworkCreateXML(virConnectPtr conn, const char *xml) { def = NULL; net->active = 1; + event = virNetworkEventLifecycleNew(net->def->name, net->def->uuid, + VIR_NETWORK_EVENT_STARTED); + ret = virGetNetwork(conn, net->def->name, net->def->uuid); cleanup: virNetworkDefFree(def); + if (event) + testObjectEventQueue(privconn, event); if (net) virNetworkObjUnlock(net); testDriverUnlock(privconn); @@ -3556,6 +3562,7 @@ virNetworkPtr testNetworkDefineXML(virConnectPtr conn, const char *xml) virNetworkDefPtr def; virNetworkObjPtr net = NULL; virNetworkPtr ret = NULL; + virObjectEventPtr event = NULL; testDriverLock(privconn); if ((def = virNetworkDefParseString(xml)) == NULL) @@ -3566,10 +3573,15 @@ virNetworkPtr testNetworkDefineXML(virConnectPtr conn, const char *xml) def = NULL; net->persistent = 1; + event = virNetworkEventLifecycleNew(net->def->name, net->def->uuid, + VIR_NETWORK_EVENT_DEFINED); + ret = virGetNetwork(conn, net->def->name, net->def->uuid); cleanup: virNetworkDefFree(def); + if (event) + testObjectEventQueue(privconn, event); if (net) virNetworkObjUnlock(net); testDriverUnlock(privconn); @@ -3580,6 +3592,7 @@ static int testNetworkUndefine(virNetworkPtr network) { testConnPtr privconn = network->conn->privateData; virNetworkObjPtr privnet; int ret = -1; + virObjectEventPtr event = NULL; testDriverLock(privconn); privnet = virNetworkFindByName(&privconn->networks, @@ -3596,12 +3609,17 @@ static int testNetworkUndefine(virNetworkPtr network) { goto cleanup; } + event = virNetworkEventLifecycleNew(network->name, network->uuid, + VIR_NETWORK_EVENT_UNDEFINED); + virNetworkRemoveInactive(&privconn->networks, privnet); privnet = NULL; ret = 0; cleanup: + if (event) + testObjectEventQueue(privconn, event); if (privnet) virNetworkObjUnlock(privnet); testDriverUnlock(privconn); @@ -3660,6 +3678,7 @@ static int testNetworkCreate(virNetworkPtr network) { testConnPtr privconn = network->conn->privateData; virNetworkObjPtr privnet; int ret = -1; + virObjectEventPtr event = NULL; testDriverLock(privconn); privnet = virNetworkFindByName(&privconn->networks, @@ -3678,9 +3697,13 @@ static int testNetworkCreate(virNetworkPtr network) { } privnet->active = 1; + event = virNetworkEventLifecycleNew(privnet->def->name, privnet->def->uuid, + VIR_NETWORK_EVENT_STARTED); ret = 0; cleanup: + if (event) + testObjectEventQueue(privconn, event); if (privnet) virNetworkObjUnlock(privnet); return ret; @@ -3690,6 +3713,7 @@ static int testNetworkDestroy(virNetworkPtr network) { testConnPtr privconn = network->conn->privateData; virNetworkObjPtr privnet; int ret = -1; + virObjectEventPtr event = NULL; testDriverLock(privconn); privnet = virNetworkFindByName(&privconn->networks, @@ -3701,6 +3725,8 @@ static int testNetworkDestroy(virNetworkPtr network) { } privnet->active = 0; + event = virNetworkEventLifecycleNew(privnet->def->name, privnet->def->uuid, + VIR_NETWORK_EVENT_STOPPED); if (!privnet->persistent) { virNetworkRemoveInactive(&privconn->networks, privnet); @@ -3709,6 +3735,8 @@ static int testNetworkDestroy(virNetworkPtr network) { ret = 0; cleanup: + if (event) + testObjectEventQueue(privconn, event); if (privnet) virNetworkObjUnlock(privnet); testDriverUnlock(privconn); @@ -6027,6 +6055,37 @@ testConnectDomainEventDeregisterAny(virConnectPtr conn, } +static int +testConnectNetworkEventRegisterAny(virConnectPtr conn, + virNetworkPtr net, + int eventID, + virConnectNetworkEventGenericCallback callback, + void *opaque, + virFreeCallback freecb) +{ + testConnPtr driver = conn->privateData; + int ret; + + testDriverLock(driver); + if (virNetworkEventStateRegisterID(conn, + driver->domainEventState, + net, eventID, + VIR_OBJECT_EVENT_CALLBACK(callback), + opaque, freecb, &ret) < 0) + ret = -1; + testDriverUnlock(driver); + + return ret; +} + +static int +testConnectNetworkEventDeregisterAny(virConnectPtr conn, + int callbackID) +{ + return testConnectDomainEventDeregisterAny(conn, callbackID); +} + + /* driver must be locked before calling */ static void testObjectEventQueue(testConnPtr driver, virObjectEventPtr event) @@ -7205,6 +7264,8 @@ static virNetworkDriver testNetworkDriver = { .connectNumOfDefinedNetworks = testConnectNumOfDefinedNetworks, /* 0.3.2 */ .connectListDefinedNetworks = testConnectListDefinedNetworks, /* 0.3.2 */ .connectListAllNetworks = testConnectListAllNetworks, /* 0.10.2 */ + .connectNetworkEventRegisterAny = testConnectNetworkEventRegisterAny, /* 1.2.1 */ + .connectNetworkEventDeregisterAny = testConnectNetworkEventDeregisterAny, /* 1.2.1 */ .networkLookupByUUID = testNetworkLookupByUUID, /* 0.3.2 */ .networkLookupByName = testNetworkLookupByName, /* 0.3.2 */ .networkCreateXML = testNetworkCreateXML, /* 0.3.2 */ -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:06PM +0100, Cédric Bosdonnat wrote:
--- src/test/test_driver.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+)
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 :|
--- tests/objecteventtest.c | 165 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 165 insertions(+) diff --git a/tests/objecteventtest.c b/tests/objecteventtest.c index 53ab642..3843821 100644 --- a/tests/objecteventtest.c +++ b/tests/objecteventtest.c @@ -40,6 +40,18 @@ static const char domainDef[] = " </os>" "</domain>"; +static const char networkDef[] = +"<network>\n" +" <name>test</name>\n" +" <bridge name=\"virbr0\"/>\n" +" <forward/>\n" +" <ip address=\"192.168.122.1\" netmask=\"255.255.255.0\">\n" +" <dhcp>\n" +" <range start=\"192.168.122.2\" end=\"192.168.122.254\"/>\n" +" </dhcp>\n" +" </ip>\n" +"</network>\n"; + struct lifecycleEventCounter { int startEvents; int stopEvents; @@ -57,6 +69,7 @@ static void lifecycleEventCounter_reset(struct lifecycleEventCounter* counter) struct objecteventTest { virConnectPtr conn; + virNetworkPtr net; }; @@ -88,6 +101,25 @@ static int domainLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED, return 0; } +static void +networkLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED, + virNetworkPtr net ATTRIBUTE_UNUSED, + int event, + void* opaque) +{ + struct lifecycleEventCounter *counter = opaque; + + if (event == VIR_NETWORK_EVENT_STARTED) + counter->startEvents++; + else if (event == VIR_NETWORK_EVENT_STOPPED) + counter->stopEvents++; + else if (event == VIR_NETWORK_EVENT_DEFINED) + counter->defineEvents++; + else if (event == VIR_NETWORK_EVENT_UNDEFINED) + counter->undefineEvents++; +} + + static int testDomainCreateXML(const void *data) { @@ -214,6 +246,124 @@ cleanup: } static int +testNetworkCreateXML(const void *data) +{ + const struct objecteventTest *test = data; + struct lifecycleEventCounter counter; + int eventId = (VIR_EVENT_NAMESPACE_NETWORK << 8) + VIR_NETWORK_EVENT_ID_LIFECYCLE; + virNetworkPtr net; + int id; + int ret = 0; + + lifecycleEventCounter_reset(&counter); + + id = virConnectNetworkEventRegisterAny(test->conn, NULL, eventId, + VIR_NETWORK_EVENT_CALLBACK(&networkLifecycleCb), + &counter, NULL); + net = virNetworkCreateXML(test->conn, networkDef); + + if (virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.startEvents != 1) { + ret = -1; + goto cleanup; + } + +cleanup: + virConnectNetworkEventDeregisterAny(test->conn, id); + virNetworkDestroy(net); + + virNetworkFree(net); + + return ret; +} + +static int +testNetworkDefine(const void *data) +{ + const struct objecteventTest *test = data; + struct lifecycleEventCounter counter; + int eventId = (VIR_EVENT_NAMESPACE_NETWORK << 8) + VIR_NETWORK_EVENT_ID_LIFECYCLE; + virNetworkPtr net; + int id; + int ret = 0; + + lifecycleEventCounter_reset(&counter); + + id = virConnectNetworkEventRegisterAny(test->conn, NULL, eventId, + VIR_NETWORK_EVENT_CALLBACK(&networkLifecycleCb), + &counter, NULL); + + /* Make sure the define event is triggered */ + net = virNetworkDefineXML(test->conn, networkDef); + + if (virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.defineEvents != 1) { + ret = -1; + goto cleanup; + } + + /* Make sure the undefine event is triggered */ + virNetworkUndefine(net); + + if (virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.undefineEvents != 1) { + ret = -1; + goto cleanup; + } + + +cleanup: + virConnectNetworkEventDeregisterAny(test->conn, id); + virNetworkFree(net); + + return ret; +} + +static int +testNetworkStartStopEvent(const void *data) +{ + const struct objecteventTest *test = data; + struct lifecycleEventCounter counter; + int eventId = (VIR_EVENT_NAMESPACE_NETWORK << 8) + VIR_NETWORK_EVENT_ID_LIFECYCLE; + int id; + int ret = 0; + + lifecycleEventCounter_reset(&counter); + + id = virConnectNetworkEventRegisterAny(test->conn, test->net, eventId, + VIR_NETWORK_EVENT_CALLBACK(&networkLifecycleCb), + &counter, NULL); + virNetworkCreate(test->net); + virNetworkDestroy(test->net); + + if (virEventRunDefaultImpl() < 0) { + ret = -1; + goto cleanup; + } + + if (counter.startEvents != 1 || counter.stopEvents != 1) { + ret = -1; + goto cleanup; + } +cleanup: + virConnectNetworkEventDeregisterAny(test->conn, id); + + return ret; +} + +static int mymain(void) { struct objecteventTest test; @@ -234,6 +384,21 @@ mymain(void) if (virtTestRun("Domain start stop events", testDomainStartStopEvent, &test) < 0) ret = EXIT_FAILURE; + /* Network event tests */ + /* Tests requiring the test network not to be set up*/ + if (virtTestRun("Network createXML start event ", testNetworkCreateXML, &test) < 0) + ret = EXIT_FAILURE; + if (virtTestRun("Network (un)define events", testNetworkDefine, &test) < 0) + ret = EXIT_FAILURE; + + /* Define a test network */ + test.net = virNetworkDefineXML(test.conn, networkDef); + if (virtTestRun("Network start stop events ", testNetworkStartStopEvent, &test) < 0) + ret = EXIT_FAILURE; + + /* Cleanup */ + virNetworkUndefine(test.net); + virNetworkFree(test.net); virConnectClose(test.conn); return ret; -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:07PM +0100, Cédric Bosdonnat wrote:
--- tests/objecteventtest.c | 165 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 165 insertions(+)
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 :|
into remoteDispatchObjectEventSend as it will later be used for both the domain and network events. --- daemon/remote.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index decaecc..f060006 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -108,7 +108,7 @@ remoteSerializeDomainDiskErrors(virDomainDiskErrorPtr errors, /* Prototypes */ static void -remoteDispatchDomainEventSend(virNetServerClientPtr client, +remoteDispatchObjectEventSend(virNetServerClientPtr client, virNetServerProgramPtr program, int procnr, xdrproc_t proc, @@ -134,7 +134,7 @@ static int remoteRelayDomainEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED, data.event = event; data.detail = detail; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE, (xdrproc_t)xdr_remote_domain_event_lifecycle_msg, &data); @@ -157,7 +157,7 @@ static int remoteRelayDomainEventReboot(virConnectPtr conn ATTRIBUTE_UNUSED, memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_REBOOT, (xdrproc_t)xdr_remote_domain_event_reboot_msg, &data); @@ -183,7 +183,7 @@ static int remoteRelayDomainEventRTCChange(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); data.offset = offset; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE, (xdrproc_t)xdr_remote_domain_event_rtc_change_msg, &data); @@ -209,7 +209,7 @@ static int remoteRelayDomainEventWatchdog(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); data.action = action; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_WATCHDOG, (xdrproc_t)xdr_remote_domain_event_watchdog_msg, &data); @@ -240,7 +240,7 @@ static int remoteRelayDomainEventIOError(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); data.action = action; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_IO_ERROR, (xdrproc_t)xdr_remote_domain_event_io_error_msg, &data); @@ -279,7 +279,7 @@ static int remoteRelayDomainEventIOErrorReason(virConnectPtr conn ATTRIBUTE_UNUS make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON, (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg, &data); @@ -342,7 +342,7 @@ static int remoteRelayDomainEventGraphics(virConnectPtr conn ATTRIBUTE_UNUSED, } make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_GRAPHICS, (xdrproc_t)xdr_remote_domain_event_graphics_msg, &data); @@ -388,7 +388,7 @@ static int remoteRelayDomainEventBlockJob(virConnectPtr conn ATTRIBUTE_UNUSED, data.status = status; make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB, (xdrproc_t)xdr_remote_domain_event_block_job_msg, &data); @@ -415,7 +415,7 @@ static int remoteRelayDomainEventControlError(virConnectPtr conn ATTRIBUTE_UNUSE memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR, (xdrproc_t)xdr_remote_domain_event_control_error_msg, &data); @@ -461,7 +461,7 @@ static int remoteRelayDomainEventDiskChange(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE, (xdrproc_t)xdr_remote_domain_event_disk_change_msg, &data); @@ -497,7 +497,7 @@ static int remoteRelayDomainEventTrayChange(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE, (xdrproc_t)xdr_remote_domain_event_tray_change_msg, &data); @@ -520,7 +520,7 @@ static int remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED, memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP, (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg, &data); @@ -543,7 +543,7 @@ static int remoteRelayDomainEventPMSuspend(virConnectPtr conn ATTRIBUTE_UNUSED, memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND, (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg, &data); @@ -569,7 +569,7 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); data.actual = actual; - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE, (xdrproc_t)xdr_remote_domain_event_balloon_change_msg, &data); @@ -593,7 +593,7 @@ static int remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn ATTRIBUTE_UNUS memset(&data, 0, sizeof(data)); make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK, (xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg, &data); @@ -623,7 +623,7 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn ATTRIBUTE_UNUSED, make_nonnull_domain(&data.dom, dom); - remoteDispatchDomainEventSend(client, remoteProgram, + remoteDispatchObjectEventSend(client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED, (xdrproc_t)xdr_remote_domain_event_device_removed_msg, &data); @@ -3158,7 +3158,7 @@ cleanup: } static void -remoteDispatchDomainEventSend(virNetServerClientPtr client, +remoteDispatchObjectEventSend(virNetServerClientPtr client, virNetServerProgramPtr program, int procnr, xdrproc_t proc, -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:08PM +0100, Cédric Bosdonnat wrote:
into remoteDispatchObjectEventSend as it will later be used for both the domain and network events. --- daemon/remote.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-)
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 :|
--- daemon/libvirtd.h | 1 + daemon/remote.c | 139 +++++++++++++++++++++++++++++++++++++++++++ src/remote/remote_driver.c | 126 +++++++++++++++++++++++++++++++++++++++ src/remote/remote_protocol.x | 46 +++++++++++++- 4 files changed, 311 insertions(+), 1 deletion(-) diff --git a/daemon/libvirtd.h b/daemon/libvirtd.h index d0afdc8..47f2589 100644 --- a/daemon/libvirtd.h +++ b/daemon/libvirtd.h @@ -50,6 +50,7 @@ struct daemonClientPrivate { virMutex lock; int domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LAST]; + int networkEventCallbackID[VIR_NETWORK_EVENT_ID_LAST]; # if WITH_SASL virNetSASLSessionPtr sasl; diff --git a/daemon/remote.c b/daemon/remote.c index f060006..6281d08 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -653,6 +653,37 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = { verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST); +static int remoteRelayNetworkEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED, + virNetworkPtr net, + int event, + void *opaque) +{ + virNetServerClientPtr client = opaque; + remote_network_event_lifecycle_msg data; + + if (!client) + return -1; + + VIR_DEBUG("Relaying network lifecycle event %d", event); + + /* build return data */ + memset(&data, 0, sizeof(data)); + make_nonnull_network(&data.net, net); + data.event = event; + + remoteDispatchObjectEventSend(client, remoteProgram, + REMOTE_PROC_NETWORK_EVENT_LIFECYCLE, + (xdrproc_t)xdr_remote_network_event_lifecycle_msg, &data); + + return 0; +} + +static virConnectNetworkEventGenericCallback networkEventCallbacks[] = { + VIR_NETWORK_EVENT_CALLBACK(remoteRelayNetworkEventLifecycle), +}; + +verify(ARRAY_CARDINALITY(networkEventCallbacks) == VIR_NETWORK_EVENT_ID_LAST); + /* * You must hold lock for at least the client * We don't free stuff here, merely disconnect the client's @@ -680,6 +711,15 @@ void remoteClientFreeFunc(void *data) priv->domainEventCallbackID[i] = -1; } + for (i = 0; i < VIR_NETWORK_EVENT_ID_LAST; i++) { + if (priv->networkEventCallbackID[i] != -1) { + VIR_DEBUG("Deregistering to relay remote events %zu", i); + virConnectNetworkEventDeregisterAny(priv->conn, + priv->networkEventCallbackID[i]); + } + priv->networkEventCallbackID[i] = -1; + } + virConnectClose(priv->conn); virIdentitySetCurrent(NULL); @@ -716,6 +756,9 @@ void *remoteClientInitHook(virNetServerClientPtr client, for (i = 0; i < VIR_DOMAIN_EVENT_ID_LAST; i++) priv->domainEventCallbackID[i] = -1; + for (i = 0; i < VIR_NETWORK_EVENT_ID_LAST; i++) + priv->networkEventCallbackID[i] = -1; + virNetServerClientSetCloseHook(client, remoteClientCloseFunc); return priv; } @@ -5216,6 +5259,102 @@ cleanup: } +static int +remoteDispatchConnectNetworkEventRegisterAny(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED, + remote_connect_network_event_register_any_args *args, + remote_connect_network_event_register_any_ret *ret ATTRIBUTE_UNUSED) +{ + int callbackID; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + virMutexLock(&priv->lock); + + if ((args->eventID & 0xFF) >= VIR_NETWORK_EVENT_ID_LAST || + ((args->eventID & 0xFF00) >> 8) != VIR_EVENT_NAMESPACE_NETWORK) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"), args->eventID); + goto cleanup; + } + + if (priv->networkEventCallbackID[args->eventID & 0xFF] != -1) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("network event %d already registered"), args->eventID); + goto cleanup; + } + + if ((callbackID = virConnectNetworkEventRegisterAny(priv->conn, + NULL, + args->eventID, + networkEventCallbacks[args->eventID & 0xFF], + client, NULL)) < 0) + goto cleanup; + + priv->networkEventCallbackID[args->eventID & 0xFF] = callbackID; + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + virMutexUnlock(&priv->lock); + return rv; +} + + +static int +remoteDispatchConnectNetworkEventDeregisterAny(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED, + remote_connect_network_event_deregister_any_args *args, + remote_connect_network_event_deregister_any_ret *ret ATTRIBUTE_UNUSED) +{ + int callbackID = -1; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + virMutexLock(&priv->lock); + + if ((args->eventID & 0xFF) >= VIR_NETWORK_EVENT_ID_LAST || + ((args->eventID & 0xFF00) >> 8) != VIR_EVENT_NAMESPACE_NETWORK) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"), args->eventID); + goto cleanup; + } + + callbackID = priv->networkEventCallbackID[args->eventID & 0xFF]; + if (callbackID < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("network event %d not registered"), args->eventID); + goto cleanup; + } + + if (virConnectNetworkEventDeregisterAny(priv->conn, callbackID) < 0) + goto cleanup; + + priv->networkEventCallbackID[args->eventID & 0xFF] = -1; + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + virMutexUnlock(&priv->lock); + return rv; +} + /*----- Helpers. -----*/ diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 4a84a52..593443c 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -273,6 +273,11 @@ remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog, virNetClientPtr client, void *evdata, void *opaque); +static void +remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, + virNetClientPtr client ATTRIBUTE_UNUSED, + void *evdata, void *opaque); + static virNetClientProgramEvent remoteDomainEvents[] = { { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE, remoteDomainBuildEventRTCChange, @@ -338,6 +343,10 @@ static virNetClientProgramEvent remoteDomainEvents[] = { remoteDomainBuildEventDeviceRemoved, sizeof(remote_domain_event_device_removed_msg), (xdrproc_t)xdr_remote_domain_event_device_removed_msg }, + { REMOTE_PROC_NETWORK_EVENT_LIFECYCLE, + remoteNetworkBuildEventLifecycle, + sizeof(remote_network_event_lifecycle_msg), + (xdrproc_t)xdr_remote_network_event_lifecycle_msg }, }; enum virDrvOpenRemoteFlags { @@ -2902,6 +2911,99 @@ done: } static int +remoteConnectNetworkEventRegisterAny(virConnectPtr conn, + virNetworkPtr net, + int eventID, + virConnectNetworkEventGenericCallback callback, + void *opaque, + virFreeCallback freecb) +{ + int rv = -1; + struct private_data *priv = conn->privateData; + remote_connect_network_event_register_any_args args; + int callbackID; + int count; + + remoteDriverLock(priv); + + if ((count = virNetworkEventStateRegisterID(conn, + priv->domainEventState, + net, eventID, + VIR_OBJECT_EVENT_CALLBACK(callback), + opaque, freecb, + &callbackID)) < 0) { + virReportError(VIR_ERR_RPC, "%s", _("adding cb to list")); + goto done; + } + + /* If this is the first callback for this eventID, we need to enable + * events on the server */ + if (count == 1) { + args.eventID = eventID; + + if (call(conn, priv, 0, REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY, + (xdrproc_t) xdr_remote_connect_network_event_register_any_args, (char *) &args, + (xdrproc_t) xdr_void, (char *)NULL) == -1) { + virObjectEventStateDeregisterID(conn, + priv->domainEventState, + callbackID); + goto done; + } + } + + rv = callbackID; + +done: + remoteDriverUnlock(priv); + return rv; +} + + +static int +remoteConnectNetworkEventDeregisterAny(virConnectPtr conn, + int callbackID) +{ + struct private_data *priv = conn->privateData; + int rv = -1; + remote_connect_network_event_deregister_any_args args; + int eventID; + int count; + + remoteDriverLock(priv); + + if ((eventID = virObjectEventStateEventID(conn, + priv->domainEventState, + callbackID)) < 0) { + virReportError(VIR_ERR_RPC, _("unable to find callback ID %d"), callbackID); + goto done; + } + + if ((count = virObjectEventStateDeregisterID(conn, + priv->domainEventState, + callbackID)) < 0) { + virReportError(VIR_ERR_RPC, _("unable to find callback ID %d"), callbackID); + goto done; + } + + /* If that was the last callback for this eventID, we need to disable + * events on the server */ + if (count == 0) { + args.eventID = eventID; + + if (call(conn, priv, 0, REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY, + (xdrproc_t) xdr_remote_connect_network_event_deregister_any_args, (char *) &args, + (xdrproc_t) xdr_void, (char *) NULL) == -1) + goto done; + } + + rv = 0; + +done: + remoteDriverUnlock(priv); + return rv; +} + +static int remoteConnectListAllInterfaces(virConnectPtr conn, virInterfacePtr **ifaces, unsigned int flags) @@ -4800,6 +4902,28 @@ remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog ATTRIBUTE_UNUSED } +static void +remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, + virNetClientPtr client ATTRIBUTE_UNUSED, + void *evdata, void *opaque) +{ + virConnectPtr conn = opaque; + struct private_data *priv = conn->privateData; + remote_network_event_lifecycle_msg *msg = evdata; + virNetworkPtr net; + virObjectEventPtr event = NULL; + + net = get_nonnull_network(conn, msg->net); + if (!net) + return; + + event = virNetworkEventLifecycleNew(net->name, net->uuid, msg->event); + virNetworkFree(net); + + remoteDomainEventQueue(priv, event); +} + + static virDrvOpenStatus ATTRIBUTE_NONNULL(1) remoteSecretOpen(virConnectPtr conn, virConnectAuthPtr auth, unsigned int flags) @@ -7035,6 +7159,8 @@ static virNetworkDriver network_driver = { .connectNumOfDefinedNetworks = remoteConnectNumOfDefinedNetworks, /* 0.3.0 */ .connectListDefinedNetworks = remoteConnectListDefinedNetworks, /* 0.3.0 */ .connectListAllNetworks = remoteConnectListAllNetworks, /* 0.10.2 */ + .connectNetworkEventDeregisterAny = remoteConnectNetworkEventDeregisterAny, /* 1.2.1 */ + .connectNetworkEventRegisterAny = remoteConnectNetworkEventRegisterAny, /* 1.2.1 */ .networkLookupByUUID = remoteNetworkLookupByUUID, /* 0.3.0 */ .networkLookupByName = remoteNetworkLookupByName, /* 0.3.0 */ .networkCreateXML = remoteNetworkCreateXML, /* 0.3.0 */ diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index f942670..c3d544f 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2849,6 +2849,30 @@ struct remote_connect_get_cpu_model_names_ret { int ret; }; +struct remote_connect_network_event_register_any_args { + int eventID; +}; + +struct remote_connect_network_event_register_any_ret { + int cb_registered; +}; + +struct remote_connect_network_event_deregister_any_args { + int eventID; +}; + +struct remote_connect_network_event_deregister_any_ret { + int cb_registered; +}; + +struct remote_network_event_lifecycle_msg { + remote_nonnull_network net; + int event; + int detail; +}; + + + /*----- Protocol. -----*/ /* Define the program number, protocol version and procedure numbers here. */ @@ -5018,5 +5042,25 @@ enum remote_procedure { * @generate: none * @acl: connect:read */ - REMOTE_PROC_CONNECT_GET_CPU_MODEL_NAMES = 312 + REMOTE_PROC_CONNECT_GET_CPU_MODEL_NAMES = 312, + + /** + * @generate: none + * @priority: high + * @acl: connect:read + */ + REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY = 313, + + /** + * @generate: none + * @priority: high + * @acl: connect:read + */ + REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY = 314, + + /** + * @generate: both + * @acl: none + */ + REMOTE_PROC_NETWORK_EVENT_LIFECYCLE = 315 }; -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:09PM +0100, Cédric Bosdonnat wrote:
--- daemon/libvirtd.h | 1 + daemon/remote.c | 139 +++++++++++++++++++++++++++++++++++++++++++ src/remote/remote_driver.c | 126 +++++++++++++++++++++++++++++++++++++++ src/remote/remote_protocol.x | 46 +++++++++++++- 4 files changed, 311 insertions(+), 1 deletion(-)
ACK
+static int +remoteDispatchConnectNetworkEventRegisterAny(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client ATTRIBUTE_UNUSED, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED, + remote_connect_network_event_register_any_args *args, + remote_connect_network_event_register_any_ret *ret ATTRIBUTE_UNUSED) +{ + int callbackID; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + virMutexLock(&priv->lock); + + if ((args->eventID & 0xFF) >= VIR_NETWORK_EVENT_ID_LAST || + ((args->eventID & 0xFF00) >> 8) != VIR_EVENT_NAMESPACE_NETWORK) { + virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"), args->eventID); + goto cleanup; + }
Not sure I see why you're checking the namespace here. This API only ever handles the network events, so shouldn't eventID just directly reflect the EVENT_ID passed in by the application to the register API call 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/network/bridge_driver.c | 89 ++++++++++++++++++++++++++++++++++++ src/network/bridge_driver_platform.h | 3 ++ 2 files changed, 92 insertions(+) diff --git a/src/network/bridge_driver.c b/src/network/bridge_driver.c index 1e4cc70..8e1f3f7 100644 --- a/src/network/bridge_driver.c +++ b/src/network/bridge_driver.c @@ -438,6 +438,8 @@ networkStateInitialize(bool privileged, networkReloadFirewallRules(driverState); networkRefreshDaemons(driverState); + driverState->networkEventState = virObjectEventStateNew(); + networkDriverUnlock(driverState); #ifdef HAVE_FIREWALLD @@ -532,6 +534,8 @@ networkStateCleanup(void) { networkDriverLock(driverState); + virObjectEventStateFree(driverState->networkEventState); + /* free inactive networks */ virNetworkObjListFree(&driverState->networks); @@ -2290,6 +2294,55 @@ cleanup: return ret; } +static int +networkConnectNetworkEventRegisterAny(virConnectPtr conn, + virNetworkPtr net, + int eventID, + virConnectNetworkEventGenericCallback callback, + void *opaque, + virFreeCallback freecb) +{ + virNetworkDriverStatePtr driver = conn->networkPrivateData; + int ret = -1; + + networkDriverLock(driver); + + if (virConnectNetworkEventRegisterAnyEnsureACL(conn) < 0) + goto cleanup; + + if (virNetworkEventStateRegisterID(conn, driver->networkEventState, + net, eventID, + VIR_OBJECT_EVENT_CALLBACK(callback), + opaque, freecb, &ret) < 0) + ret = -1; + + networkDriverUnlock(driver); + +cleanup: + return ret; +} + +static int +networkConnectNetworkEventDeregisterAny(virConnectPtr conn, + int callbackID) +{ + virNetworkDriverStatePtr driver = conn->networkPrivateData; + int ret = -1; + + if (virConnectNetworkEventDeregisterAnyEnsureACL(conn) < 0) + goto cleanup; + + + networkDriverLock(driver); + ret = virObjectEventStateDeregisterID(conn, + driver->networkEventState, + callbackID); + networkDriverUnlock(driver); + +cleanup: + return ret; +} + static int networkIsActive(virNetworkPtr net) { virNetworkObjPtr obj; @@ -2483,6 +2536,7 @@ static virNetworkPtr networkCreateXML(virConnectPtr conn, const char *xml) { virNetworkDefPtr def; virNetworkObjPtr network = NULL; virNetworkPtr ret = NULL; + virObjectEventPtr event = NULL; networkDriverLock(driver); @@ -2509,11 +2563,17 @@ static virNetworkPtr networkCreateXML(virConnectPtr conn, const char *xml) { goto cleanup; } + event = virNetworkEventLifecycleNew(network->def->name, + network->def->uuid, + VIR_NETWORK_EVENT_STARTED); + VIR_INFO("Creating network '%s'", network->def->name); ret = virGetNetwork(conn, network->def->name, network->def->uuid); cleanup: virNetworkDefFree(def); + if (event) + virObjectEventStateQueue(driver->networkEventState, event); if (network) virNetworkObjUnlock(network); networkDriverUnlock(driver); @@ -2526,6 +2586,7 @@ static virNetworkPtr networkDefineXML(virConnectPtr conn, const char *xml) { bool freeDef = true; virNetworkObjPtr network = NULL; virNetworkPtr ret = NULL; + virObjectEventPtr event = NULL; networkDriverLock(driver); @@ -2565,10 +2626,15 @@ static virNetworkPtr networkDefineXML(virConnectPtr conn, const char *xml) { goto cleanup; } + event = virNetworkEventLifecycleNew(def->name, def->uuid, + VIR_NETWORK_EVENT_DEFINED); + VIR_INFO("Defining network '%s'", def->name); ret = virGetNetwork(conn, def->name, def->uuid); cleanup: + if (event) + virObjectEventStateQueue(driver->networkEventState, event); if (freeDef) virNetworkDefFree(def); if (network) @@ -2583,6 +2649,7 @@ networkUndefine(virNetworkPtr net) { virNetworkObjPtr network; int ret = -1; bool active = false; + virObjectEventPtr event = NULL; networkDriverLock(driver); @@ -2610,6 +2677,10 @@ networkUndefine(virNetworkPtr net) { virNetworkDefFree(network->newDef); network->newDef = NULL; + event = virNetworkEventLifecycleNew(network->def->name, + network->def->uuid, + VIR_NETWORK_EVENT_UNDEFINED); + VIR_INFO("Undefining network '%s'", network->def->name); if (!active) { if (networkRemoveInactive(driver, network) < 0) { @@ -2622,6 +2693,8 @@ networkUndefine(virNetworkPtr net) { ret = 0; cleanup: + if (event) + virObjectEventStateQueue(driver->networkEventState, event); if (network) virNetworkObjUnlock(network); networkDriverUnlock(driver); @@ -2805,6 +2878,7 @@ static int networkCreate(virNetworkPtr net) { virNetworkDriverStatePtr driver = net->conn->networkPrivateData; virNetworkObjPtr network; int ret = -1; + virObjectEventPtr event = NULL; networkDriverLock(driver); network = virNetworkFindByUUID(&driver->networks, net->uuid); @@ -2820,7 +2894,13 @@ static int networkCreate(virNetworkPtr net) { ret = networkStartNetwork(driver, network); + event = virNetworkEventLifecycleNew(network->def->name, + network->def->uuid, + VIR_NETWORK_EVENT_STARTED); + cleanup: + if (event) + virObjectEventStateQueue(driver->networkEventState, event); if (network) virNetworkObjUnlock(network); networkDriverUnlock(driver); @@ -2831,6 +2911,7 @@ static int networkDestroy(virNetworkPtr net) { virNetworkDriverStatePtr driver = net->conn->networkPrivateData; virNetworkObjPtr network; int ret = -1; + virObjectEventPtr event = NULL; networkDriverLock(driver); network = virNetworkFindByUUID(&driver->networks, net->uuid); @@ -2853,6 +2934,10 @@ static int networkDestroy(virNetworkPtr net) { if ((ret = networkShutdownNetwork(driver, network)) < 0) goto cleanup; + event = virNetworkEventLifecycleNew(network->def->name, + network->def->uuid, + VIR_NETWORK_EVENT_STOPPED); + if (!network->persistent) { if (networkRemoveInactive(driver, network) < 0) { network = NULL; @@ -2863,6 +2948,8 @@ static int networkDestroy(virNetworkPtr net) { } cleanup: + if (event) + virObjectEventStateQueue(driver->networkEventState, event); if (network) virNetworkObjUnlock(network); networkDriverUnlock(driver); @@ -3021,6 +3108,8 @@ static virNetworkDriver networkDriver = { .connectNumOfDefinedNetworks = networkConnectNumOfDefinedNetworks, /* 0.2.0 */ .connectListDefinedNetworks = networkConnectListDefinedNetworks, /* 0.2.0 */ .connectListAllNetworks = networkConnectListAllNetworks, /* 0.10.2 */ + .connectNetworkEventRegisterAny = networkConnectNetworkEventRegisterAny, /* 1.2.1 */ + .connectNetworkEventDeregisterAny = networkConnectNetworkEventDeregisterAny, /* 1.2.1 */ .networkLookupByUUID = networkLookupByUUID, /* 0.2.0 */ .networkLookupByName = networkLookupByName, /* 0.2.0 */ .networkCreateXML = networkCreateXML, /* 0.2.0 */ diff --git a/src/network/bridge_driver_platform.h b/src/network/bridge_driver_platform.h index 289ab79..82d96f6 100644 --- a/src/network/bridge_driver_platform.h +++ b/src/network/bridge_driver_platform.h @@ -29,6 +29,7 @@ # include "virthread.h" # include "virdnsmasq.h" # include "network_conf.h" +# include "object_event.h" /* Main driver state */ struct _virNetworkDriverState { @@ -43,6 +44,8 @@ struct _virNetworkDriverState { char *dnsmasqStateDir; char *radvdStateDir; dnsmasqCapsPtr dnsmasqCaps; + + virObjectEventStatePtr networkEventState; }; typedef struct _virNetworkDriverState virNetworkDriverState; -- 1.8.4.2
On Fri, Nov 29, 2013 at 04:19:10PM +0100, Cédric Bosdonnat wrote:
--- src/network/bridge_driver.c | 89 ++++++++++++++++++++++++++++++++++++ src/network/bridge_driver_platform.h | 3 ++ 2 files changed, 92 insertions(+)
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:18:36PM +0100, Cédric Bosdonnat wrote:
This patch serie is replacing the previous one I sent. The improvements that were made in between are: * splitting the 2 huge commits into smaller reviewable ones. * Get rid of the huge union in virDomainEvent and use virObjects instead. * No domain events-related code in object_event.c. I left the network events related code there as it would be pretty small in a separate set of files. * Rebased on the python split repository
This all looks pretty good to me. The only thing I'm not really liking is the VIR_EVENT_NAMESPACE stuff exposed in the public header. Since we have separate public APIs for registering event callbacks for each type of object, there is no need to have namespaces for event IDs from an app developers POV. I understand you want to encode things into a single event ID space internally for ease of handling, but I think we should not expose this to apps.
I saw something weird in the domain events code when working on this: VIR_DOMAIN_EVENT_LAST is defined if VIR_ENUM_SENTINELS is defined, but is generally used independently of it. I did the same for the VIR_NETWORK_EVENT_LAST thought I'm not sure that's the correct thing to do.
The internal code alwas has VIR_ENUM_SENTINELS defined so can rely on using any _LAST constant. We simply hide from the client applications by default.
These changes are all about bringing events for network object like the ones existing for domains. This feature is needed for virt-manager to refresh its UI when networks are started/destroyed/defined/undefined.
The network events are implemented in the test, bridge network and remote drivers ATM.
Regards, 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 29.11.2013 16:18, Cédric Bosdonnat wrote:
This patch serie is replacing the previous one I sent. The improvements that were made in between are: * splitting the 2 huge commits into smaller reviewable ones. * Get rid of the huge union in virDomainEvent and use virObjects instead. * No domain events-related code in object_event.c. I left the network events related code there as it would be pretty small in a separate set of files. * Rebased on the python split repository
I saw something weird in the domain events code when working on this: VIR_DOMAIN_EVENT_LAST is defined if VIR_ENUM_SENTINELS is defined, but is generally used independently of it. I did the same for the VIR_NETWORK_EVENT_LAST thought I'm not sure that's the correct thing to do.
These changes are all about bringing events for network object like the ones existing for domains. This feature is needed for virt-manager to refresh its UI when networks are started/destroyed/defined/undefined.
The network events are implemented in the test, bridge network and remote drivers ATM.
Cédric Bosdonnat (34): Added domain start/stop/define/undefine event unit tests Rename virDomainEventCallback to virObjectEventCallback Renamed virDomainMeta to virObjectMeta Renamed virDomainEventQueue to virObjectEventQueue Renamed virDomainEventState to virObjectEventState Renamed virDomainEventCallbackList* to virObjectEventCallbackList* Created virObjectEventStateRegisterID virObject-ified virDomainEvent Create virDomainEventLifecycle to start removing the huge union Renamed virDomainEventNew* to virDomainEventLifecycleNew* Renamed virDomainEventNewInternal to virDomainEventNew Create virDomainEventRTCChange to get rid of the huge union Created virDomainEventWatchdog to get rid of the huge union Created virDomainEventIOError Created virDomainEventGraphics Created virDomainEventBlockJob Create virDomainEventDiskChange Created virDomainEventTrayChange Created virDomainEventBalloonChange Created virDomainEventDeviceRemoved and removed the huge union Changed the remaining domain event creation methods results to void* Removed virDomainEventPtr in favor of virObjectEventPtr Add object event namespaces for the event IDs Renamed virDomainEventTimer to virObjectEventTimer Split the virObjectEvent and virDomainEvent* to separate them after Extracted common parts of domain_event.[ch] to object_event.[ch] Added virNetworkEventLifecycle object Added API for network events similar to the one from Domain events test driver: renamed testDomainEventQueue into testObjectEventQueue test driver: implemented network events Add network events unit tests daemon/remote.c: renamed remoteDispatchDomainEventSend Add network events to the remote driver Added network events to the bridged network driver
.gitignore | 1 + cfg.mk | 6 +- daemon/libvirtd.h | 1 + daemon/remote.c | 175 ++- include/libvirt/libvirt.h.in | 86 ++ src/Makefile.am | 6 + src/conf/domain_event.c | 1954 ++++++++++++++-------------------- src/conf/domain_event.h | 219 ++-- src/conf/object_event.c | 903 ++++++++++++++++ src/conf/object_event.h | 113 ++ src/conf/object_event_private.h | 113 ++ src/driver.h | 14 + src/libvirt.c | 133 +++ src/libvirt_private.syms | 25 +- src/libvirt_public.syms | 7 + src/libxl/libxl_conf.h | 2 +- src/libxl/libxl_driver.c | 46 +- src/lxc/lxc_conf.h | 2 +- src/lxc/lxc_driver.c | 54 +- src/lxc/lxc_process.c | 20 +- src/network/bridge_driver.c | 89 ++ src/network/bridge_driver_platform.h | 3 + src/parallels/parallels_utils.h | 2 +- src/qemu/qemu_conf.h | 2 +- src/qemu/qemu_domain.c | 6 +- src/qemu/qemu_domain.h | 2 +- src/qemu/qemu_driver.c | 116 +- src/qemu/qemu_hotplug.c | 10 +- src/qemu/qemu_migration.c | 38 +- src/qemu/qemu_process.c | 70 +- src/remote/remote_driver.c | 178 +++- src/remote/remote_protocol.x | 46 +- src/test/test_driver.c | 197 ++-- src/uml/uml_conf.h | 2 +- src/uml/uml_driver.c | 44 +- src/vbox/vbox_tmpl.c | 22 +- src/xen/xen_driver.c | 10 +- src/xen/xen_driver.h | 4 +- src/xen/xen_inotify.c | 10 +- src/xen/xs_internal.c | 20 +- tests/Makefile.am | 7 + tests/objecteventtest.c | 407 +++++++ tests/qemuhotplugtest.c | 2 +- 43 files changed, 3525 insertions(+), 1642 deletions(-) create mode 100644 src/conf/object_event.c create mode 100644 src/conf/object_event.h create mode 100644 src/conf/object_event_private.h create mode 100644 tests/objecteventtest.c
I'm getting some compile errors on ARM: CC conf/libvirt_conf_la-domain_event.lo conf/domain_event.c: In function 'virDomainEventDispatchDefaultFunc': conf/domain_event.c:1148:30: error: cast increases required alignment of target type [-Werror=cast-align] rtcChangeEvent = (virDomainEventRTCChangePtr)event; ^ conf/domain_event.c:1264:34: error: cast increases required alignment of target type [-Werror=cast-align] balloonChangeEvent = (virDomainEventBalloonChangePtr)event; ^ Michal
On 12/11/2013 06:18 AM, Michal Privoznik wrote:
I'm getting some compile errors on ARM:
CC conf/libvirt_conf_la-domain_event.lo conf/domain_event.c: In function 'virDomainEventDispatchDefaultFunc': conf/domain_event.c:1148:30: error: cast increases required alignment of target type [-Werror=cast-align] rtcChangeEvent = (virDomainEventRTCChangePtr)event;
Hmm. In this case, event is virObjectEventPtr, and rtcChangeEvent is virDomainEventRTCChangePtr. Comparing the two structs, I see the problem: struct _virObjectEvent { virObject parent; int eventID; virObjectMeta meta; }; Only has alignment specified by virObject (which in turn is unsigned int, int, void*), int, and virObjectMeta (which in turn is int, char*, unsigned char[]). vs. struct _virDomainEventRTCChange { virDomainEvent parent; long long offset; }; I think one possible solution would be as simple as altering src/util/virobject.h to change 'magic' from 'unsigned int' to 'unsigned long long' - then ALL virObject structs will be forcefully aligned to the worst case between void* and long long, so that any subclass can use long long without requiring stricter alignment than the parent class, and so that downcasting code like domain_event.c no longer warns. But it does make every object consume more memory on 64-bit platforms (from 16 bytes into 24 bytes), is that okay? -- Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
On 12/11/2013 12:15 PM, Eric Blake wrote:
struct _virObjectEvent { virObject parent; int eventID; virObjectMeta meta; };
Only has alignment specified by virObject (which in turn is unsigned int, int, void*),
struct _virObject { unsigned int magic; int refs; virClassPtr klass; };
I think one possible solution would be as simple as altering src/util/virobject.h to change 'magic' from 'unsigned int' to 'unsigned long long' - then ALL virObject structs will be forcefully aligned to the worst case between void* and long long, so that any subclass can use long long without requiring stricter alignment than the parent class, and so that downcasting code like domain_event.c no longer warns. But it does make every object consume more memory on 64-bit platforms (from 16 bytes into 24 bytes), is that okay?
Or maybe even change _virObject to contain a union: struct _virObject { union { long long align; struct { unsigned int magic; int refs; } s; } u; virClassPtr klass; } which keeps the size at 16 bytes on 64-bit platform, keeps things at 12 bytes on 32-bit platforms that don't care about long long alignment, and for ARM (*) would change things from 12 to 16 bytes with 8-byte alignment for the long long. Yeah, that means using obj->u.s.refs instead of obj->refs, but most code shouldn't be directly mucking with object-internal fields, so hopefully the fallout would be limited to just virobject.c (if only C99 had anonymous struct/unions; C11 does, but we don't require that yet). (*) Am I correct that your platform with the compile failure is a 32-bit ARM platform with 4-byte pointers? Because if it were 64-bit, then I would have guessed that an 8-byte pointer would already be forcing 8-byte alignment, such that use of 'long long' in a subclass wouldn't be warning about changed alignment. -- Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
On 11.12.2013 20:28, Eric Blake wrote:
On 12/11/2013 12:15 PM, Eric Blake wrote:
struct _virObjectEvent { virObject parent; int eventID; virObjectMeta meta; };
Only has alignment specified by virObject (which in turn is unsigned int, int, void*),
struct _virObject { unsigned int magic; int refs; virClassPtr klass; };
I think one possible solution would be as simple as altering src/util/virobject.h to change 'magic' from 'unsigned int' to 'unsigned long long' - then ALL virObject structs will be forcefully aligned to the worst case between void* and long long, so that any subclass can use long long without requiring stricter alignment than the parent class, and so that downcasting code like domain_event.c no longer warns. But it does make every object consume more memory on 64-bit platforms (from 16 bytes into 24 bytes), is that okay?
Or maybe even change _virObject to contain a union:
struct _virObject { union { long long align; struct { unsigned int magic; int refs; } s; } u; virClassPtr klass; }
Yep. I can confirm that this works. This and all the subsequent code adaptations made me able to compile again. Will you post it as a patch please? Michal
On 12/12/2013 09:05 AM, Michal Privoznik wrote:
Or maybe even change _virObject to contain a union:
struct _virObject { union { long long align; struct { unsigned int magic; int refs; } s; } u; virClassPtr klass; }
Yep. I can confirm that this works. This and all the subsequent code adaptations made me able to compile again. Will you post it as a patch please?
Yes, I'll turn it into a formal patch. -- Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
On Wed, Dec 11, 2013 at 12:28:32PM -0700, Eric Blake wrote:
On 12/11/2013 12:15 PM, Eric Blake wrote:
struct _virObjectEvent { virObject parent; int eventID; virObjectMeta meta; };
Only has alignment specified by virObject (which in turn is unsigned int, int, void*),
struct _virObject { unsigned int magic; int refs; virClassPtr klass; };
I think one possible solution would be as simple as altering src/util/virobject.h to change 'magic' from 'unsigned int' to 'unsigned long long' - then ALL virObject structs will be forcefully aligned to the worst case between void* and long long, so that any subclass can use long long without requiring stricter alignment than the parent class, and so that downcasting code like domain_event.c no longer warns. But it does make every object consume more memory on 64-bit platforms (from 16 bytes into 24 bytes), is that okay?
Or maybe even change _virObject to contain a union:
struct _virObject { union { long long align; struct { unsigned int magic; int refs; } s; } u; virClassPtr klass; }
which keeps the size at 16 bytes on 64-bit platform, keeps things at 12 bytes on 32-bit platforms that don't care about long long alignment, and for ARM (*) would change things from 12 to 16 bytes with 8-byte alignment for the long long.
Yeah, that means using obj->u.s.refs instead of obj->refs, but most code shouldn't be directly mucking with object-internal fields, so hopefully the fallout would be limited to just virobject.c (if only C99 had anonymous struct/unions; C11 does, but we don't require that yet).
(*) Am I correct that your platform with the compile failure is a 32-bit ARM platform with 4-byte pointers? Because if it were 64-bit, then I would have guessed that an 8-byte pointer would already be forcing 8-byte alignment, such that use of 'long long' in a subclass wouldn't be warning about changed alignment.
That seems reasonable to me - it makes sense that we should have our base object type be nicely aligned, instead of trying to fix this in the events code (and potentially anywhere else using objects in the future). 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 :|
Sorry, I noticed just now that here you are discussing about the problem with the compilation of libvirt on ARM platforms. An alternative solution can be ATTRIBUTE_PACKED. I've sent right now to the ML a patch based on this. Michele On 12/12/2013 17:11, Daniel P. Berrange wrote:
On 12/11/2013 12:15 PM, Eric Blake wrote:
struct _virObjectEvent { virObject parent; int eventID; virObjectMeta meta; };
Only has alignment specified by virObject (which in turn is unsigned int, int, void*), struct _virObject { unsigned int magic; int refs; virClassPtr klass; };
I think one possible solution would be as simple as altering src/util/virobject.h to change 'magic' from 'unsigned int' to 'unsigned long long' - then ALL virObject structs will be forcefully aligned to the worst case between void* and long long, so that any subclass can use long long without requiring stricter alignment than the parent class, and so that downcasting code like domain_event.c no longer warns. But it does make every object consume more memory on 64-bit platforms (from 16 bytes into 24 bytes), is that okay? Or maybe even change _virObject to contain a union:
struct _virObject { union { long long align; struct { unsigned int magic; int refs; } s; } u; virClassPtr klass; }
which keeps the size at 16 bytes on 64-bit platform, keeps things at 12 bytes on 32-bit platforms that don't care about long long alignment, and for ARM (*) would change things from 12 to 16 bytes with 8-byte alignment for the long long.
Yeah, that means using obj->u.s.refs instead of obj->refs, but most code shouldn't be directly mucking with object-internal fields, so hopefully the fallout would be limited to just virobject.c (if only C99 had anonymous struct/unions; C11 does, but we don't require that yet).
(*) Am I correct that your platform with the compile failure is a 32-bit ARM platform with 4-byte pointers? Because if it were 64-bit, then I would have guessed that an 8-byte pointer would already be forcing 8-byte alignment, such that use of 'long long' in a subclass wouldn't be warning about changed alignment. That seems reasonable to me - it makes sense that we should have our base object type be nicely aligned, instead of trying to fix
On Wed, Dec 11, 2013 at 12:28:32PM -0700, Eric Blake wrote: this in the events code (and potentially anywhere else using objects in the future).
Daniel
-- *Michele Paolino*, Virtualization R&D Engineer Virtual Open Systems /Open Source KVM Virtualization Developments/ /Multicore Systems Virtualization Porting Services/ Web/:/www.virtualopensystems. <http://www.virtualopensystems.com/>com <http://www.virtualopensystems.com/>
participants (6)
-
Cedric Bosdonnat -
Cédric Bosdonnat
-
Daniel P. Berrange -
Eric Blake -
Michal Privoznik -
Michele Paolino