External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-10-05 22:05:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Turn virDomainObjList into an opaque virObject

Browse Source 
As a step towards making virDomainObjList thread-safe turn it
into an opaque virObject, preventing any direct access to its
internals.

As part of this a new method virDomainObjListForEach is
introduced to replace all existing usage of virHashForEach
This commit is contained in:
Daniel P. Berrange 2013-01-11 13:54:15 +00:00
parent 4f6ed6c33a
commit 37abd47165
19 changed files with 273 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/conf/domain_conf.c
View File

@ -58,6 +58,15 @@
* verify that it doesn't overflow an unsigned int when shifting */ * verify that it doesn't overflow an unsigned int when shifting */
verify(VIR_DOMAIN_VIRT_LAST <= 32); verify(VIR_DOMAIN_VIRT_LAST <= 32);
struct _virDomainObjList {
virObjectLockable parent;
/* uuid string -> virDomainObj mapping
* for O(1), lockless lookup-by-uuid */
virHashTable *objs;
};
/* Private flags used internally by virDomainSaveStatus and /* Private flags used internally by virDomainSaveStatus and
* virDomainLoadStatus. */ * virDomainLoadStatus. */
typedef enum { typedef enum {
@ -694,7 +703,9 @@ VIR_ENUM_IMPL(virDomainNumatuneMemPlacementMode,
#define VIR_DOMAIN_XML_READ_FLAGS VIR_DOMAIN_XML_INACTIVE #define VIR_DOMAIN_XML_READ_FLAGS VIR_DOMAIN_XML_INACTIVE
static virClassPtr virDomainObjClass; static virClassPtr virDomainObjClass;
static virClassPtr virDomainObjListClass;
static void virDomainObjDispose(void *obj); static void virDomainObjDispose(void *obj);
static void virDomainObjListDispose(void *obj);
static int virDomainObjOnceInit(void) static int virDomainObjOnceInit(void)
{ {
@ -704,6 +715,12 @@ static int virDomainObjOnceInit(void)
virDomainObjDispose))) virDomainObjDispose)))
return -1; return -1;
if (!(virDomainObjListClass = virClassNew(virClassForObjectLockable(),
"virDomainObjList",
sizeof(virDomainObjList),
virDomainObjListDispose)))
return -1;
return 0; return 0;
} }
@ -780,26 +797,26 @@ virDomainObjListPtr virDomainObjListNew(void)
{ {
virDomainObjListPtr doms; virDomainObjListPtr doms;
if (VIR_ALLOC(doms) < 0) { if (virDomainObjInitialize() < 0)
virReportOOMError(); return NULL;
if (!(doms = virObjectLockableNew(virDomainObjListClass)))
return NULL;
if (!(doms->objs = virHashCreate(50, virDomainObjListDataFree))) {
virObjectUnref(doms);
return NULL; return NULL;
} }
doms->objs = virHashCreate(50, virDomainObjListDataFree);
if (!doms->objs) {
VIR_FREE(doms);
return NULL;
}
return doms; return doms;
} }
void virDomainObjListFree(virDomainObjListPtr doms) static void virDomainObjListDispose(void *obj)
{ {
if (!doms) virDomainObjListPtr doms = obj;
return;
virHashFree(doms->objs); virHashFree(doms->objs);
VIR_FREE(doms);
} }
@ -15231,6 +15248,37 @@ cleanup:
return -1; return -1;
} }
struct virDomainListIterData {
virDomainObjListIterator callback;
void *opaque;
int ret;
};
static void
virDomainObjListHelper(void *payload,
const void *name ATTRIBUTE_UNUSED,
void *opaque)
{
struct virDomainListIterData *data = opaque;
if (data->callback(payload, data->opaque) < 0)
data->ret = -1;
}
int virDomainObjListForEach(virDomainObjListPtr doms,
virDomainObjListIterator callback,
void *opaque)
{
struct virDomainListIterData data = {
callback, opaque, 0,
};
virHashForEach(doms->objs, virDomainObjListHelper, &data);
return data.ret;
}
int virDomainChrDefForeach(virDomainDefPtr def, int virDomainChrDefForeach(virDomainDefPtr def,
bool abortOnError, bool abortOnError,
virDomainChrDefIterator iter, virDomainChrDefIterator iter,

14
src/conf/domain_conf.h
View File

@ -37,7 +37,6 @@
# include "virhash.h" # include "virhash.h"
# include "virsocketaddr.h" # include "virsocketaddr.h"
# include "nwfilter_params.h" # include "nwfilter_params.h"
# include "nwfilter_conf.h"
# include "virnetdevmacvlan.h" # include "virnetdevmacvlan.h"
# include "virsysinfo.h" # include "virsysinfo.h"
# include "virnetdevvportprofile.h" # include "virnetdevvportprofile.h"
@ -1893,11 +1892,6 @@ struct _virDomainObj {
typedef struct _virDomainObjList virDomainObjList; typedef struct _virDomainObjList virDomainObjList;
typedef virDomainObjList *virDomainObjListPtr; typedef virDomainObjList *virDomainObjListPtr;
struct _virDomainObjList {
/* uuid string -> virDomainObj mapping
* for O(1), lockless lookup-by-uuid */
virHashTable *objs;
};
static inline bool static inline bool
virDomainObjIsActive(virDomainObjPtr dom) virDomainObjIsActive(virDomainObjPtr dom)
@ -1908,7 +1902,6 @@ virDomainObjIsActive(virDomainObjPtr dom)
virDomainObjPtr virDomainObjNew(virCapsPtr caps); virDomainObjPtr virDomainObjNew(virCapsPtr caps);
virDomainObjListPtr virDomainObjListNew(void); virDomainObjListPtr virDomainObjListNew(void);
void virDomainObjListFree(virDomainObjListPtr objs);
virDomainObjPtr virDomainObjListFindByID(const virDomainObjListPtr doms, virDomainObjPtr virDomainObjListFindByID(const virDomainObjListPtr doms,
int id); int id);
@ -2176,6 +2169,13 @@ int virDomainObjListGetInactiveNames(virDomainObjListPtr doms,
char **const names, char **const names,
int maxnames); int maxnames);
typedef int (*virDomainObjListIterator)(virDomainObjPtr dom,
void *opaque);
int virDomainObjListForEach(virDomainObjListPtr doms,
virDomainObjListIterator callback,
void *opaque);
typedef int (*virDomainSmartcardDefIterator)(virDomainDefPtr def, typedef int (*virDomainSmartcardDefIterator)(virDomainDefPtr def,
virDomainSmartcardDefPtr dev, virDomainSmartcardDefPtr dev,
void *opaque); void *opaque);

20
src/conf/nwfilter_conf.c
View File

@ -2867,7 +2867,7 @@ virNWFilterCallbackDriversUnlock(void)
} }
static virHashIterator virNWFilterDomainFWUpdateCB; static virDomainObjListIterator virNWFilterDomainFWUpdateCB;
/** /**
* virNWFilterInstFiltersOnAllVMs: * virNWFilterInstFiltersOnAllVMs:
@ -2880,7 +2880,6 @@ virNWFilterInstFiltersOnAllVMs(virConnectPtr conn)
int i; int i;
struct domUpdateCBStruct cb = { struct domUpdateCBStruct cb = {
.conn = conn, .conn = conn,
.err = 0, /* ignored here */
.step = STEP_APPLY_CURRENT, .step = STEP_APPLY_CURRENT,
.skipInterfaces = NULL, /* not needed */ .skipInterfaces = NULL, /* not needed */
}; };
@ -2897,10 +2896,9 @@ static int
virNWFilterTriggerVMFilterRebuild(virConnectPtr conn) virNWFilterTriggerVMFilterRebuild(virConnectPtr conn)
{ {
int i; int i;
int err; int ret = 0;
struct domUpdateCBStruct cb = { struct domUpdateCBStruct cb = {
.conn = conn, .conn = conn,
.err = 0,
.step = STEP_APPLY_NEW, .step = STEP_APPLY_NEW,
.skipInterfaces = virHashCreate(0, NULL), .skipInterfaces = virHashCreate(0, NULL),
}; };
@ -2909,16 +2907,14 @@ virNWFilterTriggerVMFilterRebuild(virConnectPtr conn)
return -1; return -1;
for (i = 0; i < nCallbackDriver; i++) { for (i = 0; i < nCallbackDriver; i++) {
callbackDrvArray[i]->vmFilterRebuild(conn, if (callbackDrvArray[i]->vmFilterRebuild(conn,
virNWFilterDomainFWUpdateCB, virNWFilterDomainFWUpdateCB,
&cb); &cb) < 0)
ret = -1;
} }
err = cb.err; if (ret < 0) {
if (err) {
cb.step = STEP_TEAR_NEW; /* rollback */ cb.step = STEP_TEAR_NEW; /* rollback */
cb.err = 0;
for (i = 0; i < nCallbackDriver; i++) for (i = 0; i < nCallbackDriver; i++)
callbackDrvArray[i]->vmFilterRebuild(conn, callbackDrvArray[i]->vmFilterRebuild(conn,
@ -2935,7 +2931,7 @@ virNWFilterTriggerVMFilterRebuild(virConnectPtr conn)
virHashFree(cb.skipInterfaces); virHashFree(cb.skipInterfaces);
return err; return ret;
} }
@ -3503,7 +3499,7 @@ char *virNWFilterConfigFile(const char *dir,
} }
int virNWFilterConfLayerInit(virHashIterator domUpdateCB) int virNWFilterConfLayerInit(virDomainObjListIterator domUpdateCB)
{ {
virNWFilterDomainFWUpdateCB = domUpdateCB; virNWFilterDomainFWUpdateCB = domUpdateCB;

7
src/conf/nwfilter_conf.h
View File

@ -34,6 +34,7 @@
# include "virbuffer.h" # include "virbuffer.h"
# include "virsocketaddr.h" # include "virsocketaddr.h"
# include "virmacaddr.h" # include "virmacaddr.h"
# include "domain_conf.h"
/* XXX /* XXX
* The config parser/structs should not be using platform specific * The config parser/structs should not be using platform specific
@ -588,7 +589,6 @@ enum UpdateStep {
struct domUpdateCBStruct { struct domUpdateCBStruct {
virConnectPtr conn; virConnectPtr conn;
enum UpdateStep step; enum UpdateStep step;
int err;
virHashTablePtr skipInterfaces; virHashTablePtr skipInterfaces;
}; };
@ -725,14 +725,15 @@ void virNWFilterObjUnlock(virNWFilterObjPtr obj);
void virNWFilterLockFilterUpdates(void); void virNWFilterLockFilterUpdates(void);
void virNWFilterUnlockFilterUpdates(void); void virNWFilterUnlockFilterUpdates(void);
int virNWFilterConfLayerInit(virHashIterator domUpdateCB); int virNWFilterConfLayerInit(virDomainObjListIterator domUpdateCB);
void virNWFilterConfLayerShutdown(void); void virNWFilterConfLayerShutdown(void);
int virNWFilterInstFiltersOnAllVMs(virConnectPtr conn); int virNWFilterInstFiltersOnAllVMs(virConnectPtr conn);
typedef int (*virNWFilterRebuild)(virConnectPtr conn, typedef int (*virNWFilterRebuild)(virConnectPtr conn,
virHashIterator, void *data); virDomainObjListIterator domUpdateCB,
void *data);
typedef void (*virNWFilterVoidCall)(void); typedef void (*virNWFilterVoidCall)(void);

2
src/libvirt_private.syms
View File

@ -476,7 +476,7 @@ virDomainObjListExport;
virDomainObjListFindByID; virDomainObjListFindByID;
virDomainObjListFindByName; virDomainObjListFindByName;
virDomainObjListFindByUUID; virDomainObjListFindByUUID;
virDomainObjListFree; virDomainObjListForEach;
virDomainObjListGetActiveIDs; virDomainObjListGetActiveIDs;
virDomainObjListGetInactiveNames; virDomainObjListGetInactiveNames;
virDomainObjListIsDuplicate; virDomainObjListIsDuplicate;

45
src/libxl/libxl_driver.c
View File

@ -98,12 +98,12 @@ struct _libxlEventHookInfo {
}; };
static virClassPtr libxlDomainObjPrivateClass; static virClassPtr libxlDomainObjPrivateClass;
static libxlDriverPrivatePtr libxl_driver = NULL; static libxlDriverPrivatePtr libxl_driver = NULL;
/* Function declarations */ /* Function declarations */
static void static int
libxlDomainManagedSaveLoad(void *payload, libxlDomainManagedSaveLoad(virDomainObjPtr vm,
const void *n ATTRIBUTE_UNUSED,
void *opaque); void *opaque);
static int static int
@ -433,13 +433,13 @@ libxlDomainEventQueue(libxlDriverPrivatePtr driver, virDomainEventPtr event)
virDomainEventStateQueue(driver->domainEventState, event); virDomainEventStateQueue(driver->domainEventState, event);
} }
static void static int
libxlAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, libxlAutostartDomain(virDomainObjPtr vm,
void *opaque) void *opaque)
{ {
libxlDriverPrivatePtr driver = opaque; libxlDriverPrivatePtr driver = opaque;
virDomainObjPtr vm = payload;
virErrorPtr err; virErrorPtr err;
int ret = -1;
virObjectLock(vm); virObjectLock(vm);
virResetLastError(); virResetLastError();
@ -450,10 +450,14 @@ libxlAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED,
VIR_ERROR(_("Failed to autostart VM '%s': %s"), VIR_ERROR(_("Failed to autostart VM '%s': %s"),
vm->def->name, vm->def->name,
err ? err->message : _("unknown error")); err ? err->message : _("unknown error"));
goto cleanup;
} }
ret = 0;
cleanup:
if (vm) if (vm)
virObjectUnlock(vm); virObjectUnlock(vm);
return ret;
} }
static int static int
@ -1005,12 +1009,10 @@ error:
* Reconnect to running domains that were previously started/created * Reconnect to running domains that were previously started/created
* with libxenlight driver. * with libxenlight driver.
*/ */
static void static int
libxlReconnectDomain(void *payload, libxlReconnectDomain(virDomainObjPtr vm,
const void *name ATTRIBUTE_UNUSED,
void *opaque) void *opaque)
{ {
virDomainObjPtr vm = payload;
libxlDriverPrivatePtr driver = opaque; libxlDriverPrivatePtr driver = opaque;
int rc; int rc;
libxl_dominfo d_info; libxl_dominfo d_info;
@ -1047,7 +1049,7 @@ libxlReconnectDomain(void *payload,
/* Recreate domain death et. al. events */ /* Recreate domain death et. al. events */
libxlCreateDomEvents(vm); libxlCreateDomEvents(vm);
virObjectUnlock(vm); virObjectUnlock(vm);
return; return 0;
out: out:
libxlVmCleanup(driver, vm, VIR_DOMAIN_SHUTOFF_UNKNOWN); libxlVmCleanup(driver, vm, VIR_DOMAIN_SHUTOFF_UNKNOWN);
@ -1055,12 +1057,14 @@ out:
virDomainObjListRemove(driver->domains, vm); virDomainObjListRemove(driver->domains, vm);
else else
virObjectUnlock(vm); virObjectUnlock(vm);
return -1;
} }
static void static void
libxlReconnectDomains(libxlDriverPrivatePtr driver) libxlReconnectDomains(libxlDriverPrivatePtr driver)
{ {
virHashForEach(driver->domains->objs, libxlReconnectDomain, driver); virDomainObjListForEach(driver->domains, libxlReconnectDomain, driver);
} }
static int static int
@ -1071,7 +1075,7 @@ libxlShutdown(void)
libxlDriverLock(libxl_driver); libxlDriverLock(libxl_driver);
virCapabilitiesFree(libxl_driver->caps); virCapabilitiesFree(libxl_driver->caps);
virDomainObjListFree(libxl_driver->domains); virObjectUnref(libxl_driver->domains);
libxl_ctx_free(libxl_driver->ctx); libxl_ctx_free(libxl_driver->ctx);
xtl_logger_destroy(libxl_driver->logger); xtl_logger_destroy(libxl_driver->logger);
if (libxl_driver->logger_file) if (libxl_driver->logger_file)
@ -1252,10 +1256,10 @@ libxlStartup(bool privileged,
NULL, NULL) < 0) NULL, NULL) < 0)
goto error; goto error;
virHashForEach(libxl_driver->domains->objs, libxlAutostartDomain, virDomainObjListForEach(libxl_driver->domains, libxlAutostartDomain,
libxl_driver); libxl_driver);
virHashForEach(libxl_driver->domains->objs, libxlDomainManagedSaveLoad, virDomainObjListForEach(libxl_driver->domains, libxlDomainManagedSaveLoad,
libxl_driver); libxl_driver);
libxlDriverUnlock(libxl_driver); libxlDriverUnlock(libxl_driver);
@ -1288,7 +1292,7 @@ libxlReload(void)
1, 1 << VIR_DOMAIN_VIRT_XEN, 1, 1 << VIR_DOMAIN_VIRT_XEN,
NULL, libxl_driver); NULL, libxl_driver);
virHashForEach(libxl_driver->domains->objs, libxlAutostartDomain, virDomainObjListForEach(libxl_driver->domains, libxlAutostartDomain,
libxl_driver); libxl_driver);
libxlDriverUnlock(libxl_driver); libxlDriverUnlock(libxl_driver);
@ -2406,14 +2410,13 @@ cleanup:
return ret; return ret;
} }
static void static int
libxlDomainManagedSaveLoad(void *payload, libxlDomainManagedSaveLoad(virDomainObjPtr vm,
const void *n ATTRIBUTE_UNUSED,
void *opaque) void *opaque)
{ {
virDomainObjPtr vm = payload;
libxlDriverPrivatePtr driver = opaque; libxlDriverPrivatePtr driver = opaque;
char *name; char *name;
int ret = -1;
virObjectLock(vm); virObjectLock(vm);
@ -2422,9 +2425,11 @@ libxlDomainManagedSaveLoad(void *payload,
vm->hasManagedSave = virFileExists(name); vm->hasManagedSave = virFileExists(name);
ret = 0;
cleanup: cleanup:
virObjectUnlock(vm); virObjectUnlock(vm);
VIR_FREE(name); VIR_FREE(name);
return ret;
} }
static int static int

9
src/lxc/lxc_driver.c
View File

@ -58,6 +58,7 @@
#include "fdstream.h" #include "fdstream.h"
#include "domain_audit.h" #include "domain_audit.h"
#include "domain_nwfilter.h" #include "domain_nwfilter.h"
#include "nwfilter_conf.h"
#include "network/bridge_driver.h" #include "network/bridge_driver.h"
#include "virinitctl.h" #include "virinitctl.h"
#include "virnetdev.h" #include "virnetdev.h"
@ -82,11 +83,9 @@ virLXCDriverPtr lxc_driver = NULL;
/* callbacks for nwfilter */ /* callbacks for nwfilter */
static int static int
lxcVMFilterRebuild(virConnectPtr conn ATTRIBUTE_UNUSED, lxcVMFilterRebuild(virConnectPtr conn ATTRIBUTE_UNUSED,
virHashIterator iter, void *data) virDomainObjListIterator iter, void *data)
{ {
virHashForEach(lxc_driver->domains->objs, iter, data); return virDomainObjListForEach(lxc_driver->domains, iter, data);
return 0;
} }
static void static void
@ -1556,7 +1555,7 @@ static int lxcShutdown(void)
lxcDriverLock(lxc_driver); lxcDriverLock(lxc_driver);
virNWFilterUnRegisterCallbackDriver(&lxcCallbackDriver); virNWFilterUnRegisterCallbackDriver(&lxcCallbackDriver);
virDomainObjListFree(lxc_driver->domains); virObjectUnref(lxc_driver->domains);
virDomainEventStateFree(lxc_driver->domainEventState); virDomainEventStateFree(lxc_driver->domainEventState);
virLXCProcessAutoDestroyShutdown(lxc_driver); virLXCProcessAutoDestroyShutdown(lxc_driver);

26
src/lxc/lxc_process.c
View File

@ -1246,16 +1246,17 @@ struct virLXCProcessAutostartData {
virConnectPtr conn; virConnectPtr conn;
}; };
static void static int
virLXCProcessAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque) virLXCProcessAutostartDomain(virDomainObjPtr vm,
void *opaque)
{ {
virDomainObjPtr vm = payload;
const struct virLXCProcessAutostartData *data = opaque; const struct virLXCProcessAutostartData *data = opaque;
int ret = 0;
virObjectLock(vm); virObjectLock(vm);
if (vm->autostart && if (vm->autostart &&
!virDomainObjIsActive(vm)) { !virDomainObjIsActive(vm)) {
int ret = virLXCProcessStart(data->conn, data->driver, vm, false, ret = virLXCProcessStart(data->conn, data->driver, vm, false,
VIR_DOMAIN_RUNNING_BOOTED); VIR_DOMAIN_RUNNING_BOOTED);
virDomainAuditStart(vm, "booted", ret >= 0); virDomainAuditStart(vm, "booted", ret >= 0);
if (ret < 0) { if (ret < 0) {
@ -1273,6 +1274,7 @@ virLXCProcessAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, v
} }
} }
virObjectUnlock(vm); virObjectUnlock(vm);
return ret;
} }
@ -1290,19 +1292,22 @@ virLXCProcessAutostartAll(virLXCDriverPtr driver)
struct virLXCProcessAutostartData data = { driver, conn }; struct virLXCProcessAutostartData data = { driver, conn };
lxcDriverLock(driver); lxcDriverLock(driver);
virHashForEach(driver->domains->objs, virLXCProcessAutostartDomain, &data); virDomainObjListForEach(driver->domains,
virLXCProcessAutostartDomain,
&data);
lxcDriverUnlock(driver); lxcDriverUnlock(driver);
if (conn) if (conn)
virConnectClose(conn); virConnectClose(conn);
} }
static void static int
virLXCProcessReconnectDomain(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque) virLXCProcessReconnectDomain(virDomainObjPtr vm,
void *opaque)
{ {
virDomainObjPtr vm = payload;
virLXCDriverPtr driver = opaque; virLXCDriverPtr driver = opaque;
virLXCDomainObjPrivatePtr priv; virLXCDomainObjPrivatePtr priv;
int ret = -1;
virObjectLock(vm); virObjectLock(vm);
VIR_DEBUG("Reconnect id=%d pid=%d state=%d", vm->def->id, vm->pid, vm->state.state); VIR_DEBUG("Reconnect id=%d pid=%d state=%d", vm->def->id, vm->pid, vm->state.state);
@ -1346,9 +1351,10 @@ virLXCProcessReconnectDomain(void *payload, const void *name ATTRIBUTE_UNUSED, v
vm->def->id = -1; vm->def->id = -1;
} }
ret = 0;
cleanup: cleanup:
virObjectUnlock(vm); virObjectUnlock(vm);
return; return ret;
error: error:
virLXCProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED); virLXCProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED);
@ -1360,6 +1366,6 @@ error:
int virLXCProcessReconnectAll(virLXCDriverPtr driver, int virLXCProcessReconnectAll(virLXCDriverPtr driver,
virDomainObjListPtr doms) virDomainObjListPtr doms)
{ {
virHashForEach(doms->objs, virLXCProcessReconnectDomain, driver); virDomainObjListForEach(doms, virLXCProcessReconnectDomain, driver);
return 0; return 0;
} }

