External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-07 18:35:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Simplify "NWFilterPool" to "NWFilter"

Browse Source 
The public object is called NWFilter but the corresponding private
object is called NWFilterPool. I don't see compelling reasons for this
Pool suffix. One might argue that an NWFilter is a "pool" of rules, etc.

Remove the Pool suffix from NWFilterPool. No functional change included.
This commit is contained in:
Matthias Bolte 2011-01-15 16:06:52 +01:00
parent f002e9218d
commit 2c0db5b5dc
10 changed files with 276 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
cfg.mk
View File

@ -116,7 +116,7 @@ useless_free_options = \
--name=virNWFilterHashTableFree \ --name=virNWFilterHashTableFree \
--name=virNWFilterIPAddrLearnReqFree \ --name=virNWFilterIPAddrLearnReqFree \
--name=virNWFilterIncludeDefFree \ --name=virNWFilterIncludeDefFree \
--name=virNWFilterPoolObjFree \ --name=virNWFilterObjFree \
--name=virNWFilterRuleDefFree \ --name=virNWFilterRuleDefFree \
--name=virNWFilterRuleInstFree \ --name=virNWFilterRuleInstFree \
--name=virNetworkDefFree \ --name=virNetworkDefFree \
@ -194,9 +194,9 @@ useless_free_options = \
# y virNWFilterHashTableFree # y virNWFilterHashTableFree
# y virNWFilterIPAddrLearnReqFree # y virNWFilterIPAddrLearnReqFree
# y virNWFilterIncludeDefFree # y virNWFilterIncludeDefFree
# n virNWFilterPoolFreeName (returns int) # n virNWFilterFreeName (returns int)
# y virNWFilterPoolObjFree # y virNWFilterObjFree
# n virNWFilterPoolObjListFree FIXME # n virNWFilterObjListFree FIXME
# y virNWFilterRuleDefFree # y virNWFilterRuleDefFree
# n virNWFilterRuleFreeInstanceData (typedef) # n virNWFilterRuleFreeInstanceData (typedef)
# y virNWFilterRuleInstFree # y virNWFilterRuleInstFree

237
src/conf/nwfilter_conf.c
View File

