--name=virNWFilterRuleDefFree \
--name=virNWFilterRuleInstFree \
--name=virNetworkDefFree \
- --name=virNetworkObjFree \
--name=virNodeDeviceDefFree \
--name=virNodeDeviceObjFree \
--name=virObjectUnref \
# y virNetworkDefFree
# n virNetworkFree (returns int)
# n virNetworkFreeName (returns int)
-# y virNetworkObjFree
# n virNodeDevCapsDefFree FIXME
# y virNodeDeviceDefFree
# n virNodeDeviceFree (returns int)
VIR_ENUM_IMPL(virNetworkTaint, VIR_NETWORK_TAINT_LAST,
"hook-script");
+static virClassPtr virNetworkObjClass;
static virClassPtr virNetworkObjListClass;
+static void virNetworkObjDispose(void *obj);
static void virNetworkObjListDispose(void *obj);
static int virNetworkObjOnceInit(void)
{
+ if (!(virNetworkObjClass = virClassNew(virClassForObjectLockable(),
+ "virNetworkObj",
+ sizeof(virNetworkObj),
+ virNetworkObjDispose)))
+ return -1;
+
if (!(virNetworkObjListClass = virClassNew(virClassForObject(),
"virNetworkObjList",
sizeof(virNetworkObjList),
VIR_ONCE_GLOBAL_INIT(virNetworkObj)
-static void
-virNetworkObjListDataFree(void *payload, const void *name ATTRIBUTE_UNUSED)
+virNetworkObjPtr
+virNetworkObjNew(void)
{
- virNetworkObjPtr obj = payload;
- virNetworkObjFree(obj);
+ virNetworkObjPtr net;
+
+ if (virNetworkObjInitialize() < 0)
+ return NULL;
+
+ if (!(net = virObjectLockableNew(virNetworkObjClass)))
+ return NULL;
+
+ if (!(net->class_id = virBitmapNew(CLASS_ID_BITMAP_SIZE)))
+ goto error;
+
+ /* The first three class IDs are already taken */
+ ignore_value(virBitmapSetBit(net->class_id, 0));
+ ignore_value(virBitmapSetBit(net->class_id, 1));
+ ignore_value(virBitmapSetBit(net->class_id, 2));
+
+ return net;
+
+ error:
+ virObjectUnref(net);
+ return NULL;
}
virNetworkObjListPtr virNetworkObjListNew(void)
if (!(nets = virObjectNew(virNetworkObjListClass)))
return NULL;
- if (!(nets->objs = virHashCreate(50, virNetworkObjListDataFree))) {
+ if (!(nets->objs = virHashCreate(50, virObjectFreeHashData))) {
virObjectUnref(nets);
return NULL;
}
ret = virHashLookup(nets->objs, uuidstr);
if (ret)
- virNetworkObjLock(ret);
+ virObjectLock(ret);
return ret;
}
virNetworkObjPtr net = (virNetworkObjPtr) payload;
int want = 0;
- virNetworkObjLock(net);
+ virObjectLock(net);
if (STREQ(net->def->name, (const char *)data))
want = 1;
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return want;
}
ret = virHashSearch(nets->objs, virNetworkObjSearchName, name);
if (ret)
- virNetworkObjLock(ret);
+ virObjectLock(ret);
return ret;
}
VIR_FREE(def);
}
-void virNetworkObjFree(virNetworkObjPtr net)
+static void
+virNetworkObjDispose(void *obj)
{
- if (!net)
- return;
+ virNetworkObjPtr net = obj;
virNetworkDefFree(net->def);
virNetworkDefFree(net->newDef);
virBitmapFree(net->class_id);
-
- virMutexDestroy(&net->lock);
-
- VIR_FREE(net);
}
static void
return network;
}
- if (VIR_ALLOC(network) < 0)
+ if (!(network = virNetworkObjNew()))
return NULL;
- if (virMutexInit(&network->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- "%s", _("cannot initialize mutex"));
- VIR_FREE(network);
- return NULL;
- }
- virNetworkObjLock(network);
-
- if (!(network->class_id = virBitmapNew(CLASS_ID_BITMAP_SIZE)))
- goto error;
+ virObjectLock(network);
virUUIDFormat(def->uuid, uuidstr);
if (virHashAddEntry(nets->objs, uuidstr, network) < 0)
goto error;
- /* The first three class IDs are already taken */
- ignore_value(virBitmapSetBit(network->class_id, 0));
- ignore_value(virBitmapSetBit(network->class_id, 1));
- ignore_value(virBitmapSetBit(network->class_id, 2));
-
network->def = def;
network->persistent = !live;
return network;
error:
- virNetworkObjUnlock(network);
- virNetworkObjFree(network);
+ virObjectUnlock(network);
+ virObjectUnref(network);
return NULL;
}
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(net->def->uuid, uuidstr);
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
virHashRemoveEntry(nets->objs, uuidstr);
}
continue;
if ((net = virNetworkLoadState(nets, stateDir, entry->d_name)))
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
}
closedir(dir);
autostartDir,
entry->d_name);
if (net)
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
}
closedir(dir);
virNetworkObjPtr net = (virNetworkObjPtr) payload;
const struct virNetworkBridgeInUseHelperData *data = opaque;
- virNetworkObjLock(net);
+ virObjectLock(net);
if (net->def->bridge &&
STREQ(net->def->bridge, data->bridge) &&
!(data->skipname && STREQ(net->def->name, data->skipname)))
ret = 1;
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return ret;
}
cleanup:
if (net)
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return ret;
}
-void virNetworkObjLock(virNetworkObjPtr obj)
-{
- virMutexLock(&obj->lock);
-}
-
-void virNetworkObjUnlock(virNetworkObjPtr obj)
-{
- virMutexUnlock(&obj->lock);
-}
-
#define MATCH(FLAG) (flags & (FLAG))
static bool
virNetworkMatch(virNetworkObjPtr netobj,
if (data->error)
return;
- virNetworkObjLock(obj);
+ virObjectLock(obj);
if (data->filter &&
!data->filter(data->conn, obj->def))
data->nets[data->nnets++] = net;
cleanup:
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
}
int
data->got == data->nnames)
return;
- virNetworkObjLock(obj);
+ virObjectLock(obj);
if (data->filter &&
!data->filter(data->conn, obj->def))
}
cleanup:
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
}
int
virNetworkObjPtr obj = (virNetworkObjPtr) payload;
int want = 0;
- virNetworkObjLock(obj);
+ virObjectLock(obj);
want = virNetworkMatch(obj, data->flags);
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return want;
}
typedef struct _virNetworkObj virNetworkObj;
typedef virNetworkObj *virNetworkObjPtr;
struct _virNetworkObj {
- virMutex lock;
+ virObjectLockable parent;
pid_t dnsmasqPid;
pid_t radvdPid;
unsigned int taint;
};
+virNetworkObjPtr virNetworkObjNew(void);
+
typedef struct _virNetworkObjList virNetworkObjList;
typedef virNetworkObjList *virNetworkObjListPtr;
virNetworkTaintFlags taint);
void virNetworkDefFree(virNetworkDefPtr def);
-void virNetworkObjFree(virNetworkObjPtr net);
typedef bool (*virNetworkObjListFilter)(virConnectPtr conn,
virNetworkDefPtr def);
virNetworkDefPtr def,
bool check_active);
-void virNetworkObjLock(virNetworkObjPtr obj);
-void virNetworkObjUnlock(virNetworkObjPtr obj);
-
VIR_ENUM_DECL(virNetworkForward)
# define VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE \
virNetworkObjAssignDef;
virNetworkObjFindByName;
virNetworkObjFindByUUID;
-virNetworkObjFree;
virNetworkObjGetPersistentDef;
virNetworkObjIsDuplicate;
virNetworkObjListExport;
virNetworkObjListNew;
virNetworkObjListNumOfNetworks;
virNetworkObjListPrune;
-virNetworkObjLock;
+virNetworkObjNew;
virNetworkObjReplacePersistentDef;
virNetworkObjSetDefTransient;
virNetworkObjTaint;
-virNetworkObjUnlock;
virNetworkObjUnsetDefTransient;
virNetworkObjUpdate;
virNetworkRemoveInactive;
{
int ret = -1;
- virNetworkObjLock(obj);
+ virObjectLock(obj);
if (!virNetworkObjIsActive(obj)) {
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return 0;
}
ret = 0;
cleanup:
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
{
int ret = -1;
- virNetworkObjLock(net);
+ virObjectLock(net);
if (net->autostart &&
!virNetworkObjIsActive(net) &&
networkStartNetwork(net) < 0)
ret = 0;
cleanup:
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return ret;
}
void *opaque ATTRIBUTE_UNUSED)
{
- virNetworkObjLock(net);
+ virObjectLock(net);
if (virNetworkObjIsActive(net) &&
((net->def->forward.type == VIR_NETWORK_FORWARD_NONE) ||
(net->def->forward.type == VIR_NETWORK_FORWARD_NAT) ||
networkRefreshDhcpDaemon(net);
networkRefreshRadvd(net);
}
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return 0;
}
void *opaque ATTRIBUTE_UNUSED)
{
- virNetworkObjLock(net);
+ virObjectLock(net);
if (virNetworkObjIsActive(net) &&
((net->def->forward.type == VIR_NETWORK_FORWARD_NONE) ||
(net->def->forward.type == VIR_NETWORK_FORWARD_NAT) ||
/* failed to add but already logged */
}
}
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return 0;
}
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
cleanup:
if (obj)
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
if (event)
virObjectEventStateQueue(driver->networkEventState, event);
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
networkDriverUnlock();
return ret;
}
if (freeDef)
virNetworkDefFree(def);
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
networkDriverUnlock();
return ret;
}
if (event)
virObjectEventStateQueue(driver->networkEventState, event);
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
networkDriverUnlock();
return ret;
}
ret = 0;
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
networkDriverUnlock();
return ret;
}
if (event)
virObjectEventStateQueue(driver->networkEventState, event);
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
networkDriverUnlock();
return ret;
}
if (event)
virObjectEventStateQueue(driver->networkEventState, event);
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
networkDriverUnlock();
return ret;
}
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return bridge;
}
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
VIR_FREE(configFile);
VIR_FREE(autostartLink);
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
networkDriverUnlock();
return ret;
}
virJSONValueFree(leases_array);
if (obj)
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return rv;
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
error:
ret = 0;
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
error:
ret = 0;
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
if (iface->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
virDomainActualNetDefFree(iface->data.network.actual);
iface->data.network.actual = NULL;
ret = 0;
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
goto cleanup;
net->active = 1;
net->autostart = 1;
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return net;
cleanup:
}
net->active = 1;
net->autostart = 1;
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return net;
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
cleanup:
if (obj)
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
return ret;
}
goto error;
}
netobj->active = 1;
- virNetworkObjUnlock(netobj);
+ virObjectUnlock(netobj);
if (!(interfacedef = virInterfaceDefParseString(defaultInterfaceXML)))
goto error;
}
obj->active = 1;
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
}
ret = 0;
cleanup:
if (net)
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return ret;
}
cleanup:
if (net)
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
return ret;
}
cleanup:
if (obj)
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
cleanup:
if (obj)
- virNetworkObjUnlock(obj);
+ virObjectUnlock(obj);
return ret;
}
if (event)
testObjectEventQueue(privconn, event);
if (net)
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
testDriverUnlock(privconn);
return ret;
}
if (event)
testObjectEventQueue(privconn, event);
if (net)
- virNetworkObjUnlock(net);
+ virObjectUnlock(net);
testDriverUnlock(privconn);
return ret;
}
if (event)
testObjectEventQueue(privconn, event);
if (privnet)
- virNetworkObjUnlock(privnet);
+ virObjectUnlock(privnet);
testDriverUnlock(privconn);
return ret;
}
ret = 0;
cleanup:
if (network)
- virNetworkObjUnlock(network);
+ virObjectUnlock(network);
testDriverUnlock(privconn);
return ret;
}
if (event)
testObjectEventQueue(privconn, event);
if (privnet)
- virNetworkObjUnlock(privnet);
+ virObjectUnlock(privnet);
return ret;
}
if (event)
testObjectEventQueue(privconn, event);
if (privnet)
- virNetworkObjUnlock(privnet);
+ virObjectUnlock(privnet);
testDriverUnlock(privconn);
return ret;
}
cleanup:
if (privnet)
- virNetworkObjUnlock(privnet);
+ virObjectUnlock(privnet);
return ret;
}
cleanup:
if (privnet)
- virNetworkObjUnlock(privnet);
+ virObjectUnlock(privnet);
return bridge;
}
cleanup:
if (privnet)
- virNetworkObjUnlock(privnet);
+ virObjectUnlock(privnet);
return ret;
}
cleanup:
if (privnet)
- virNetworkObjUnlock(privnet);
+ virObjectUnlock(privnet);
return ret;
}
if (!(dev = virNetworkDefParseString(inXmlData)))
goto fail;
- if (VIR_ALLOC(obj) < 0)
+ if (!(obj = virNetworkObjNew()))
goto fail;
obj->def = dev;
VIR_FREE(actual);
VIR_FREE(pidfile);
virCommandFree(cmd);
- virNetworkObjFree(obj);
+ virObjectUnref(obj);
dnsmasqContextFree(dctx);
return ret;
}
*)
let objectLockMethods = [
"virDomainObjLock";
- "virNetworkObjLock";
"virStoragePoolObjLock";
"virNodeDevObjLock"
]
*)
let objectUnlockMethods = [
"virDomainObjUnlock";
- "virNetworkObjUnlock";
"virStoragePoolObjUnlock";
"virNodeDevObjUnlock"
]