26
src/nwfilter/nwfilter_gentech_driver.c
View File

@ -1150,16 +1150,15 @@ virNWFilterTeardownFilter(const virDomainNetDefPtr net)
} }
void int
virNWFilterDomainFWUpdateCB(void *payload, virNWFilterDomainFWUpdateCB(virDomainObjPtr obj,
const void *name ATTRIBUTE_UNUSED,
void *data) void *data)
{ {
virDomainObjPtr obj = payload;
virDomainDefPtr vm = obj->def; virDomainDefPtr vm = obj->def;
struct domUpdateCBStruct *cb = data; struct domUpdateCBStruct *cb = data;
int i, err; int i;
bool skipIface; bool skipIface;
int ret = 0;
virObjectLock(obj); virObjectLock(obj);
@ -1169,13 +1168,13 @@ virNWFilterDomainFWUpdateCB(void *payload,
if ((net->filter) && (net->ifname)) { if ((net->filter) && (net->ifname)) {
switch (cb->step) { switch (cb->step) {
case STEP_APPLY_NEW: case STEP_APPLY_NEW:
cb->err = virNWFilterUpdateInstantiateFilter(cb->conn, ret = virNWFilterUpdateInstantiateFilter(cb->conn,
vm->uuid, vm->uuid,
net, net,
&skipIface); &skipIface);
if (cb->err == 0 && skipIface) { if (ret == 0 && skipIface) {
/* filter tree unchanged -- no update needed */ /* filter tree unchanged -- no update needed */
cb->err = virHashAddEntry(cb->skipInterfaces, ret = virHashAddEntry(cb->skipInterfaces,
net->ifname, net->ifname,
(void *)~0); (void *)~0);
} }
@ -1183,31 +1182,32 @@ virNWFilterDomainFWUpdateCB(void *payload,
case STEP_TEAR_NEW: case STEP_TEAR_NEW:
if (!virHashLookup(cb->skipInterfaces, net->ifname)) { if (!virHashLookup(cb->skipInterfaces, net->ifname)) {
cb->err = virNWFilterRollbackUpdateFilter(net); ret = virNWFilterRollbackUpdateFilter(net);
} }
break; break;
case STEP_TEAR_OLD: case STEP_TEAR_OLD:
if (!virHashLookup(cb->skipInterfaces, net->ifname)) { if (!virHashLookup(cb->skipInterfaces, net->ifname)) {
cb->err = virNWFilterTearOldFilter(net); ret = virNWFilterTearOldFilter(net);
} }
break; break;
case STEP_APPLY_CURRENT: case STEP_APPLY_CURRENT:
err = virNWFilterInstantiateFilter(cb->conn, ret = virNWFilterInstantiateFilter(cb->conn,
vm->uuid, vm->uuid,
net); net);
if (err) if (ret)
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("Failure while applying current filter on " _("Failure while applying current filter on "
"VM %s"), vm->name); "VM %s"), vm->name);
break; break;
} }
if (cb->err) if (ret)
break; break;
} }
} }
} }
virObjectUnlock(obj); virObjectUnlock(obj);
return ret;
} }