@ -299,7 +299,8 @@ virNWFilterDefFree(virNWFilterDefPtr def) {
void void
virNWFilterPoolObjFree(virNWFilterPoolObjPtr obj) { virNWFilterObjFree(virNWFilterObjPtr obj)
{
if (!obj) if (!obj)
return; return;
@ -315,13 +316,13 @@ virNWFilterPoolObjFree(virNWFilterPoolObjPtr obj) {
void void
virNWFilterPoolObjListFree(virNWFilterPoolObjListPtr pools) virNWFilterObjListFree(virNWFilterObjListPtr nwfilters)
{ {
unsigned int i; unsigned int i;
for (i = 0 ; i < pools->count ; i++) for (i = 0 ; i < nwfilters->count ; i++)
virNWFilterPoolObjFree(pools->objs[i]); virNWFilterObjFree(nwfilters->objs[i]);
VIR_FREE(pools->objs); VIR_FREE(nwfilters->objs);
pools->count = 0; nwfilters->count = 0;
} }
@ -382,31 +383,31 @@ virNWFilterRuleDefAddString(virNWFilterRuleDefPtr nwf,
void void
virNWFilterPoolObjRemove(virNWFilterPoolObjListPtr pools, virNWFilterObjRemove(virNWFilterObjListPtr nwfilters,
virNWFilterPoolObjPtr pool) virNWFilterObjPtr nwfilter)
{ {
unsigned int i; unsigned int i;
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
for (i = 0 ; i < pools->count ; i++) { for (i = 0 ; i < nwfilters->count ; i++) {
virNWFilterPoolObjLock(pools->objs[i]); virNWFilterObjLock(nwfilters->objs[i]);
if (pools->objs[i] == pool) { if (nwfilters->objs[i] == nwfilter) {
virNWFilterPoolObjUnlock(pools->objs[i]); virNWFilterObjUnlock(nwfilters->objs[i]);
virNWFilterPoolObjFree(pools->objs[i]); virNWFilterObjFree(nwfilters->objs[i]);
if (i < (pools->count - 1)) if (i < (nwfilters->count - 1))
memmove(pools->objs + i, pools->objs + i + 1, memmove(nwfilters->objs + i, nwfilters->objs + i + 1,
sizeof(*(pools->objs)) * (pools->count - (i + 1))); sizeof(*(nwfilters->objs)) * (nwfilters->count - (i + 1)));
if (VIR_REALLOC_N(pools->objs, pools->count - 1) < 0) { if (VIR_REALLOC_N(nwfilters->objs, nwfilters->count - 1) < 0) {
; /* Failure to reduce memory allocation isn't fatal */ ; /* Failure to reduce memory allocation isn't fatal */
} }
pools->count--; nwfilters->count--;
break; break;
} }
virNWFilterPoolObjUnlock(pools->objs[i]); virNWFilterObjUnlock(nwfilters->objs[i]);
} }
} }
@ -1998,7 +1999,7 @@ virNWFilterDefParseNode(xmlDocPtr xml,
if (STRNEQ((const char *)root->name, "filter")) { if (STRNEQ((const char *)root->name, "filter")) {
virNWFilterReportError(VIR_ERR_XML_ERROR, virNWFilterReportError(VIR_ERR_XML_ERROR,
"%s", "%s",
_("unknown root element for nw filter pool")); _("unknown root element for nw filter"));
goto cleanup; goto cleanup;
} }
@ -2089,34 +2090,33 @@ virNWFilterDefParseFile(virConnectPtr conn,
} }
virNWFilterPoolObjPtr virNWFilterObjPtr
virNWFilterPoolObjFindByUUID(virNWFilterPoolObjListPtr pools, virNWFilterObjFindByUUID(virNWFilterObjListPtr nwfilters,
const unsigned char *uuid) const unsigned char *uuid)
{ {
unsigned int i; unsigned int i;
for (i = 0 ; i < pools->count ; i++) { for (i = 0 ; i < nwfilters->count ; i++) {
virNWFilterPoolObjLock(pools->objs[i]); virNWFilterObjLock(nwfilters->objs[i]);
if (!memcmp(pools->objs[i]->def->uuid, uuid, VIR_UUID_BUFLEN)) if (!memcmp(nwfilters->objs[i]->def->uuid, uuid, VIR_UUID_BUFLEN))
return pools->objs[i]; return nwfilters->objs[i];
virNWFilterPoolObjUnlock(pools->objs[i]); virNWFilterObjUnlock(nwfilters->objs[i]);
} }
return NULL; return NULL;
} }
virNWFilterPoolObjPtr virNWFilterObjPtr
virNWFilterPoolObjFindByName(virNWFilterPoolObjListPtr pools, virNWFilterObjFindByName(virNWFilterObjListPtr nwfilters, const char *name)
const char *name)
{ {
unsigned int i; unsigned int i;
for (i = 0 ; i < pools->count ; i++) { for (i = 0 ; i < nwfilters->count ; i++) {
virNWFilterPoolObjLock(pools->objs[i]); virNWFilterObjLock(nwfilters->objs[i]);
if (STREQ(pools->objs[i]->def->name, name)) if (STREQ(nwfilters->objs[i]->def->name, name))
return pools->objs[i]; return nwfilters->objs[i];
virNWFilterPoolObjUnlock(pools->objs[i]); virNWFilterObjUnlock(nwfilters->objs[i]);
} }
return NULL; return NULL;
@ -2197,14 +2197,14 @@ cleanup:
static int static int
_virNWFilterDefLoopDetect(virConnectPtr conn, _virNWFilterDefLoopDetect(virConnectPtr conn,
virNWFilterPoolObjListPtr pools, virNWFilterObjListPtr nwfilters,
virNWFilterDefPtr def, virNWFilterDefPtr def,
const char *filtername) const char *filtername)
{ {
int rc = 0; int rc = 0;
int i; int i;
virNWFilterEntryPtr entry; virNWFilterEntryPtr entry;
virNWFilterPoolObjPtr obj; virNWFilterObjPtr obj;
if (!def) if (!def)
return 0; return 0;
@ -2218,14 +2218,13 @@ _virNWFilterDefLoopDetect(virConnectPtr conn,
break; break;
} }
obj = virNWFilterPoolObjFindByName(pools, obj = virNWFilterObjFindByName(nwfilters,
entry->include->filterref); entry->include->filterref);
if (obj) { if (obj) {
rc = _virNWFilterDefLoopDetect(conn, rc = _virNWFilterDefLoopDetect(conn, nwfilters,
pools,
obj->def, filtername); obj->def, filtername);
virNWFilterPoolObjUnlock(obj); virNWFilterObjUnlock(obj);
if (rc) if (rc)
break; break;
} }
@ -2239,7 +2238,7 @@ _virNWFilterDefLoopDetect(virConnectPtr conn,
/* /*
* virNWFilterDefLoopDetect: * virNWFilterDefLoopDetect:
* @conn: pointer to virConnect object * @conn: pointer to virConnect object
* @pools : the pools to search * @nwfilters : the nwfilters to search
* @def : the filter definiton that may add a loop and is to be tested * @def : the filter definiton that may add a loop and is to be tested
* *
* Detect a loop introduced through the filters being able to * Detect a loop introduced through the filters being able to
@ -2249,10 +2248,10 @@ _virNWFilterDefLoopDetect(virConnectPtr conn,
*/ */
static int static int
virNWFilterDefLoopDetect(virConnectPtr conn, virNWFilterDefLoopDetect(virConnectPtr conn,
virNWFilterPoolObjListPtr pools, virNWFilterObjListPtr nwfilters,
virNWFilterDefPtr def) virNWFilterDefPtr def)
{ {
return _virNWFilterDefLoopDetect(conn, pools, def, def->name); return _virNWFilterDefLoopDetect(conn, nwfilters, def, def->name);
} }
int nCallbackDriver; int nCallbackDriver;
@ -2339,104 +2338,104 @@ virNWFilterTriggerVMFilterRebuild(virConnectPtr conn)
int int
virNWFilterTestUnassignDef(virConnectPtr conn, virNWFilterTestUnassignDef(virConnectPtr conn,
virNWFilterPoolObjPtr pool) virNWFilterObjPtr nwfilter)
{ {
int rc = 0; int rc = 0;
virNWFilterLockFilterUpdates(); virNWFilterLockFilterUpdates();
pool->wantRemoved = 1; nwfilter->wantRemoved = 1;
// trigger the update on VMs referencing the filter // trigger the update on VMs referencing the filter
if (virNWFilterTriggerVMFilterRebuild(conn)) if (virNWFilterTriggerVMFilterRebuild(conn))
rc = 1; rc = 1;
pool->wantRemoved = 0; nwfilter->wantRemoved = 0;
virNWFilterUnlockFilterUpdates(); virNWFilterUnlockFilterUpdates();
return rc; return rc;
} }
virNWFilterPoolObjPtr virNWFilterObjPtr
virNWFilterPoolObjAssignDef(virConnectPtr conn, virNWFilterObjAssignDef(virConnectPtr conn,
virNWFilterPoolObjListPtr pools, virNWFilterObjListPtr nwfilters,
virNWFilterDefPtr def) virNWFilterDefPtr def)
{ {
virNWFilterPoolObjPtr pool; virNWFilterObjPtr nwfilter;
pool = virNWFilterPoolObjFindByUUID(pools, def->uuid); nwfilter = virNWFilterObjFindByUUID(nwfilters, def->uuid);
if (pool) { if (nwfilter) {
if (!STREQ(def->name, pool->def->name)) { if (!STREQ(def->name, nwfilter->def->name)) {
virNWFilterReportError(VIR_ERR_INVALID_NWFILTER, virNWFilterReportError(VIR_ERR_INVALID_NWFILTER,
_("filter with same UUID but different name " _("filter with same UUID but different name "
"('%s') already exists"), "('%s') already exists"),
pool->def->name); nwfilter->def->name);
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
return NULL; return NULL;
} }
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
} }
if (virNWFilterDefLoopDetect(conn, pools, def)) { if (virNWFilterDefLoopDetect(conn, nwfilters, def)) {
virNWFilterReportError(VIR_ERR_INVALID_NWFILTER, virNWFilterReportError(VIR_ERR_INVALID_NWFILTER,
"%s", _("filter would introduce a loop")); "%s", _("filter would introduce a loop"));
return NULL; return NULL;
} }
if ((pool = virNWFilterPoolObjFindByName(pools, def->name))) { if ((nwfilter = virNWFilterObjFindByName(nwfilters, def->name))) {
virNWFilterLockFilterUpdates(); virNWFilterLockFilterUpdates();
pool->newDef = def; nwfilter->newDef = def;
// trigger the update on VMs referencing the filter // trigger the update on VMs referencing the filter
if (virNWFilterTriggerVMFilterRebuild(conn)) { if (virNWFilterTriggerVMFilterRebuild(conn)) {
pool->newDef = NULL; nwfilter->newDef = NULL;
virNWFilterUnlockFilterUpdates(); virNWFilterUnlockFilterUpdates();
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
return NULL; return NULL;
} }
virNWFilterDefFree(pool->def); virNWFilterDefFree(nwfilter->def);
pool->def = def; nwfilter->def = def;
pool->newDef = NULL; nwfilter->newDef = NULL;
virNWFilterUnlockFilterUpdates(); virNWFilterUnlockFilterUpdates();
return pool; return nwfilter;
} }
if (VIR_ALLOC(pool) < 0) { if (VIR_ALLOC(nwfilter) < 0) {
virReportOOMError(); virReportOOMError();
return NULL; return NULL;
} }
if (virMutexInitRecursive(&pool->lock) < 0) { if (virMutexInitRecursive(&nwfilter->lock) < 0) {
virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, virNWFilterReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot initialize mutex")); "%s", _("cannot initialize mutex"));
VIR_FREE(pool); VIR_FREE(nwfilter);
return NULL; return NULL;
} }
virNWFilterPoolObjLock(pool); virNWFilterObjLock(nwfilter);
pool->active = 0; nwfilter->active = 0;
pool->def = def; nwfilter->def = def;
if (VIR_REALLOC_N(pools->objs, pools->count+1) < 0) { if (VIR_REALLOC_N(nwfilters->objs, nwfilters->count + 1) < 0) {
pool->def = NULL; nwfilter->def = NULL;
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
virNWFilterPoolObjFree(pool); virNWFilterObjFree(nwfilter);
virReportOOMError(); virReportOOMError();
return NULL; return NULL;
} }
pools->objs[pools->count++] = pool; nwfilters->objs[nwfilters->count++] = nwfilter;
return pool; return nwfilter;
} }
static virNWFilterPoolObjPtr static virNWFilterObjPtr
virNWFilterPoolObjLoad(virConnectPtr conn, virNWFilterObjLoad(virConnectPtr conn,
virNWFilterPoolObjListPtr pools, virNWFilterObjListPtr nwfilters,
const char *file, const char *file,
const char *path) const char *path)
{ {
virNWFilterDefPtr def; virNWFilterDefPtr def;
virNWFilterPoolObjPtr pool; virNWFilterObjPtr nwfilter;
if (!(def = virNWFilterDefParseFile(conn, path))) { if (!(def = virNWFilterDefParseFile(conn, path))) {
return NULL; return NULL;
@ -2444,33 +2443,33 @@ virNWFilterPoolObjLoad(virConnectPtr conn,
if (!virFileMatchesNameSuffix(file, def->name, ".xml")) { if (!virFileMatchesNameSuffix(file, def->name, ".xml")) {
virNWFilterReportError(VIR_ERR_INVALID_NWFILTER, virNWFilterReportError(VIR_ERR_INVALID_NWFILTER,
_("network filter pool config filename '%s' does not match pool name '%s'"), _("network filter config filename '%s' does not match name '%s'"),
path, def->name); path, def->name);
virNWFilterDefFree(def); virNWFilterDefFree(def);
return NULL; return NULL;
} }
if (!(pool = virNWFilterPoolObjAssignDef(conn, pools, def))) { if (!(nwfilter = virNWFilterObjAssignDef(conn, nwfilters, def))) {
virNWFilterDefFree(def); virNWFilterDefFree(def);
return NULL; return NULL;
} }
VIR_FREE(pool->configFile); // for driver reload VIR_FREE(nwfilter->configFile); // for driver reload
pool->configFile = strdup(path); nwfilter->configFile = strdup(path);
if (pool->configFile == NULL) { if (nwfilter->configFile == NULL) {
virReportOOMError(); virReportOOMError();
virNWFilterDefFree(def); virNWFilterDefFree(def);
return NULL; return NULL;
} }
return pool; return nwfilter;
} }
int int
virNWFilterPoolLoadAllConfigs(virConnectPtr conn, virNWFilterLoadAllConfigs(virConnectPtr conn,
virNWFilterPoolObjListPtr pools, virNWFilterObjListPtr nwfilters,
const char *configDir) const char *configDir)
{ {
DIR *dir; DIR *dir;
struct dirent *entry; struct dirent *entry;
@ -2486,7 +2485,7 @@ virNWFilterPoolLoadAllConfigs(virConnectPtr conn,
while ((entry = readdir(dir))) { while ((entry = readdir(dir))) {
char path[PATH_MAX]; char path[PATH_MAX];
virNWFilterPoolObjPtr pool; virNWFilterObjPtr nwfilter;
if (entry->d_name[0] == '.') if (entry->d_name[0] == '.')
continue; continue;
@ -2502,9 +2501,9 @@ virNWFilterPoolLoadAllConfigs(virConnectPtr conn,
continue; continue;
} }
pool = virNWFilterPoolObjLoad(conn, pools, entry->d_name, path); nwfilter = virNWFilterObjLoad(conn, nwfilters, entry->d_name, path);
if (pool) if (nwfilter)
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
} }
closedir(dir); closedir(dir);
@ -2514,15 +2513,15 @@ virNWFilterPoolLoadAllConfigs(virConnectPtr conn,
int int
virNWFilterPoolObjSaveDef(virNWFilterDriverStatePtr driver, virNWFilterObjSaveDef(virNWFilterDriverStatePtr driver,
virNWFilterPoolObjPtr pool, virNWFilterObjPtr nwfilter,
virNWFilterDefPtr def) virNWFilterDefPtr def)
{ {
char *xml; char *xml;
int fd = -1, ret = -1; int fd = -1, ret = -1;
ssize_t towrite; ssize_t towrite;
if (!pool->configFile) { if (!nwfilter->configFile) {
int err; int err;
char path[PATH_MAX]; char path[PATH_MAX];
@ -2539,7 +2538,7 @@ virNWFilterPoolObjSaveDef(virNWFilterDriverStatePtr driver,
"%s", _("cannot construct config file path")); "%s", _("cannot construct config file path"));
return -1; return -1;
} }
if (!(pool->configFile = strdup(path))) { if (!(nwfilter->configFile = strdup(path))) {
virReportOOMError(); virReportOOMError();
return -1; return -1;
} }
@ -2551,12 +2550,12 @@ virNWFilterPoolObjSaveDef(virNWFilterDriverStatePtr driver,
return -1; return -1;
} }
if ((fd = open(pool->configFile, if ((fd = open(nwfilter->configFile,
O_WRONLY | O_CREAT | O_TRUNC, O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR )) < 0) { S_IRUSR | S_IWUSR )) < 0) {
virReportSystemError(errno, virReportSystemError(errno,
_("cannot create config file %s"), _("cannot create config file %s"),
pool->configFile); nwfilter->configFile);
goto cleanup; goto cleanup;
} }
@ -2564,14 +2563,14 @@ virNWFilterPoolObjSaveDef(virNWFilterDriverStatePtr driver,
if (safewrite(fd, xml, towrite) != towrite) { if (safewrite(fd, xml, towrite) != towrite) {
virReportSystemError(errno, virReportSystemError(errno,
_("cannot write config file %s"), _("cannot write config file %s"),
pool->configFile); nwfilter->configFile);
goto cleanup; goto cleanup;
} }
if (VIR_CLOSE(fd) < 0) { if (VIR_CLOSE(fd) < 0) {
virReportSystemError(errno, virReportSystemError(errno,
_("cannot save config file %s"), _("cannot save config file %s"),
pool->configFile); nwfilter->configFile);
goto cleanup; goto cleanup;
} }
@ -2587,18 +2586,18 @@ virNWFilterPoolObjSaveDef(virNWFilterDriverStatePtr driver,
int int
virNWFilterPoolObjDeleteDef(virNWFilterPoolObjPtr pool) virNWFilterObjDeleteDef(virNWFilterObjPtr nwfilter)
{ {
if (!pool->configFile) { if (!nwfilter->configFile) {
virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, virNWFilterReportError(VIR_ERR_INTERNAL_ERROR,
_("no config file for %s"), pool->def->name); _("no config file for %s"), nwfilter->def->name);
return -1; return -1;
} }
if (unlink(pool->configFile) < 0) { if (unlink(nwfilter->configFile) < 0) {
virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, virNWFilterReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot remove config for %s"), _("cannot remove config for %s"),
pool->def->name); nwfilter->def->name);
return -1; return -1;
} }
@ -2900,12 +2899,12 @@ void virNWFilterConfLayerShutdown(void)
} }
void virNWFilterPoolObjLock(virNWFilterPoolObjPtr obj) void virNWFilterObjLock(virNWFilterObjPtr obj)
{ {
virMutexLock(&obj->lock); virMutexLock(&obj->lock);
} }
void virNWFilterPoolObjUnlock(virNWFilterPoolObjPtr obj) void virNWFilterObjUnlock(virNWFilterObjPtr obj)
{ {
virMutexUnlock(&obj->lock); virMutexUnlock(&obj->lock);
} }

60
src/conf/nwfilter_conf.h
View File

@ -441,10 +441,10 @@ struct _virNWFilterDef {
}; };
typedef struct _virNWFilterPoolObj virNWFilterPoolObj; typedef struct _virNWFilterObj virNWFilterObj;
typedef virNWFilterPoolObj *virNWFilterPoolObjPtr; typedef virNWFilterObj *virNWFilterObjPtr;
struct _virNWFilterPoolObj { struct _virNWFilterObj {
virMutex lock; virMutex lock;
char *configFile; char *configFile;
@ -456,11 +456,11 @@ struct _virNWFilterPoolObj {
}; };
typedef struct _virNWFilterPoolObjList virNWFilterPoolObjList; typedef struct _virNWFilterObjList virNWFilterObjList;
typedef virNWFilterPoolObjList *virNWFilterPoolObjListPtr; typedef virNWFilterObjList *virNWFilterObjListPtr;
struct _virNWFilterPoolObjList { struct _virNWFilterObjList {
unsigned int count; unsigned int count;
virNWFilterPoolObjPtr *objs; virNWFilterObjPtr *objs;
}; };
@ -469,7 +469,7 @@ typedef virNWFilterDriverState *virNWFilterDriverStatePtr;
struct _virNWFilterDriverState { struct _virNWFilterDriverState {
virMutex lock; virMutex lock;
virNWFilterPoolObjList pools; virNWFilterObjList nwfilters;
char *configDir; char *configDir;
}; };
@ -583,33 +583,31 @@ struct _virNWFilterTechDriver {
void virNWFilterRuleDefFree(virNWFilterRuleDefPtr def); void virNWFilterRuleDefFree(virNWFilterRuleDefPtr def);
void virNWFilterDefFree(virNWFilterDefPtr def); void virNWFilterDefFree(virNWFilterDefPtr def);
void virNWFilterPoolObjListFree(virNWFilterPoolObjListPtr pools); void virNWFilterObjListFree(virNWFilterObjListPtr nwfilters);
void virNWFilterPoolObjRemove(virNWFilterPoolObjListPtr pools, void virNWFilterObjRemove(virNWFilterObjListPtr nwfilters,
virNWFilterPoolObjPtr pool); virNWFilterObjPtr nwfilter);
void virNWFilterPoolObjFree(virNWFilterPoolObjPtr obj); void virNWFilterObjFree(virNWFilterObjPtr obj);
virNWFilterPoolObjPtr virNWFilterObjPtr virNWFilterObjFindByUUID(virNWFilterObjListPtr nwfilters,
virNWFilterPoolObjFindByUUID(virNWFilterPoolObjListPtr pools, const unsigned char *uuid);
const unsigned char *uuid);
virNWFilterPoolObjPtr virNWFilterObjPtr virNWFilterObjFindByName(virNWFilterObjListPtr nwfilters,
virNWFilterPoolObjFindByName(virNWFilterPoolObjListPtr pools, const char *name);
const char *name);
int virNWFilterPoolObjSaveDef(virNWFilterDriverStatePtr driver, int virNWFilterObjSaveDef(virNWFilterDriverStatePtr driver,
virNWFilterPoolObjPtr pool, virNWFilterObjPtr nwfilter,
virNWFilterDefPtr def); virNWFilterDefPtr def);
int virNWFilterPoolObjDeleteDef(virNWFilterPoolObjPtr pool); int virNWFilterObjDeleteDef(virNWFilterObjPtr nwfilter);
virNWFilterPoolObjPtr virNWFilterPoolObjAssignDef(virConnectPtr conn, virNWFilterObjPtr virNWFilterObjAssignDef(virConnectPtr conn,
virNWFilterPoolObjListPtr pools, virNWFilterObjListPtr nwfilters,
virNWFilterDefPtr def); virNWFilterDefPtr def);
int virNWFilterTestUnassignDef(virConnectPtr conn, int virNWFilterTestUnassignDef(virConnectPtr conn,
virNWFilterPoolObjPtr pool); virNWFilterObjPtr nwfilter);
virNWFilterDefPtr virNWFilterDefParseNode(xmlDocPtr xml, virNWFilterDefPtr virNWFilterDefParseNode(xmlDocPtr xml,
xmlNodePtr root); xmlNodePtr root);
@ -623,9 +621,9 @@ int virNWFilterSaveXML(const char *configDir,
int virNWFilterSaveConfig(const char *configDir, int virNWFilterSaveConfig(const char *configDir,
virNWFilterDefPtr def); virNWFilterDefPtr def);
int virNWFilterPoolLoadAllConfigs(virConnectPtr conn, int virNWFilterLoadAllConfigs(virConnectPtr conn,
virNWFilterPoolObjListPtr pools, virNWFilterObjListPtr nwfilters,
const char *configDir); const char *configDir);
char *virNWFilterConfigFile(const char *dir, char *virNWFilterConfigFile(const char *dir,
const char *name); const char *name);
@ -635,8 +633,8 @@ virNWFilterDefPtr virNWFilterDefParseString(virConnectPtr conn,
virNWFilterDefPtr virNWFilterDefParseFile(virConnectPtr conn, virNWFilterDefPtr virNWFilterDefParseFile(virConnectPtr conn,
const char *filename); const char *filename);
void virNWFilterPoolObjLock(virNWFilterPoolObjPtr obj); void virNWFilterObjLock(virNWFilterObjPtr obj);
void virNWFilterPoolObjUnlock(virNWFilterPoolObjPtr obj); void virNWFilterObjUnlock(virNWFilterObjPtr obj);
void virNWFilterLockFilterUpdates(void); void virNWFilterLockFilterUpdates(void);
void virNWFilterUnlockFilterUpdates(void); void virNWFilterUnlockFilterUpdates(void);

72
src/datatypes.c
View File

@ -126,17 +126,17 @@ virSecretFreeName(virSecretPtr secret, const char *name ATTRIBUTE_UNUSED)
} }
/** /**
* virNWFilterPoolFreeName: * virNWFilterFreeName:
* @pool: a nwfilter pool object * @nwfilter: a nwfilter object
* *
* Destroy the nwfilter pool object, this is just used by the nwfilter pool hash callback. * Destroy the nwfilter object, this is just used by the nwfilter hash callback.
* *
* Returns 0 in case of success and -1 in case of failure. * Returns 0 in case of success and -1 in case of failure.
*/ */
static int static int
virNWFilterPoolFreeName(virNWFilterPtr pool, const char *name ATTRIBUTE_UNUSED) virNWFilterFreeName(virNWFilterPtr nwfilter, const char *name ATTRIBUTE_UNUSED)
{ {
return (virUnrefNWFilter(pool)); return virUnrefNWFilter(nwfilter);
} }
/** /**
@ -200,8 +200,8 @@ virGetConnect(void) {
ret->secrets = virHashCreate(20); ret->secrets = virHashCreate(20);
if (ret->secrets == NULL) if (ret->secrets == NULL)
goto failed; goto failed;
ret->nwfilterPools = virHashCreate(20); ret->nwfilters = virHashCreate(20);
if (ret->nwfilterPools == NULL) if (ret->nwfilters == NULL)
goto failed; goto failed;
ret->refs = 1; ret->refs = 1;
@ -223,8 +223,8 @@ failed:
virHashFree(ret->nodeDevices, (virHashDeallocator) virNodeDeviceFree); virHashFree(ret->nodeDevices, (virHashDeallocator) virNodeDeviceFree);
if (ret->secrets != NULL) if (ret->secrets != NULL)
virHashFree(ret->secrets, (virHashDeallocator) virSecretFreeName); virHashFree(ret->secrets, (virHashDeallocator) virSecretFreeName);
if (ret->nwfilterPools != NULL) if (ret->nwfilters != NULL)
virHashFree(ret->nwfilterPools, (virHashDeallocator) virNWFilterPoolFreeName); virHashFree(ret->nwfilters, (virHashDeallocator) virNWFilterFreeName);
virMutexDestroy(&ret->lock); virMutexDestroy(&ret->lock);
VIR_FREE(ret); VIR_FREE(ret);
@ -281,8 +281,8 @@ virReleaseConnect(virConnectPtr conn) {
virHashFree(conn->nodeDevices, (virHashDeallocator) virNodeDeviceFree); virHashFree(conn->nodeDevices, (virHashDeallocator) virNodeDeviceFree);
if (conn->secrets != NULL) if (conn->secrets != NULL)
virHashFree(conn->secrets, (virHashDeallocator) virSecretFreeName); virHashFree(conn->secrets, (virHashDeallocator) virSecretFreeName);
if (conn->nwfilterPools != NULL) if (conn->nwfilters != NULL)
virHashFree(conn->nwfilterPools, (virHashDeallocator) virNWFilterPoolFreeName); virHashFree(conn->nwfilters, (virHashDeallocator) virNWFilterFreeName);
virResetError(&conn->err); virResetError(&conn->err);
@ -1466,7 +1466,7 @@ int virUnrefStream(virStreamPtr st) {
* Lookup if the network filter is already registered for that connection, * Lookup if the network filter is already registered for that connection,
* if yes return a new pointer to it, if no allocate a new structure, * if yes return a new pointer to it, if no allocate a new structure,
* and register it in the table. In any case a corresponding call to * and register it in the table. In any case a corresponding call to
* virFreeNWFilterPool() is needed to not leak data. * virUnrefNWFilter() is needed to not leak data.
* *
* Returns a pointer to the network, or NULL in case of failure * Returns a pointer to the network, or NULL in case of failure
*/ */
@ -1491,7 +1491,7 @@ virGetNWFilter(virConnectPtr conn, const char *name, const unsigned char *uuid)
virUUIDFormat(uuid, uuidstr); virUUIDFormat(uuid, uuidstr);
ret = (virNWFilterPtr) virHashLookup(conn->nwfilterPools, uuidstr); ret = (virNWFilterPtr) virHashLookup(conn->nwfilters, uuidstr);
if (ret == NULL) { if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) { if (VIR_ALLOC(ret) < 0) {
virMutexUnlock(&conn->lock); virMutexUnlock(&conn->lock);
@ -1508,10 +1508,10 @@ virGetNWFilter(virConnectPtr conn, const char *name, const unsigned char *uuid)
ret->conn = conn; ret->conn = conn;
memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
if (virHashAddEntry(conn->nwfilterPools, uuidstr, ret) < 0) { if (virHashAddEntry(conn->nwfilters, uuidstr, ret) < 0) {
virMutexUnlock(&conn->lock); virMutexUnlock(&conn->lock);
virLibConnError(VIR_ERR_INTERNAL_ERROR, "%s", virLibConnError(VIR_ERR_INTERNAL_ERROR, "%s",
_("failed to add network filter pool to connection hash table")); _("failed to add network filter to connection hash table"));
goto error; goto error;
} }
conn->refs++; conn->refs++;
@ -1530,35 +1530,36 @@ error:
/** /**
* virReleaseNWFilterPool: * virReleaseNWFilter:
* @pool: the pool to release * @nwfilter: the nwfilter to release
* *
* Unconditionally release all memory associated with a pool. * Unconditionally release all memory associated with a nwfilter.
* The conn.lock mutex must be held prior to calling this, and will * The conn.lock mutex must be held prior to calling this, and will
* be released prior to this returning. The pool obj must not * be released prior to this returning. The nwfilter obj must not
* be used once this method returns. * be used once this method returns.
* *
* It will also unreference the associated connection object, * It will also unreference the associated connection object,
* which may also be released if its ref count hits zero. * which may also be released if its ref count hits zero.
*/ */
static void static void
virReleaseNWFilterPool(virNWFilterPtr pool) { virReleaseNWFilter(virNWFilterPtr nwfilter)
virConnectPtr conn = pool->conn; {
virConnectPtr conn = nwfilter->conn;
char uuidstr[VIR_UUID_STRING_BUFLEN]; char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(pool->uuid, uuidstr); virUUIDFormat(nwfilter->uuid, uuidstr);
DEBUG("release pool %p %s %s", pool, pool->name, uuidstr); DEBUG("release nwfilter %p %s %s", nwfilter, nwfilter->name, uuidstr);
if (virHashRemoveEntry(conn->nwfilterPools, uuidstr, NULL) < 0) { if (virHashRemoveEntry(conn->nwfilters, uuidstr, NULL) < 0) {
virMutexUnlock(&conn->lock); virMutexUnlock(&conn->lock);
virLibConnError(VIR_ERR_INTERNAL_ERROR, "%s", virLibConnError(VIR_ERR_INTERNAL_ERROR, "%s",
_("pool missing from connection hash table")); _("pool missing from connection hash table"));
conn = NULL; conn = NULL;
} }
pool->magic = -1; nwfilter->magic = -1;
VIR_FREE(pool->name); VIR_FREE(nwfilter->name);
VIR_FREE(pool); VIR_FREE(nwfilter);
if (conn) { if (conn) {
DEBUG("unref connection %p %d", conn, conn->refs); DEBUG("unref connection %p %d", conn, conn->refs);
@ -1583,25 +1584,26 @@ virReleaseNWFilterPool(virNWFilterPtr pool) {
* Returns the reference count or -1 in case of failure. * Returns the reference count or -1 in case of failure.
*/ */
int int
virUnrefNWFilter(virNWFilterPtr pool) { virUnrefNWFilter(virNWFilterPtr nwfilter)
{
int refs; int refs;
if (!VIR_IS_CONNECTED_NWFILTER(pool)) { if (!VIR_IS_CONNECTED_NWFILTER(nwfilter)) {
virLibConnError(VIR_ERR_INVALID_ARG, virLibConnError(VIR_ERR_INVALID_ARG,
_("bad nwfilter or no connection")); _("bad nwfilter or no connection"));
return -1; return -1;
} }
virMutexLock(&pool->conn->lock); virMutexLock(&nwfilter->conn->lock);
DEBUG("unref pool %p %s %d", pool, pool->name, pool->refs); DEBUG("unref pool %p %s %d", nwfilter, nwfilter->name, nwfilter->refs);
pool->refs--; nwfilter->refs--;
refs = pool->refs; refs = nwfilter->refs;
if (refs == 0) { if (refs == 0) {
virReleaseNWFilterPool(pool); virReleaseNWFilter(nwfilter);
/* Already unlocked mutex */ /* Already unlocked mutex */
return (0); return (0);
} }
virMutexUnlock(&pool->conn->lock); virMutexUnlock(&nwfilter->conn->lock);
return (refs); return (refs);
} }

8
src/datatypes.h
View File

@ -194,8 +194,8 @@ struct _virConnect {
virHashTablePtr storagePools;/* hash table for known storage pools */ virHashTablePtr storagePools;/* hash table for known storage pools */
virHashTablePtr storageVols;/* hash table for known storage vols */ virHashTablePtr storageVols;/* hash table for known storage vols */
virHashTablePtr nodeDevices; /* hash table for known node devices */ virHashTablePtr nodeDevices; /* hash table for known node devices */
virHashTablePtr secrets; /* hash taboe for known secrets */ virHashTablePtr secrets; /* hash table for known secrets */
virHashTablePtr nwfilterPools; /* hash tables ofr known nw filter pools */ virHashTablePtr nwfilters; /* hash table for known nw filters */
int refs; /* reference count */ int refs; /* reference count */
}; };
@ -387,10 +387,10 @@ struct _virNWFilter {
virNWFilterPtr virGetNWFilter(virConnectPtr conn, virNWFilterPtr virGetNWFilter(virConnectPtr conn,
const char *name, const char *name,
const unsigned char *uuid); const unsigned char *uuid);
int virUnrefNWFilter(virNWFilterPtr pool); int virUnrefNWFilter(virNWFilterPtr nwfilter);
virDomainSnapshotPtr virGetDomainSnapshot(virDomainPtr domain, virDomainSnapshotPtr virGetDomainSnapshot(virDomainPtr domain,
const char *name); const char *name);
int virUnrefDomainSnapshot(virDomainSnapshotPtr pool); int virUnrefDomainSnapshot(virDomainSnapshotPtr snapshot);
#endif #endif

4
src/driver.h
View File

@ -1138,10 +1138,10 @@ typedef virNWFilterPtr
const char *xmlDesc, const char *xmlDesc,
unsigned int flags); unsigned int flags);
typedef int typedef int
(*virDrvNWFilterUndefine) (virNWFilterPtr pool); (*virDrvNWFilterUndefine) (virNWFilterPtr nwfilter);
typedef char * typedef char *
(*virDrvNWFilterGetXMLDesc) (virNWFilterPtr pool, (*virDrvNWFilterGetXMLDesc) (virNWFilterPtr nwfilter,
unsigned int flags); unsigned int flags);

4
src/libvirt.c
View File

@ -705,7 +705,7 @@ virLibSecretError(virSecretPtr secret, virErrorNumber error, const char *info)
* Handle an error at the connection level * Handle an error at the connection level
*/ */
static void static void
virLibNWFilterError(virNWFilterPtr pool, virErrorNumber error, virLibNWFilterError(virNWFilterPtr nwfilter, virErrorNumber error,
const char *info) const char *info)
{ {
virConnectPtr conn = NULL; virConnectPtr conn = NULL;
@ -716,7 +716,7 @@ virLibNWFilterError(virNWFilterPtr pool, virErrorNumber error,
errmsg = virErrorMsg(error, info); errmsg = virErrorMsg(error, info);
if (error != VIR_ERR_INVALID_NWFILTER) if (error != VIR_ERR_INVALID_NWFILTER)
conn = pool->conn; conn = nwfilter->conn;
virRaiseError(conn, NULL, NULL, VIR_FROM_NWFILTER, error, VIR_ERR_ERROR, virRaiseError(conn, NULL, NULL, VIR_FROM_NWFILTER, error, VIR_ERR_ERROR,
errmsg, info, NULL, 0, 0, errmsg, info); errmsg, info, NULL, 0, 0, errmsg, info);

20
src/libvirt_private.syms
View File

@ -637,17 +637,17 @@ virNWFilterDefFormat;
virNWFilterDefFree; virNWFilterDefFree;
virNWFilterDefParseString; virNWFilterDefParseString;
virNWFilterJumpTargetTypeToString; virNWFilterJumpTargetTypeToString;
virNWFilterLoadAllConfigs;
virNWFilterLockFilterUpdates; virNWFilterLockFilterUpdates;
virNWFilterPoolLoadAllConfigs; virNWFilterObjAssignDef;
virNWFilterPoolObjAssignDef; virNWFilterObjDeleteDef;
virNWFilterPoolObjDeleteDef; virNWFilterObjFindByName;
virNWFilterPoolObjFindByName; virNWFilterObjFindByUUID;
virNWFilterPoolObjFindByUUID; virNWFilterObjListFree;
virNWFilterPoolObjListFree; virNWFilterObjLock;
virNWFilterPoolObjLock; virNWFilterObjRemove;
virNWFilterPoolObjRemove; virNWFilterObjSaveDef;
virNWFilterPoolObjSaveDef; virNWFilterObjUnlock;
virNWFilterPoolObjUnlock;
virNWFilterPrintStateMatchFlags; virNWFilterPrintStateMatchFlags;
virNWFilterRegisterCallbackDriver; virNWFilterRegisterCallbackDriver;
virNWFilterRuleActionTypeToString; virNWFilterRuleActionTypeToString;

112
src/nwfilter/nwfilter_driver.c
View File

@ -105,9 +105,9 @@ nwfilterDriverStartup(int privileged) {
VIR_FREE(base); VIR_FREE(base);
if (virNWFilterPoolLoadAllConfigs(NULL, if (virNWFilterLoadAllConfigs(NULL,
&driverState->pools, &driverState->nwfilters,
driverState->configDir) < 0) driverState->configDir) < 0)
goto error; goto error;
nwfilterDriverUnlock(driverState); nwfilterDriverUnlock(driverState);
@ -155,9 +155,9 @@ nwfilterDriverReload(void) {
nwfilterDriverLock(driverState); nwfilterDriverLock(driverState);
virNWFilterCallbackDriversLock(); virNWFilterCallbackDriversLock();
virNWFilterPoolLoadAllConfigs(conn, virNWFilterLoadAllConfigs(conn,
&driverState->pools, &driverState->nwfilters,
driverState->configDir); driverState->configDir);
virNWFilterCallbackDriversUnlock(); virNWFilterCallbackDriversUnlock();
nwfilterDriverUnlock(driverState); nwfilterDriverUnlock(driverState);
@ -171,7 +171,7 @@ nwfilterDriverReload(void) {
/** /**
* virNWFilterActive: * virNWFilterActive:
* *
* Checks if the nwfilter driver is active, i.e. has an active pool * Checks if the nwfilter driver is active, i.e. has an active nwfilter
* *
* Returns 1 if active, 0 otherwise * Returns 1 if active, 0 otherwise
*/ */
@ -183,7 +183,7 @@ nwfilterDriverActive(void) {
return 0; return 0;
nwfilterDriverLock(driverState); nwfilterDriverLock(driverState);
ret = driverState->pools.count ? 1 : 0; ret = driverState->nwfilters.count ? 1 : 0;
nwfilterDriverUnlock(driverState); nwfilterDriverUnlock(driverState);
return ret; return ret;
@ -192,7 +192,7 @@ nwfilterDriverActive(void) {
/** /**
* virNWFilterShutdown: * virNWFilterShutdown:
* *
* Shutdown the nwfilter driver, it will stop all active nwfilter pools * Shutdown the nwfilter driver, it will stop all active nwfilters
*/ */
static int static int
nwfilterDriverShutdown(void) { nwfilterDriverShutdown(void) {
@ -203,8 +203,8 @@ nwfilterDriverShutdown(void) {
nwfilterDriverLock(driverState); nwfilterDriverLock(driverState);
/* free inactive pools */ /* free inactive nwfilters */
virNWFilterPoolObjListFree(&driverState->pools); virNWFilterObjListFree(&driverState->nwfilters);
VIR_FREE(driverState->configDir); VIR_FREE(driverState->configDir);
nwfilterDriverUnlock(driverState); nwfilterDriverUnlock(driverState);
@ -219,24 +219,24 @@ static virNWFilterPtr
nwfilterLookupByUUID(virConnectPtr conn, nwfilterLookupByUUID(virConnectPtr conn,
const unsigned char *uuid) { const unsigned char *uuid) {
virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData; virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData;
virNWFilterPoolObjPtr pool; virNWFilterObjPtr nwfilter;
virNWFilterPtr ret = NULL; virNWFilterPtr ret = NULL;
nwfilterDriverLock(driver); nwfilterDriverLock(driver);
pool = virNWFilterPoolObjFindByUUID(&driver->pools, uuid); nwfilter = virNWFilterObjFindByUUID(&driver->nwfilters, uuid);
nwfilterDriverUnlock(driver); nwfilterDriverUnlock(driver);
if (!pool) { if (!nwfilter) {
virNWFilterReportError(VIR_ERR_NO_NWFILTER, virNWFilterReportError(VIR_ERR_NO_NWFILTER,
"%s", _("no pool with matching uuid")); "%s", _("no nwfilter with matching uuid"));
goto cleanup; goto cleanup;
} }
ret = virGetNWFilter(conn, pool->def->name, pool->def->uuid); ret = virGetNWFilter(conn, nwfilter->def->name, nwfilter->def->uuid);
cleanup: cleanup:
if (pool) if (nwfilter)
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
return ret; return ret;
} }
@ -245,24 +245,24 @@ static virNWFilterPtr
nwfilterLookupByName(virConnectPtr conn, nwfilterLookupByName(virConnectPtr conn,
const char *name) { const char *name) {
virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData; virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData;
virNWFilterPoolObjPtr pool; virNWFilterObjPtr nwfilter;
virNWFilterPtr ret = NULL; virNWFilterPtr ret = NULL;
nwfilterDriverLock(driver); nwfilterDriverLock(driver);
pool = virNWFilterPoolObjFindByName(&driver->pools, name); nwfilter = virNWFilterObjFindByName(&driver->nwfilters, name);
nwfilterDriverUnlock(driver); nwfilterDriverUnlock(driver);
if (!pool) { if (!nwfilter) {
virNWFilterReportError(VIR_ERR_NO_NWFILTER, virNWFilterReportError(VIR_ERR_NO_NWFILTER,
_("no pool with matching name '%s'"), name); _("no nwfilter with matching name '%s'"), name);
goto cleanup; goto cleanup;
} }
ret = virGetNWFilter(conn, pool->def->name, pool->def->uuid); ret = virGetNWFilter(conn, nwfilter->def->name, nwfilter->def->uuid);
cleanup: cleanup:
if (pool) if (nwfilter)
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
return ret; return ret;
} }
@ -289,7 +289,7 @@ nwfilterClose(virConnectPtr conn) {
static int static int
nwfilterNumNWFilters(virConnectPtr conn) { nwfilterNumNWFilters(virConnectPtr conn) {
virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData; virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData;
return driver->pools.count; return driver->nwfilters.count;
} }
@ -301,15 +301,15 @@ nwfilterListNWFilters(virConnectPtr conn,
int got = 0, i; int got = 0, i;
nwfilterDriverLock(driver); nwfilterDriverLock(driver);
for (i = 0 ; i < driver->pools.count && got < nnames ; i++) { for (i = 0 ; i < driver->nwfilters.count && got < nnames ; i++) {
virNWFilterPoolObjLock(driver->pools.objs[i]); virNWFilterObjLock(driver->nwfilters.objs[i]);
if (!(names[got] = strdup(driver->pools.objs[i]->def->name))) { if (!(names[got] = strdup(driver->nwfilters.objs[i]->def->name))) {
virNWFilterPoolObjUnlock(driver->pools.objs[i]); virNWFilterObjUnlock(driver->nwfilters.objs[i]);
virReportOOMError(); virReportOOMError();
goto cleanup; goto cleanup;
} }
got++; got++;
virNWFilterPoolObjUnlock(driver->pools.objs[i]); virNWFilterObjUnlock(driver->nwfilters.objs[i]);
} }
nwfilterDriverUnlock(driver); nwfilterDriverUnlock(driver);
return got; return got;
@ -329,7 +329,7 @@ nwfilterDefine(virConnectPtr conn,
unsigned int flags ATTRIBUTE_UNUSED) { unsigned int flags ATTRIBUTE_UNUSED) {
virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData; virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData;
virNWFilterDefPtr def; virNWFilterDefPtr def;
virNWFilterPoolObjPtr pool = NULL; virNWFilterObjPtr nwfilter = NULL;
virNWFilterPtr ret = NULL; virNWFilterPtr ret = NULL;
nwfilterDriverLock(driver); nwfilterDriverLock(driver);
@ -338,22 +338,22 @@ nwfilterDefine(virConnectPtr conn,
if (!(def = virNWFilterDefParseString(conn, xml))) if (!(def = virNWFilterDefParseString(conn, xml)))
goto cleanup; goto cleanup;
if (!(pool = virNWFilterPoolObjAssignDef(conn, &driver->pools, def))) if (!(nwfilter = virNWFilterObjAssignDef(conn, &driver->nwfilters, def)))
goto cleanup; goto cleanup;
if (virNWFilterPoolObjSaveDef(driver, pool, def) < 0) { if (virNWFilterObjSaveDef(driver, nwfilter, def) < 0) {
virNWFilterPoolObjRemove(&driver->pools, pool); virNWFilterObjRemove(&driver->nwfilters, nwfilter);
def = NULL; def = NULL;
goto cleanup; goto cleanup;
} }
def = NULL; def = NULL;
ret = virGetNWFilter(conn, pool->def->name, pool->def->uuid); ret = virGetNWFilter(conn, nwfilter->def->name, nwfilter->def->uuid);
cleanup: cleanup:
virNWFilterDefFree(def); virNWFilterDefFree(def);
if (pool) if (nwfilter)
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
virNWFilterCallbackDriversUnlock(); virNWFilterCallbackDriversUnlock();
nwfilterDriverUnlock(driver); nwfilterDriverUnlock(driver);
@ -364,38 +364,38 @@ cleanup:
static int static int
nwfilterUndefine(virNWFilterPtr obj) { nwfilterUndefine(virNWFilterPtr obj) {
virNWFilterDriverStatePtr driver = obj->conn->nwfilterPrivateData; virNWFilterDriverStatePtr driver = obj->conn->nwfilterPrivateData;
virNWFilterPoolObjPtr pool; virNWFilterObjPtr nwfilter;
int ret = -1; int ret = -1;
nwfilterDriverLock(driver); nwfilterDriverLock(driver);
virNWFilterCallbackDriversLock(); virNWFilterCallbackDriversLock();
pool = virNWFilterPoolObjFindByUUID(&driver->pools, obj->uuid); nwfilter = virNWFilterObjFindByUUID(&driver->nwfilters, obj->uuid);
if (!pool) { if (!nwfilter) {
virNWFilterReportError(VIR_ERR_INVALID_NWFILTER, virNWFilterReportError(VIR_ERR_INVALID_NWFILTER,
"%s", _("no nwfilter pool with matching uuid")); "%s", _("no nwfilter with matching uuid"));
goto cleanup; goto cleanup;
} }
if (virNWFilterTestUnassignDef(obj->conn, pool)) { if (virNWFilterTestUnassignDef(obj->conn, nwfilter)) {
virNWFilterReportError(VIR_ERR_INVALID_NWFILTER, virNWFilterReportError(VIR_ERR_INVALID_NWFILTER,
"%s", "%s",
_("nwfilter is in use")); _("nwfilter is in use"));
goto cleanup; goto cleanup;
} }
if (virNWFilterPoolObjDeleteDef(pool) < 0) if (virNWFilterObjDeleteDef(nwfilter) < 0)
goto cleanup; goto cleanup;
VIR_FREE(pool->configFile); VIR_FREE(nwfilter->configFile);
virNWFilterPoolObjRemove(&driver->pools, pool); virNWFilterObjRemove(&driver->nwfilters, nwfilter);
pool = NULL; nwfilter = NULL;
ret = 0; ret = 0;
cleanup: cleanup:
if (pool) if (nwfilter)
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
virNWFilterCallbackDriversUnlock(); virNWFilterCallbackDriversUnlock();
nwfilterDriverUnlock(driver); nwfilterDriverUnlock(driver);
@ -407,26 +407,26 @@ static char *
nwfilterDumpXML(virNWFilterPtr obj, nwfilterDumpXML(virNWFilterPtr obj,
unsigned int flags) { unsigned int flags) {
virNWFilterDriverStatePtr driver = obj->conn->nwfilterPrivateData; virNWFilterDriverStatePtr driver = obj->conn->nwfilterPrivateData;
virNWFilterPoolObjPtr pool; virNWFilterObjPtr nwfilter;
char *ret = NULL; char *ret = NULL;
virCheckFlags(0, NULL); virCheckFlags(0, NULL);
nwfilterDriverLock(driver); nwfilterDriverLock(driver);
pool = virNWFilterPoolObjFindByUUID(&driver->pools, obj->uuid); nwfilter = virNWFilterObjFindByUUID(&driver->nwfilters, obj->uuid);
nwfilterDriverUnlock(driver); nwfilterDriverUnlock(driver);
if (!pool) { if (!nwfilter) {
virNWFilterReportError(VIR_ERR_INVALID_NWFILTER, virNWFilterReportError(VIR_ERR_INVALID_NWFILTER,
"%s", _("no nwfilter pool with matching uuid")); "%s", _("no nwfilter with matching uuid"));
goto cleanup; goto cleanup;
} }
ret = virNWFilterDefFormat(pool->def); ret = virNWFilterDefFormat(nwfilter->def);
cleanup: cleanup:
if (pool) if (nwfilter)
virNWFilterPoolObjUnlock(pool); virNWFilterObjUnlock(nwfilter);
return ret; return ret;
} }

30
src/nwfilter/nwfilter_gentech_driver.c
View File

@ -284,7 +284,7 @@ err_exit:
/** /**
* _virNWFilterPoolInstantiateRec: * _virNWFilterInstantiateRec:
* @conn: pointer to virConnect object * @conn: pointer to virConnect object
* @techdriver: The driver to use for instantiation * @techdriver: The driver to use for instantiation
* @filter: The filter to instantiate * @filter: The filter to instantiate
@ -319,7 +319,7 @@ _virNWFilterInstantiateRec(virConnectPtr conn,
enum instCase useNewFilter, bool *foundNewFilter, enum instCase useNewFilter, bool *foundNewFilter,
virNWFilterDriverStatePtr driver) virNWFilterDriverStatePtr driver)
{ {
virNWFilterPoolObjPtr obj; virNWFilterObjPtr obj;
int rc = 0; int rc = 0;
int i; int i;
virNWFilterRuleInstPtr inst; virNWFilterRuleInstPtr inst;
@ -351,8 +351,7 @@ _virNWFilterInstantiateRec(virConnectPtr conn,
} else if (inc) { } else if (inc) {
VIR_DEBUG("Instantiating filter %s", inc->filterref); VIR_DEBUG("Instantiating filter %s", inc->filterref);
obj = virNWFilterPoolObjFindByName(&driver->pools, obj = virNWFilterObjFindByName(&driver->nwfilters, inc->filterref);
inc->filterref);
if (obj) { if (obj) {
if (obj->wantRemoved) { if (obj->wantRemoved) {
@ -360,7 +359,7 @@ _virNWFilterInstantiateRec(virConnectPtr conn,
_("Filter '%s' is in use."), _("Filter '%s' is in use."),
inc->filterref); inc->filterref);
rc = 1; rc = 1;
virNWFilterPoolObjUnlock(obj); virNWFilterObjUnlock(obj);
break; break;
} }
@ -371,7 +370,7 @@ _virNWFilterInstantiateRec(virConnectPtr conn,
if (!tmpvars) { if (!tmpvars) {
virReportOOMError(); virReportOOMError();
rc = 1; rc = 1;
virNWFilterPoolObjUnlock(obj); virNWFilterObjUnlock(obj);
break; break;
} }
@ -401,7 +400,7 @@ _virNWFilterInstantiateRec(virConnectPtr conn,
virNWFilterHashTableFree(tmpvars); virNWFilterHashTableFree(tmpvars);
virNWFilterPoolObjUnlock(obj); virNWFilterObjUnlock(obj);
if (rc) if (rc)
break; break;
} else { } else {
@ -425,7 +424,7 @@ virNWFilterDetermineMissingVarsRec(virConnectPtr conn,
int useNewFilter, int useNewFilter,
virNWFilterDriverStatePtr driver) virNWFilterDriverStatePtr driver)
{ {
virNWFilterPoolObjPtr obj; virNWFilterObjPtr obj;
int rc = 0; int rc = 0;
int i, j; int i, j;
virNWFilterDefPtr next_filter; virNWFilterDefPtr next_filter;
@ -443,8 +442,7 @@ virNWFilterDetermineMissingVarsRec(virConnectPtr conn,
} }
} else if (inc) { } else if (inc) {
VIR_DEBUG("Following filter %s\n", inc->filterref); VIR_DEBUG("Following filter %s\n", inc->filterref);
obj = virNWFilterPoolObjFindByName(&driver->pools, obj = virNWFilterObjFindByName(&driver->nwfilters, inc->filterref);
inc->filterref);
if (obj) { if (obj) {
if (obj->wantRemoved) { if (obj->wantRemoved) {
@ -452,7 +450,7 @@ virNWFilterDetermineMissingVarsRec(virConnectPtr conn,
_("Filter '%s' is in use."), _("Filter '%s' is in use."),
inc->filterref); inc->filterref);
rc = 1; rc = 1;
virNWFilterPoolObjUnlock(obj); virNWFilterObjUnlock(obj);
break; break;
} }
@ -463,7 +461,7 @@ virNWFilterDetermineMissingVarsRec(virConnectPtr conn,
if (!tmpvars) { if (!tmpvars) {
virReportOOMError(); virReportOOMError();
rc = 1; rc = 1;
virNWFilterPoolObjUnlock(obj); virNWFilterObjUnlock(obj);
break; break;
} }
@ -488,7 +486,7 @@ virNWFilterDetermineMissingVarsRec(virConnectPtr conn,
virNWFilterHashTableFree(tmpvars); virNWFilterHashTableFree(tmpvars);
virNWFilterPoolObjUnlock(obj); virNWFilterObjUnlock(obj);
if (rc) if (rc)
break; break;
} else { } else {
@ -700,7 +698,7 @@ __virNWFilterInstantiateFilter(virConnectPtr conn,
int rc; int rc;
const char *drvname = EBIPTABLES_DRIVER_ID; const char *drvname = EBIPTABLES_DRIVER_ID;
virNWFilterTechDriverPtr techdriver; virNWFilterTechDriverPtr techdriver;
virNWFilterPoolObjPtr obj; virNWFilterObjPtr obj;
virNWFilterHashTablePtr vars, vars1; virNWFilterHashTablePtr vars, vars1;
virNWFilterDefPtr filter; virNWFilterDefPtr filter;
char vmmacaddr[VIR_MAC_STRING_BUFLEN] = {0}; char vmmacaddr[VIR_MAC_STRING_BUFLEN] = {0};
@ -720,7 +718,7 @@ __virNWFilterInstantiateFilter(virConnectPtr conn,
VIR_DEBUG("filter name: %s", filtername); VIR_DEBUG("filter name: %s", filtername);
obj = virNWFilterPoolObjFindByName(&driver->pools, filtername); obj = virNWFilterObjFindByName(&driver->nwfilters, filtername);
if (!obj) { if (!obj) {
virNWFilterReportError(VIR_ERR_NO_NWFILTER, virNWFilterReportError(VIR_ERR_NO_NWFILTER,
_("Could not find filter '%s'"), _("Could not find filter '%s'"),
@ -804,7 +802,7 @@ err_exit_vars1:
virNWFilterHashTableFree(vars1); virNWFilterHashTableFree(vars1);
err_exit: err_exit:
virNWFilterPoolObjUnlock(obj); virNWFilterObjUnlock(obj);
VIR_FREE(str_ipaddr); VIR_FREE(str_ipaddr);
VIR_FREE(str_macaddr); VIR_FREE(str_macaddr);