5
src/nwfilter/nwfilter_gentech_driver.h
View File

@ -23,6 +23,8 @@
#ifndef __NWFILTER_GENTECH_DRIVER_H #ifndef __NWFILTER_GENTECH_DRIVER_H
# define __NWFILTER_GENTECH_DRIVER_H # define __NWFILTER_GENTECH_DRIVER_H
# include "nwfilter_conf.h"
virNWFilterTechDriverPtr virNWFilterTechDriverForName(const char *name); virNWFilterTechDriverPtr virNWFilterTechDriverForName(const char *name);
int virNWFilterRuleInstAddData(virNWFilterRuleInstPtr res, int virNWFilterRuleInstAddData(virNWFilterRuleInstPtr res,
@ -60,8 +62,7 @@ int virNWFilterTeardownFilter(const virDomainNetDefPtr net);
virNWFilterHashTablePtr virNWFilterCreateVarHashmap(char *macaddr, virNWFilterHashTablePtr virNWFilterCreateVarHashmap(char *macaddr,
const virNWFilterVarValuePtr); const virNWFilterVarValuePtr);
void virNWFilterDomainFWUpdateCB(void *payload, int virNWFilterDomainFWUpdateCB(virDomainObjPtr vm,
const void *name,
void *data); void *data);
#endif #endif

74
src/openvz/openvz_conf.c
View File

@ -558,7 +558,7 @@ openvzFreeDriver(struct openvz_driver *driver)
if (!driver) if (!driver)
return; return;
virDomainObjListFree(driver->domains); virObjectUnref(driver->domains);
virCapabilitiesFree(driver->caps); virCapabilitiesFree(driver->caps);
VIR_FREE(driver); VIR_FREE(driver);
} }
@ -570,6 +570,7 @@ int openvzLoadDomains(struct openvz_driver *driver) {
char *status; char *status;
char uuidstr[VIR_UUID_STRING_BUFLEN]; char uuidstr[VIR_UUID_STRING_BUFLEN];
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
virDomainDefPtr def = NULL;
char *temp = NULL; char *temp = NULL;
char *outbuf = NULL; char *outbuf = NULL;
char *line; char *line;
@ -594,35 +595,20 @@ int openvzLoadDomains(struct openvz_driver *driver) {
} }
*line++ = '\0'; *line++ = '\0';
if (!(dom = virDomainObjNew(driver->caps))) if (VIR_ALLOC(def) < 0)
goto cleanup;
if (VIR_ALLOC(dom->def) < 0)
goto no_memory; goto no_memory;
dom->def->virtType = VIR_DOMAIN_VIRT_OPENVZ; def->virtType = VIR_DOMAIN_VIRT_OPENVZ;
if (STREQ(status, "stopped")) { if (STREQ(status, "stopped"))
virDomainObjSetState(dom, VIR_DOMAIN_SHUTOFF, def->id = -1;
VIR_DOMAIN_SHUTOFF_UNKNOWN);
} else {
virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
VIR_DOMAIN_RUNNING_UNKNOWN);
}
dom->pid = veid;
if (virDomainObjGetState(dom, NULL) == VIR_DOMAIN_SHUTOFF)
dom->def->id = -1;
else else
dom->def->id = veid; def->id = veid;
/* XXX OpenVZ doesn't appear to have concept of a transient domain */ if (virAsprintf(&def->name, "%i", veid) < 0)
dom->persistent = 1;
if (virAsprintf(&dom->def->name, "%i", veid) < 0)
goto no_memory; goto no_memory;
openvzGetVPSUUID(veid, uuidstr, sizeof(uuidstr)); openvzGetVPSUUID(veid, uuidstr, sizeof(uuidstr));
ret = virUUIDParse(uuidstr, dom->def->uuid); ret = virUUIDParse(uuidstr, def->uuid);
if (ret == -1) { if (ret == -1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@ -630,9 +616,9 @@ int openvzLoadDomains(struct openvz_driver *driver) {
goto cleanup; goto cleanup;
} }
if (!(dom->def->os.type = strdup("exe"))) if (!(def->os.type = strdup("exe")))
goto no_memory; goto no_memory;
if (!(dom->def->os.init = strdup("/sbin/init"))) if (!(def->os.init = strdup("/sbin/init")))
goto no_memory; goto no_memory;
ret = openvzReadVPSConfigParam(veid, "CPUS", &temp); ret = openvzReadVPSConfigParam(veid, "CPUS", &temp);
@ -642,35 +628,48 @@ int openvzLoadDomains(struct openvz_driver *driver) {
veid); veid);
goto cleanup; goto cleanup;
} else if (ret > 0) { } else if (ret > 0) {
dom->def->maxvcpus = strtoI(temp); def->maxvcpus = strtoI(temp);
} }
if (ret == 0 || dom->def->maxvcpus == 0) if (ret == 0 || def->maxvcpus == 0)
dom->def->maxvcpus = openvzGetNodeCPUs(); def->maxvcpus = openvzGetNodeCPUs();
dom->def->vcpus = dom->def->maxvcpus; def->vcpus = def->maxvcpus;
/* XXX load rest of VM config data .... */ /* XXX load rest of VM config data .... */
openvzReadNetworkConf(dom->def, veid); openvzReadNetworkConf(def, veid);
openvzReadFSConf(dom->def, veid); openvzReadFSConf(def, veid);
openvzReadMemConf(dom->def, veid); openvzReadMemConf(def, veid);
virUUIDFormat(dom->def->uuid, uuidstr); virUUIDFormat(def->uuid, uuidstr);
if (virHashLookup(driver->domains->objs, uuidstr)) { if (virDomainObjListIsDuplicate(driver->domains, def, true)) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("Duplicate container UUID %s detected for %d"), _("Duplicate container UUID %s detected for %d"),
uuidstr, uuidstr,
veid); veid);
goto cleanup; goto cleanup;
} }
if (virHashAddEntry(driver->domains->objs, uuidstr, dom) < 0) { if (!(dom = virDomainObjListAdd(driver->domains,
virReportError(VIR_ERR_INTERNAL_ERROR, driver->caps,
_("Could not add UUID for container %d"), veid); def,
STRNEQ(status, "stopped"))))
goto cleanup; goto cleanup;
if (STREQ(status, "stopped")) {
virDomainObjSetState(dom, VIR_DOMAIN_SHUTOFF,
VIR_DOMAIN_SHUTOFF_UNKNOWN);
dom->pid = -1;
} else {
virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
VIR_DOMAIN_RUNNING_UNKNOWN);
dom->pid = veid;
} }
/* XXX OpenVZ doesn't appear to have concept of a transient domain */
dom->persistent = 1;
virObjectUnlock(dom); virObjectUnlock(dom);
dom = NULL; dom = NULL;
def = NULL;
} }
virCommandFree(cmd); virCommandFree(cmd);
@ -687,6 +686,7 @@ int openvzLoadDomains(struct openvz_driver *driver) {
VIR_FREE(temp); VIR_FREE(temp);
VIR_FREE(outbuf); VIR_FREE(outbuf);
virObjectUnref(dom); virObjectUnref(dom);
virDomainDefFree(def);
return -1; return -1;
} }

4
src/parallels/parallels_driver.c
View File

@ -940,7 +940,7 @@ parallelsOpenDefault(virConnectPtr conn)
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
error: error:
virDomainObjListFree(privconn->domains); virObjectUnref(privconn->domains);
virCapabilitiesFree(privconn->caps); virCapabilitiesFree(privconn->caps);
virStoragePoolObjListFree(&privconn->pools); virStoragePoolObjListFree(&privconn->pools);
VIR_FREE(privconn); VIR_FREE(privconn);
@ -987,7 +987,7 @@ parallelsClose(virConnectPtr conn)
parallelsDriverLock(privconn); parallelsDriverLock(privconn);
virCapabilitiesFree(privconn->caps); virCapabilitiesFree(privconn->caps);
virDomainObjListFree(privconn->domains); virObjectUnref(privconn->domains);
conn->privateData = NULL; conn->privateData = NULL;
parallelsDriverUnlock(privconn); parallelsDriverUnlock(privconn);

34
src/parallels/parallels_storage.c
View File

@ -122,11 +122,6 @@ cleanup:
} }
struct parallelsPoolsAddData {
virConnectPtr conn;
bool failed;
};
/* /*
* Generate unique pool name by path * Generate unique pool name by path
*/ */
@ -404,26 +399,20 @@ cleanup:
} }
static void static int
parallelsPoolsAdd(void *payload, parallelsPoolsAdd(virDomainObjPtr dom,
const void *name ATTRIBUTE_UNUSED,
void *opaque) void *opaque)
{ {
struct parallelsPoolsAddData *data = (struct parallelsPoolsAddData *)opaque; virConnectPtr conn = opaque;
virDomainObjPtr dom = payload;
virStoragePoolObjPtr pool; virStoragePoolObjPtr pool;
if (!(pool = parallelsPoolAddByDomain(data->conn, dom))) { if (!(pool = parallelsPoolAddByDomain(conn, dom)))
data->failed = true; return -1;
return;
}
if (parallelsFindVmVolumes(pool, dom)) { if (parallelsFindVmVolumes(pool, dom))
data->failed = true; return -1;
return;
}
return; return 0;
} }
static int parallelsLoadPools(virConnectPtr conn) static int parallelsLoadPools(virConnectPtr conn)
@ -432,7 +421,6 @@ static int parallelsLoadPools(virConnectPtr conn)
virStorageDriverStatePtr storageState = conn->storagePrivateData; virStorageDriverStatePtr storageState = conn->storagePrivateData;
char *base = NULL; char *base = NULL;
size_t i; size_t i;
struct parallelsPoolsAddData data;
if ((base = strdup(SYSCONFDIR "/libvirt")) == NULL) if ((base = strdup(SYSCONFDIR "/libvirt")) == NULL)
goto out_of_memory; goto out_of_memory;
@ -456,11 +444,7 @@ static int parallelsLoadPools(virConnectPtr conn)
goto error; goto error;
} }
data.conn = conn; if (virDomainObjListForEach(privconn->domains, parallelsPoolsAdd, conn) < 0)
data.failed = false;
virHashForEach(privconn->domains->objs, parallelsPoolsAdd, &data);
if (data.failed)
goto error; goto error;
for (i = 0; i < privconn->pools.count; i++) { for (i = 0; i < privconn->pools.count; i++) {

70
src/qemu/qemu_driver.c
View File

@ -79,6 +79,7 @@
#include "cpu/cpu.h" #include "cpu/cpu.h"
#include "virsysinfo.h" #include "virsysinfo.h"
#include "domain_nwfilter.h" #include "domain_nwfilter.h"
#include "nwfilter_conf.h"
#include "virhook.h" #include "virhook.h"
#include "virstoragefile.h" #include "virstoragefile.h"
#include "virfile.h" #include "virfile.h"
@ -144,8 +145,7 @@ static int qemuDomainObjStart(virConnectPtr conn,
static int qemuDomainGetMaxVcpus(virDomainPtr dom); static int qemuDomainGetMaxVcpus(virDomainPtr dom);
static void qemuDomainManagedSaveLoad(void *payload, static int qemuDomainManagedSaveLoad(virDomainObjPtr vm,
const void *n ATTRIBUTE_UNUSED,
void *opaque); void *opaque);
@ -166,11 +166,9 @@ qemuVMDriverUnlock(void) {
static int static int
qemuVMFilterRebuild(virConnectPtr conn ATTRIBUTE_UNUSED, qemuVMFilterRebuild(virConnectPtr conn ATTRIBUTE_UNUSED,
virHashIterator iter, void *data) virDomainObjListIterator iter, void *data)
{ {
virHashForEach(qemu_driver->domains->objs, iter, data); return virDomainObjListForEach(qemu_driver->domains, iter, data);
return 0;
} }
static virNWFilterCallbackDriver qemuCallbackDriver = { static virNWFilterCallbackDriver qemuCallbackDriver = {
@ -278,15 +276,15 @@ qemuSnapObjFromSnapshot(virDomainObjPtr vm,
return qemuSnapObjFromName(vm, snapshot->name); return qemuSnapObjFromName(vm, snapshot->name);
} }
static void static int
qemuAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, qemuAutostartDomain(virDomainObjPtr vm,
void *opaque) void *opaque)
{ {
virDomainObjPtr vm = payload;
struct qemuAutostartData *data = opaque; struct qemuAutostartData *data = opaque;
virErrorPtr err; virErrorPtr err;
int flags = 0; int flags = 0;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(data->driver); virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(data->driver);
int ret = -1;
if (cfg->autoStartBypassCache) if (cfg->autoStartBypassCache)
flags |= VIR_DOMAIN_START_BYPASS_CACHE; flags |= VIR_DOMAIN_START_BYPASS_CACHE;
@ -315,10 +313,12 @@ qemuAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED,
vm = NULL; vm = NULL;
} }
ret = 0;
cleanup: cleanup:
if (vm) if (vm)
virObjectUnlock(vm); virObjectUnlock(vm);
virObjectUnref(cfg); virObjectUnref(cfg);
return ret;
} }
@ -336,7 +336,7 @@ qemuAutostartDomains(virQEMUDriverPtr driver)
struct qemuAutostartData data = { driver, conn }; struct qemuAutostartData data = { driver, conn };
qemuDriverLock(driver); qemuDriverLock(driver);
virHashForEach(driver->domains->objs, qemuAutostartDomain, &data); virDomainObjListForEach(driver->domains, qemuAutostartDomain, &data);
qemuDriverUnlock(driver); qemuDriverUnlock(driver);
if (conn) if (conn)
@ -489,18 +489,15 @@ err_exit:
} }
static void static int
qemuDomainSnapshotLoad(void *payload, qemuDomainSnapshotLoad(virDomainObjPtr vm,
const void *name ATTRIBUTE_UNUSED,
void *data) void *data)
{ {
virDomainObjPtr vm = (virDomainObjPtr)payload;
char *baseDir = (char *)data; char *baseDir = (char *)data;
char *snapDir = NULL; char *snapDir = NULL;
DIR *dir = NULL; DIR *dir = NULL;
struct dirent *entry; struct dirent *entry;
char *xmlStr; char *xmlStr;
int ret;
char *fullpath; char *fullpath;
virDomainSnapshotDefPtr def = NULL; virDomainSnapshotDefPtr def = NULL;
virDomainSnapshotObjPtr snap = NULL; virDomainSnapshotObjPtr snap = NULL;
@ -509,6 +506,7 @@ qemuDomainSnapshotLoad(void *payload,
unsigned int flags = (VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE | unsigned int flags = (VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE |
VIR_DOMAIN_SNAPSHOT_PARSE_DISKS | VIR_DOMAIN_SNAPSHOT_PARSE_DISKS |
VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL); VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL);
int ret = -1;
virObjectLock(vm); virObjectLock(vm);
if (virAsprintf(&snapDir, "%s/%s", baseDir, vm->def->name) < 0) { if (virAsprintf(&snapDir, "%s/%s", baseDir, vm->def->name) < 0) {
@ -541,8 +539,7 @@ qemuDomainSnapshotLoad(void *payload,
continue; continue;
} }
ret = virFileReadAll(fullpath, 1024*1024*1, &xmlStr); if (virFileReadAll(fullpath, 1024*1024*1, &xmlStr) < 0) {
if (ret < 0) {
/* Nothing we can do here, skip this one */ /* Nothing we can do here, skip this one */
VIR_ERROR(_("Failed to read snapshot file %s: %s"), fullpath, VIR_ERROR(_("Failed to read snapshot file %s: %s"), fullpath,
virStrerror(errno, ebuf, sizeof(ebuf))); virStrerror(errno, ebuf, sizeof(ebuf)));
@ -596,21 +593,21 @@ qemuDomainSnapshotLoad(void *payload,
virResetLastError(); virResetLastError();
ret = 0;
cleanup: cleanup:
if (dir) if (dir)
closedir(dir); closedir(dir);
VIR_FREE(snapDir); VIR_FREE(snapDir);
virObjectUnlock(vm); virObjectUnlock(vm);
return ret;
} }
static void static int
qemuDomainNetsRestart(void *payload, qemuDomainNetsRestart(virDomainObjPtr vm,
const void *name ATTRIBUTE_UNUSED,
void *data ATTRIBUTE_UNUSED) void *data ATTRIBUTE_UNUSED)
{ {
int i; int i;
virDomainObjPtr vm = (virDomainObjPtr)payload;
virDomainDefPtr def = vm->def; virDomainDefPtr def = vm->def;
virObjectLock(vm); virObjectLock(vm);
@ -631,19 +628,20 @@ qemuDomainNetsRestart(void *payload,
} }
virObjectUnlock(vm); virObjectUnlock(vm);
return 0;
} }
static void static int
qemuDomainFindMaxID(void *payload, qemuDomainFindMaxID(virDomainObjPtr vm,
const void *name ATTRIBUTE_UNUSED,
void *data) void *data)
{ {
virDomainObjPtr vm = payload;
int *driver_maxid = data; int *driver_maxid = data;
if (vm->def->id >= *driver_maxid) if (vm->def->id >= *driver_maxid)
*driver_maxid = vm->def->id + 1; *driver_maxid = vm->def->id + 1;
return 0;
} }
@ -874,11 +872,13 @@ qemuStartup(bool privileged,
/* find the maximum ID from active and transient configs to initialize /* find the maximum ID from active and transient configs to initialize
* the driver with. This is to avoid race between autostart and reconnect * the driver with. This is to avoid race between autostart and reconnect
* threads */ * threads */
virHashForEach(qemu_driver->domains->objs, virDomainObjListForEach(qemu_driver->domains,
qemuDomainFindMaxID, qemuDomainFindMaxID,
&qemu_driver->nextvmid); &qemu_driver->nextvmid);
virHashForEach(qemu_driver->domains->objs, qemuDomainNetsRestart, NULL); virDomainObjListForEach(qemu_driver->domains,
qemuDomainNetsRestart,
NULL);
conn = virConnectOpen(cfg->uri); conn = virConnectOpen(cfg->uri);
@ -894,11 +894,11 @@ qemuStartup(bool privileged,
goto error; goto error;
virHashForEach(qemu_driver->domains->objs, virDomainObjListForEach(qemu_driver->domains,
qemuDomainSnapshotLoad, qemuDomainSnapshotLoad,
cfg->snapshotDir); cfg->snapshotDir);
virHashForEach(qemu_driver->domains->objs, virDomainObjListForEach(qemu_driver->domains,
qemuDomainManagedSaveLoad, qemuDomainManagedSaveLoad,
qemu_driver); qemu_driver);
@ -1054,7 +1054,7 @@ qemuShutdown(void) {
virCapabilitiesFree(qemu_driver->caps); virCapabilitiesFree(qemu_driver->caps);
qemuCapsCacheFree(qemu_driver->capsCache); qemuCapsCacheFree(qemu_driver->capsCache);
virDomainObjListFree(qemu_driver->domains); virObjectUnref(qemu_driver->domains);
virObjectUnref(qemu_driver->remotePorts); virObjectUnref(qemu_driver->remotePorts);
virSysinfoDefFree(qemu_driver->hostsysinfo); virSysinfoDefFree(qemu_driver->hostsysinfo);
@ -3128,14 +3128,13 @@ cleanup:
return ret; return ret;
} }
static void static int
qemuDomainManagedSaveLoad(void *payload, qemuDomainManagedSaveLoad(virDomainObjPtr vm,
const void *n ATTRIBUTE_UNUSED,
void *opaque) void *opaque)
{ {
virDomainObjPtr vm = payload;
virQEMUDriverPtr driver = opaque; virQEMUDriverPtr driver = opaque;
char *name; char *name;
int ret = -1;
virObjectLock(vm); virObjectLock(vm);
@ -3144,11 +3143,14 @@ qemuDomainManagedSaveLoad(void *payload,
vm->hasManagedSave = virFileExists(name); vm->hasManagedSave = virFileExists(name);
ret = 0;
cleanup: cleanup:
virObjectUnlock(vm); virObjectUnlock(vm);
VIR_FREE(name); VIR_FREE(name);
return ret;
} }
static int static int
qemuDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags) qemuDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{ {

15
src/qemu/qemu_process.c
View File

@ -3353,23 +3353,21 @@ error:
virObjectUnref(cfg); virObjectUnref(cfg);
} }
static void static int
qemuProcessReconnectHelper(void *payload, qemuProcessReconnectHelper(virDomainObjPtr obj,
const void *name ATTRIBUTE_UNUSED,
void *opaque) void *opaque)
{ {
virThread thread; virThread thread;
struct qemuProcessReconnectData *src = opaque; struct qemuProcessReconnectData *src = opaque;
struct qemuProcessReconnectData *data; struct qemuProcessReconnectData *data;
virDomainObjPtr obj = payload;
if (VIR_ALLOC(data) < 0) { if (VIR_ALLOC(data) < 0) {
virReportOOMError(); virReportOOMError();
return; return -1;
} }
memcpy(data, src, sizeof(*data)); memcpy(data, src, sizeof(*data));
data->payload = payload; data->payload = obj;
/* This iterator is called with driver being locked. /* This iterator is called with driver being locked.
* We create a separate thread to run qemuProcessReconnect in it. * We create a separate thread to run qemuProcessReconnect in it.
@ -3430,10 +3428,11 @@ qemuProcessReconnectHelper(void *payload,
virObjectUnlock(obj); virObjectUnlock(obj);
return; return 0;
error: error:
VIR_FREE(data); VIR_FREE(data);
return -1;
} }
/** /**
@ -3446,7 +3445,7 @@ void
qemuProcessReconnectAll(virConnectPtr conn, virQEMUDriverPtr driver) qemuProcessReconnectAll(virConnectPtr conn, virQEMUDriverPtr driver)
{ {
struct qemuProcessReconnectData data = {.conn = conn, .driver = driver}; struct qemuProcessReconnectData data = {.conn = conn, .driver = driver};
virHashForEach(driver->domains->objs, qemuProcessReconnectHelper, &data); virDomainObjListForEach(driver->domains, qemuProcessReconnectHelper, &data);
} }
int int

6
src/test/test_driver.c
View File

@ -646,7 +646,7 @@ static int testOpenDefault(virConnectPtr conn) {
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
error: error:
virDomainObjListFree(privconn->domains); virObjectUnref(privconn->domains);
virNetworkObjListFree(&privconn->networks); virNetworkObjListFree(&privconn->networks);
virInterfaceObjListFree(&privconn->ifaces); virInterfaceObjListFree(&privconn->ifaces);
virStoragePoolObjListFree(&privconn->pools); virStoragePoolObjListFree(&privconn->pools);
@ -1115,7 +1115,7 @@ static int testOpenFromFile(virConnectPtr conn,
VIR_FREE(ifaces); VIR_FREE(ifaces);
VIR_FREE(pools); VIR_FREE(pools);
VIR_FREE(devs); VIR_FREE(devs);
virDomainObjListFree(privconn->domains); virObjectUnref(privconn->domains);
virNetworkObjListFree(&privconn->networks); virNetworkObjListFree(&privconn->networks);
virInterfaceObjListFree(&privconn->ifaces); virInterfaceObjListFree(&privconn->ifaces);
virStoragePoolObjListFree(&privconn->pools); virStoragePoolObjListFree(&privconn->pools);
@ -1184,7 +1184,7 @@ static int testClose(virConnectPtr conn)
testConnPtr privconn = conn->privateData; testConnPtr privconn = conn->privateData;
testDriverLock(privconn); testDriverLock(privconn);
virCapabilitiesFree(privconn->caps); virCapabilitiesFree(privconn->caps);
virDomainObjListFree(privconn->domains); virObjectUnref(privconn->domains);
virNodeDeviceObjListFree(&privconn->devs); virNodeDeviceObjListFree(&privconn->devs);
virNetworkObjListFree(&privconn->networks); virNetworkObjListFree(&privconn->networks);
virInterfaceObjListFree(&privconn->ifaces); virInterfaceObjListFree(&privconn->ifaces);

29
src/uml/uml_driver.c
View File

@ -58,6 +58,7 @@
#include "datatypes.h" #include "datatypes.h"
#include "virlog.h" #include "virlog.h"
#include "domain_nwfilter.h" #include "domain_nwfilter.h"
#include "nwfilter_conf.h"
#include "virfile.h" #include "virfile.h"
#include "fdstream.h" #include "fdstream.h"
#include "configmake.h" #include "configmake.h"
@ -148,11 +149,9 @@ static struct uml_driver *uml_driver = NULL;
static int static int
umlVMFilterRebuild(virConnectPtr conn ATTRIBUTE_UNUSED, umlVMFilterRebuild(virConnectPtr conn ATTRIBUTE_UNUSED,
virHashIterator iter, void *data) virDomainObjListIterator iter, void *data)
{ {
virHashForEach(uml_driver->domains->objs, iter, data); return virDomainObjListForEach(uml_driver->domains, iter, data);
return 0;
} }
static void static void
@ -179,16 +178,15 @@ struct umlAutostartData {
virConnectPtr conn; virConnectPtr conn;
}; };
static void static int
umlAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque) umlAutostartDomain(virDomainObjPtr vm,
void *opaque)
{ {
virDomainObjPtr vm = payload;
const struct umlAutostartData *data = opaque; const struct umlAutostartData *data = opaque;
int ret = 0;
virObjectLock(vm); virObjectLock(vm);
if (vm->autostart && if (vm->autostart &&
!virDomainObjIsActive(vm)) { !virDomainObjIsActive(vm)) {
int ret;
virResetLastError(); virResetLastError();
ret = umlStartVMDaemon(data->conn, data->driver, vm, false); ret = umlStartVMDaemon(data->conn, data->driver, vm, false);
virDomainAuditStart(vm, "booted", ret >= 0); virDomainAuditStart(vm, "booted", ret >= 0);
@ -206,6 +204,7 @@ umlAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaqu
} }
} }
virObjectUnlock(vm); virObjectUnlock(vm);
return ret;
} }
static void static void
@ -223,7 +222,7 @@ umlAutostartConfigs(struct uml_driver *driver) {
struct umlAutostartData data = { driver, conn }; struct umlAutostartData data = { driver, conn };
umlDriverLock(driver); umlDriverLock(driver);
virHashForEach(driver->domains->objs, umlAutostartDomain, &data); virDomainObjListForEach(driver->domains, umlAutostartDomain, &data);
umlDriverUnlock(driver); umlDriverUnlock(driver);
if (conn) if (conn)
@ -602,10 +601,9 @@ umlReload(void) {
} }
static void static int
umlShutdownOneVM(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque) umlShutdownOneVM(virDomainObjPtr dom, void *opaque)
{ {
virDomainObjPtr dom = payload;
struct uml_driver *driver = opaque; struct uml_driver *driver = opaque;
virObjectLock(dom); virObjectLock(dom);
@ -614,6 +612,7 @@ umlShutdownOneVM(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque)
virDomainAuditStop(dom, "shutdown"); virDomainAuditStop(dom, "shutdown");
} }
virObjectUnlock(dom); virObjectUnlock(dom);
return 0;
} }
/** /**
@ -635,9 +634,9 @@ umlShutdown(void) {
/* shutdown active VMs /* shutdown active VMs
* XXX allow them to stay around & reconnect */ * XXX allow them to stay around & reconnect */
virHashForEach(uml_driver->domains->objs, umlShutdownOneVM, uml_driver); virDomainObjListForEach(uml_driver->domains, umlShutdownOneVM, uml_driver);
virDomainObjListFree(uml_driver->domains); virObjectUnref(uml_driver->domains);
virDomainEventStateFree(uml_driver->domainEventState); virDomainEventStateFree(uml_driver->domainEventState);

2
src/vmware/vmware_conf.c
View File

@ -43,7 +43,7 @@ vmwareFreeDriver(struct vmware_driver *driver)
return; return;
virMutexDestroy(&driver->lock); virMutexDestroy(&driver->lock);
virDomainObjListFree(driver->domains); virObjectUnref(driver->domains);
virCapabilitiesFree(driver->caps); virCapabilitiesFree(driver->caps);
VIR_FREE(driver); VIR_FREE(driver);
} }

12
src/vmware/vmware_driver.c
View File

@ -946,19 +946,19 @@ vmwareDomainXMLFromNative(virConnectPtr conn, const char *nativeFormat,
return xml; return xml;
} }
static void vmwareDomainObjListUpdateDomain(void *payload, const void *name ATTRIBUTE_UNUSED, void *data) static int vmwareDomainObjListUpdateDomain(virDomainObjPtr dom, void *data)
{ {
struct vmware_driver *driver = data; struct vmware_driver *driver = data;
virDomainObjPtr vm = payload; virObjectLock(dom);
virObjectLock(vm); ignore_value(vmwareUpdateVMStatus(driver, dom));
ignore_value(vmwareUpdateVMStatus(driver, vm)); virObjectUnlock(dom);
virObjectUnlock(vm); return 0;
} }
static void static void
vmwareDomainObjListUpdateAll(virDomainObjListPtr doms, struct vmware_driver *driver) vmwareDomainObjListUpdateAll(virDomainObjListPtr doms, struct vmware_driver *driver)
{ {
virHashForEach(doms->objs, vmwareDomainObjListUpdateDomain, driver); virDomainObjListForEach(doms, vmwareDomainObjListUpdateDomain, driver);
} }
static int static int