6:32 p.m.
v2: https://www.redhat.com/archives/libvir-list/2017-July/msg00673.html
(and a few pings along the way)
Don't think much survived from v2 - this is a fresh start anyway.
Perhaps old patch 2 the same, but beyond that a different approach
to remove recursive read/write locks and replace with using rwlock
read/write where the write's are in very tight confines.
I've run the changes through avocado with success. There were some
really strange deadlocks along the way - even causing libvirtd to
go defunct. There's a lot of strange ways to use/access the nwfilters.
John Ferlan (5):
nwfilter: Add update locking to Initialization
nwfilter: Remove unnecessary UUID comparison bypass
nwfilter: Convert _virNWFilterObj to use virObjectRWLockable
nwfilter: Convert _virNWFilterObjList to use virObjectRWLockable
nwfilter: Remove need for nwfilterDriverLock in some API's
src/conf/virnwfilterobj.c | 555 +++++++++++++++++++++++----------
src/conf/virnwfilterobj.h | 11 +-
src/libvirt_private.syms | 3 +-
src/nwfilter/nwfilter_driver.c | 77 +++--
src/nwfilter/nwfilter_gentech_driver.c | 11 +-
5 files changed, 433 insertions(+), 224 deletions(-)
--
2.13.6
6:32 p.m.
New subject: [libvirt] [PATCH v3 1/5] nwfilter: Add update locking to Initialization
If libvirtd is restarted, let's be sure to block any odd attempts to
update the nwfilters or allow any sort of callbacks from running guests
until all the objects are populated.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/nwfilter/nwfilter_driver.c | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/nwfilter/nwfilter_driver.c b/src/nwfilter/nwfilter_driver.c
index 2f9a51c405..06d5847ca7 100644
--- a/src/nwfilter/nwfilter_driver.c
+++ b/src/nwfilter/nwfilter_driver.c
@@ -244,18 +244,24 @@ nwfilterStateInitialize(bool privileged,
goto error;
}
+ virNWFilterWriteLockFilterUpdates();
+ virNWFilterCallbackDriversLock();
if (!(driver->nwfilters = virNWFilterObjListNew()))
goto error;
if (virNWFilterObjListLoadAllConfigs(driver->nwfilters, driver->configDir) <
0)
goto error;
+ virNWFilterCallbackDriversUnlock();
+ virNWFilterUnlockFilterUpdates();
nwfilterDriverUnlock();
return 0;
error:
VIR_FREE(base);
+ virNWFilterCallbackDriversUnlock();
+ virNWFilterUnlockFilterUpdates();
nwfilterDriverUnlock();
nwfilterStateCleanup();
--
2.13.6
6:32 p.m.
New subject: [libvirt] [PATCH v3 2/5] nwfilter: Remove unnecessary UUID comparison bypass
Commit id '46a811db07' added code to check if the filter by Name
already existed with a different UUID, to go along with the existing
found filter by UUID and compare the Names match thus making it
impossible to reach this find by Name condition without both the
Name and UUID already matching, so remove the need to "filter"
out the UUID for the virNWFilterDefEqual.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/conf/virnwfilterobj.c | 18 ++++--------------
1 file changed, 4 insertions(+), 14 deletions(-)
diff --git a/src/conf/virnwfilterobj.c b/src/conf/virnwfilterobj.c
index 408e575ca4..87d7e72703 100644
--- a/src/conf/virnwfilterobj.c
+++ b/src/conf/virnwfilterobj.c
@@ -287,18 +287,11 @@ virNWFilterObjTestUnassignDef(virNWFilterObjPtr obj)
static bool
virNWFilterDefEqual(const virNWFilterDef *def1,
- virNWFilterDefPtr def2,
- bool cmpUUIDs)
+ virNWFilterDefPtr def2)
{
bool ret = false;
- unsigned char rem_uuid[VIR_UUID_BUFLEN];
- char *xml1, *xml2 = NULL;
-
- if (!cmpUUIDs) {
- /* make sure the UUIDs are equal */
- memcpy(rem_uuid, def2->uuid, sizeof(rem_uuid));
- memcpy(def2->uuid, def1->uuid, sizeof(def2->uuid));
- }
+ char *xml1 = NULL;
+ char *xml2 = NULL;
if (!(xml1 = virNWFilterDefFormat(def1)) ||
!(xml2 = virNWFilterDefFormat(def2)))
@@ -307,9 +300,6 @@ virNWFilterDefEqual(const virNWFilterDef *def1,
ret = STREQ(xml1, xml2);
cleanup:
- if (!cmpUUIDs)
- memcpy(def2->uuid, rem_uuid, sizeof(rem_uuid));
-
VIR_FREE(xml1);
VIR_FREE(xml2);
@@ -360,7 +350,7 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
if ((obj = virNWFilterObjListFindByName(nwfilters, def->name))) {
objdef = obj->def;
- if (virNWFilterDefEqual(def, objdef, false)) {
+ if (virNWFilterDefEqual(def, objdef)) {
virNWFilterDefFree(objdef);
obj->def = def;
return obj;
--
2.13.6
6:32 p.m.
New subject: [libvirt] [PATCH v3 3/5] nwfilter: Convert _virNWFilterObj to use virObjectRWLockable
Unlike it's counterparts, the nwfilter object code needs to be able
to support recursive read locks while processing and checking new
filters against the existing environment. Thus instead of using a
virObjectLockable which uses pure mutexes, use the virObjectRWLockable
and primarily use RWLockRead when obtaining the object lock since
RWLockRead locks can be recursively obtained (up to a limit) as long
as there's a corresponding unlock.
Since all the object management is within the virnwfilterobj code, we
can limit the number of Write locks on the object to very small areas
of code to ensure we don't run into deadlock's with other threads and
domain code that will check/use the filters (it's a very delicate
balance). This limits the write locks to AssignDef and Remove processing.
This patch will introduce a new API virNWFilterObjEndAPI to unlock
and deref the object.
This patch introduces two helpers to promote/demote the read/write lock.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/conf/virnwfilterobj.c | 191 +++++++++++++++++++++++----------
src/conf/virnwfilterobj.h | 9 +-
src/libvirt_private.syms | 3 +-
src/nwfilter/nwfilter_driver.c | 15 +--
src/nwfilter/nwfilter_gentech_driver.c | 11 +-
5 files changed, 149 insertions(+), 80 deletions(-)
diff --git a/src/conf/virnwfilterobj.c b/src/conf/virnwfilterobj.c
index 87d7e72703..6b4758656f 100644
--- a/src/conf/virnwfilterobj.c
+++ b/src/conf/virnwfilterobj.c
@@ -34,7 +34,7 @@
VIR_LOG_INIT("conf.virnwfilterobj");
struct _virNWFilterObj {
- virMutex lock;
+ virObjectRWLockable parent;
bool wantRemoved;
@@ -47,27 +47,69 @@ struct _virNWFilterObjList {
virNWFilterObjPtr *objs;
};
+static virClassPtr virNWFilterObjClass;
+static void virNWFilterObjDispose(void *opaque);
+
+
+static int
+virNWFilterObjOnceInit(void)
+{
+ if (!(virNWFilterObjClass = virClassNew(virClassForObjectRWLockable(),
+ "virNWFilterObj",
+ sizeof(virNWFilterObj),
+ virNWFilterObjDispose)))
+ return -1;
+
+ return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(virNWFilterObj)
+
static virNWFilterObjPtr
virNWFilterObjNew(void)
{
virNWFilterObjPtr obj;
- if (VIR_ALLOC(obj) < 0)
+ if (virNWFilterObjInitialize() < 0)
return NULL;
- if (virMutexInitRecursive(&obj->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- "%s", _("cannot initialize mutex"));
- VIR_FREE(obj);
+ if (!(obj = virObjectRWLockableNew(virNWFilterObjClass)))
return NULL;
- }
- virNWFilterObjLock(obj);
+ virObjectRWLockWrite(obj);
return obj;
}
+static void
+virNWFilterObjPromoteToWrite(virNWFilterObjPtr obj)
+{
+ virObjectRWUnlock(obj);
+ virObjectRWLockWrite(obj);
+}
+
+
+static void
+virNWFilterObjDemoteFromWrite(virNWFilterObjPtr obj)
+{
+ virObjectRWUnlock(obj);
+ virObjectRWLockRead(obj);
+}
+
+
+void
+virNWFilterObjEndAPI(virNWFilterObjPtr *obj)
+{
+ if (!*obj)
+ return;
+
+ virObjectRWUnlock(*obj);
+ virObjectUnref(*obj);
+ *obj = NULL;
+}
+
+
virNWFilterDefPtr
virNWFilterObjGetDef(virNWFilterObjPtr obj)
{
@@ -90,17 +132,15 @@ virNWFilterObjWantRemoved(virNWFilterObjPtr obj)
static void
-virNWFilterObjFree(virNWFilterObjPtr obj)
+virNWFilterObjDispose(void *opaque)
{
+ virNWFilterObjPtr obj = opaque;
+
if (!obj)
return;
virNWFilterDefFree(obj->def);
virNWFilterDefFree(obj->newDef);
-
- virMutexDestroy(&obj->lock);
-
- VIR_FREE(obj);
}
@@ -109,7 +149,7 @@ virNWFilterObjListFree(virNWFilterObjListPtr nwfilters)
{
size_t i;
for (i = 0; i < nwfilters->count; i++)
- virNWFilterObjFree(nwfilters->objs[i]);
+ virObjectUnref(nwfilters->objs[i]);
VIR_FREE(nwfilters->objs);
VIR_FREE(nwfilters);
}
@@ -132,22 +172,32 @@ virNWFilterObjListRemove(virNWFilterObjListPtr nwfilters,
{
size_t i;
- virNWFilterObjUnlock(obj);
+ virObjectRWUnlock(obj);
for (i = 0; i < nwfilters->count; i++) {
- virNWFilterObjLock(nwfilters->objs[i]);
+ virObjectRWLockWrite(nwfilters->objs[i]);
if (nwfilters->objs[i] == obj) {
- virNWFilterObjUnlock(nwfilters->objs[i]);
- virNWFilterObjFree(nwfilters->objs[i]);
+ virObjectRWUnlock(nwfilters->objs[i]);
+ virObjectUnref(nwfilters->objs[i]);
VIR_DELETE_ELEMENT(nwfilters->objs, i, nwfilters->count);
break;
}
- virNWFilterObjUnlock(nwfilters->objs[i]);
+ virObjectRWUnlock(nwfilters->objs[i]);
}
}
+/**
+ * virNWFilterObjListFindByUUID
+ * @nwfilters: Pointer to filter list
+ * @uuid: UUID to use to lookup the object
+ *
+ * Search for the object by uuidstr in the hash table and return a read
+ * locked copy of the object.
+ *
+ * Returns: A reffed and read locked object or NULL on error
+ */
virNWFilterObjPtr
virNWFilterObjListFindByUUID(virNWFilterObjListPtr nwfilters,
const unsigned char *uuid)
@@ -158,17 +208,27 @@ virNWFilterObjListFindByUUID(virNWFilterObjListPtr nwfilters,
for (i = 0; i < nwfilters->count; i++) {
obj = nwfilters->objs[i];
- virNWFilterObjLock(obj);
+ virObjectRWLockRead(obj);
def = obj->def;
if (!memcmp(def->uuid, uuid, VIR_UUID_BUFLEN))
- return obj;
- virNWFilterObjUnlock(obj);
+ return virObjectRef(obj);
+ virObjectRWUnlock(obj);
}
return NULL;
}
+/**
+ * virNWFilterObjListFindByName
+ * @nwfilters: Pointer to filter list
+ * @name: filter name to use to lookup the object
+ *
+ * Search for the object by name in the hash table and return a read
+ * locked copy of the object.
+ *
+ * Returns: A reffed and read locked object or NULL on error
+ */
virNWFilterObjPtr
virNWFilterObjListFindByName(virNWFilterObjListPtr nwfilters,
const char *name)
@@ -179,11 +239,11 @@ virNWFilterObjListFindByName(virNWFilterObjListPtr nwfilters,
for (i = 0; i < nwfilters->count; i++) {
obj = nwfilters->objs[i];
- virNWFilterObjLock(obj);
+ virObjectRWLockRead(obj);
def = obj->def;
if (STREQ_NULLABLE(def->name, name))
- return obj;
- virNWFilterObjUnlock(obj);
+ return virObjectRef(obj);
+ virObjectRWUnlock(obj);
}
return NULL;
@@ -205,8 +265,7 @@ virNWFilterObjListFindInstantiateFilter(virNWFilterObjListPtr
nwfilters,
if (virNWFilterObjWantRemoved(obj)) {
virReportError(VIR_ERR_NO_NWFILTER,
_("Filter '%s' is in use."), filtername);
- virNWFilterObjUnlock(obj);
- return NULL;
+ virNWFilterObjEndAPI(&obj);
}
return obj;
@@ -240,7 +299,7 @@ _virNWFilterObjListDefLoopDetect(virNWFilterObjListPtr nwfilters,
if (obj) {
rc = _virNWFilterObjListDefLoopDetect(nwfilters, obj->def,
filtername);
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
if (rc < 0)
break;
}
@@ -269,17 +328,36 @@ virNWFilterObjListDefLoopDetect(virNWFilterObjListPtr nwfilters,
}
+/* virNWFilterObjTestUnassignDef
+ * @obj: A read locked nwfilter object
+ *
+ * Cause the rebuild to occur because we're about to undefine the nwfilter.
+ * The rebuild code is designed to check if the filter is currently in use
+ * by a domain and thus disallow the unassign.
+ *
+ * NB: Although we enter with the UPDATE lock from UNDEFINE, let's still
+ * promote to a WRITE lock before changing *this* object's wantRemoved
+ * value that will be used in the virNWFilterObjListFindInstantiateFilter
+ * processing to determine whether we can really remove this filter or not.
+ *
+ * Returns 0 if we can continue with the unassign, -1 if it's in use
+ */
int
virNWFilterObjTestUnassignDef(virNWFilterObjPtr obj)
{
int rc = 0;
+ virNWFilterObjPromoteToWrite(obj);
obj->wantRemoved = true;
+ virNWFilterObjDemoteFromWrite(obj);
+
/* trigger the update on VMs referencing the filter */
if (virNWFilterTriggerVMFilterRebuild() < 0)
rc = -1;
+ virNWFilterObjPromoteToWrite(obj);
obj->wantRemoved = false;
+ virNWFilterObjDemoteFromWrite(obj);
return rc;
}
@@ -322,10 +400,10 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
_("filter with same UUID but different name "
"('%s') already exists"),
objdef->name);
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
return NULL;
}
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
} else {
if ((obj = virNWFilterObjListFindByName(nwfilters, def->name))) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
@@ -335,7 +413,7 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
virReportError(VIR_ERR_OPERATION_FAILED,
_("filter '%s' already exists with uuid
%s"),
def->name, uuidstr);
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
return NULL;
}
}
@@ -347,7 +425,10 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
}
+ /* Get a READ lock and immediately promote to WRITE while we adjust
+ * data within. */
if ((obj = virNWFilterObjListFindByName(nwfilters, def->name))) {
+ virNWFilterObjPromoteToWrite(obj);
objdef = obj->def;
if (virNWFilterDefEqual(def, objdef)) {
@@ -357,13 +438,20 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
}
obj->newDef = def;
+
+ /* Demote while the trigger runs since it may need to grab a read
+ * lock on this object and promote before returning. */
+ virNWFilterObjDemoteFromWrite(obj);
+
/* trigger the update on VMs referencing the filter */
if (virNWFilterTriggerVMFilterRebuild() < 0) {
+ virNWFilterObjPromoteToWrite(obj);
obj->newDef = NULL;
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
return NULL;
}
+ virNWFilterObjPromoteToWrite(obj);
virNWFilterDefFree(objdef);
obj->def = def;
obj->newDef = NULL;
@@ -375,13 +463,12 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
if (VIR_APPEND_ELEMENT_COPY(nwfilters->objs,
nwfilters->count, obj) < 0) {
- virNWFilterObjUnlock(obj);
- virNWFilterObjFree(obj);
+ virNWFilterObjEndAPI(&obj);
return NULL;
}
obj->def = def;
- return obj;
+ return virObjectRef(obj);
}
@@ -395,10 +482,10 @@ virNWFilterObjListNumOfNWFilters(virNWFilterObjListPtr nwfilters,
for (i = 0; i < nwfilters->count; i++) {
virNWFilterObjPtr obj = nwfilters->objs[i];
- virNWFilterObjLock(obj);
+ virObjectRWLockRead(obj);
if (!filter || filter(conn, obj->def))
nfilters++;
- virNWFilterObjUnlock(obj);
+ virObjectRWUnlock(obj);
}
return nfilters;
@@ -418,16 +505,16 @@ virNWFilterObjListGetNames(virNWFilterObjListPtr nwfilters,
for (i = 0; i < nwfilters->count && nnames < maxnames; i++) {
virNWFilterObjPtr obj = nwfilters->objs[i];
- virNWFilterObjLock(obj);
+ virObjectRWLockRead(obj);
def = obj->def;
if (!filter || filter(conn, def)) {
if (VIR_STRDUP(names[nnames], def->name) < 0) {
- virNWFilterObjUnlock(obj);
+ virObjectRWUnlock(obj);
goto failure;
}
nnames++;
}
- virNWFilterObjUnlock(obj);
+ virObjectRWUnlock(obj);
}
return nnames;
@@ -464,16 +551,16 @@ virNWFilterObjListExport(virConnectPtr conn,
for (i = 0; i < nwfilters->count; i++) {
obj = nwfilters->objs[i];
- virNWFilterObjLock(obj);
+ virObjectRWLockRead(obj);
def = obj->def;
if (!filter || filter(conn, def)) {
if (!(nwfilter = virGetNWFilter(conn, def->name, def->uuid))) {
- virNWFilterObjUnlock(obj);
+ virObjectRWUnlock(obj);
goto cleanup;
}
tmp_filters[nfilters++] = nwfilter;
}
- virNWFilterObjUnlock(obj);
+ virObjectRWUnlock(obj);
}
*filters = tmp_filters;
@@ -551,24 +638,10 @@ virNWFilterObjListLoadAllConfigs(virNWFilterObjListPtr nwfilters,
continue;
obj = virNWFilterObjListLoadConfig(nwfilters, configDir, entry->d_name);
- if (obj)
- virNWFilterObjUnlock(obj);
+
+ virNWFilterObjEndAPI(&obj);
}
VIR_DIR_CLOSE(dir);
return ret;
}
-
-
-void
-virNWFilterObjLock(virNWFilterObjPtr obj)
-{
- virMutexLock(&obj->lock);
-}
-
-
-void
-virNWFilterObjUnlock(virNWFilterObjPtr obj)
-{
- virMutexUnlock(&obj->lock);
-}
diff --git a/src/conf/virnwfilterobj.h b/src/conf/virnwfilterobj.h
index 8e79518ed3..0281bc5f56 100644
--- a/src/conf/virnwfilterobj.h
+++ b/src/conf/virnwfilterobj.h
@@ -41,6 +41,9 @@ struct _virNWFilterDriverState {
bool watchingFirewallD;
};
+void
+virNWFilterObjEndAPI(virNWFilterObjPtr *obj);
+
virNWFilterDefPtr
virNWFilterObjGetDef(virNWFilterObjPtr obj);
@@ -105,10 +108,4 @@ int
virNWFilterObjListLoadAllConfigs(virNWFilterObjListPtr nwfilters,
const char *configDir);
-void
-virNWFilterObjLock(virNWFilterObjPtr obj);
-
-void
-virNWFilterObjUnlock(virNWFilterObjPtr obj);
-
#endif /* VIRNWFILTEROBJ_H */
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 7a12d6a146..d91fa92e4b 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -1004,6 +1004,7 @@ virNodeDeviceObjListRemove;
# conf/virnwfilterobj.h
+virNWFilterObjEndAPI;
virNWFilterObjGetDef;
virNWFilterObjGetNewDef;
virNWFilterObjListAssignDef;
@@ -1017,9 +1018,7 @@ virNWFilterObjListLoadAllConfigs;
virNWFilterObjListNew;
virNWFilterObjListNumOfNWFilters;
virNWFilterObjListRemove;
-virNWFilterObjLock;
virNWFilterObjTestUnassignDef;
-virNWFilterObjUnlock;
virNWFilterObjWantRemoved;
diff --git a/src/nwfilter/nwfilter_driver.c b/src/nwfilter/nwfilter_driver.c
index 06d5847ca7..a1d93f7af0 100644
--- a/src/nwfilter/nwfilter_driver.c
+++ b/src/nwfilter/nwfilter_driver.c
@@ -406,7 +406,7 @@ nwfilterLookupByUUID(virConnectPtr conn,
nwfilter = virGetNWFilter(conn, def->name, def->uuid);
cleanup:
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
return nwfilter;
}
@@ -436,7 +436,7 @@ nwfilterLookupByName(virConnectPtr conn,
nwfilter = virGetNWFilter(conn, def->name, def->uuid);
cleanup:
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
return nwfilter;
}
@@ -523,6 +523,8 @@ nwfilterDefineXML(virConnectPtr conn,
if (virNWFilterSaveConfig(driver->configDir, objdef) < 0) {
virNWFilterObjListRemove(driver->nwfilters, obj);
+ virObjectUnref(obj);
+ obj = NULL;
goto cleanup;
}
@@ -530,8 +532,7 @@ nwfilterDefineXML(virConnectPtr conn,
cleanup:
virNWFilterDefFree(def);
- if (obj)
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
virNWFilterCallbackDriversUnlock();
virNWFilterUnlockFilterUpdates();
@@ -569,12 +570,12 @@ nwfilterUndefine(virNWFilterPtr nwfilter)
goto cleanup;
virNWFilterObjListRemove(driver->nwfilters, obj);
+ virObjectUnref(obj);
obj = NULL;
ret = 0;
cleanup:
- if (obj)
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
virNWFilterCallbackDriversUnlock();
virNWFilterUnlockFilterUpdates();
@@ -607,7 +608,7 @@ nwfilterGetXMLDesc(virNWFilterPtr nwfilter,
ret = virNWFilterDefFormat(def);
cleanup:
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
return ret;
}
diff --git a/src/nwfilter/nwfilter_gentech_driver.c
b/src/nwfilter/nwfilter_gentech_driver.c
index 840d419bb4..48d0e1769f 100644
--- a/src/nwfilter/nwfilter_gentech_driver.c
+++ b/src/nwfilter/nwfilter_gentech_driver.c
@@ -316,7 +316,7 @@ virNWFilterInstReset(virNWFilterInstPtr inst)
size_t i;
for (i = 0; i < inst->nfilters; i++)
- virNWFilterObjUnlock(inst->filters[i]);
+ virNWFilterObjEndAPI(&inst->filters[i]);
VIR_FREE(inst->filters);
inst->nfilters = 0;
@@ -426,8 +426,7 @@ virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver,
if (ret < 0)
virNWFilterInstReset(inst);
virNWFilterHashTableFree(tmpvars);
- if (obj)
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
return ret;
}
@@ -541,7 +540,7 @@ virNWFilterDetermineMissingVarsRec(virNWFilterDefPtr filter,
/* create a temporary hashmap for depth-first tree traversal */
if (!(tmpvars = virNWFilterCreateVarsFrom(inc->params, vars))) {
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
return -1;
}
@@ -565,7 +564,7 @@ virNWFilterDetermineMissingVarsRec(virNWFilterDefPtr filter,
virNWFilterHashTableFree(tmpvars);
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
if (rc < 0)
return -1;
}
@@ -839,7 +838,7 @@ virNWFilterInstantiateFilterUpdate(virNWFilterDriverStatePtr driver,
virNWFilterHashTableFree(vars1);
err_exit:
- virNWFilterObjUnlock(obj);
+ virNWFilterObjEndAPI(&obj);
VIR_FREE(str_ipaddr);
VIR_FREE(str_macaddr);
--
2.13.6
6:32 p.m.
New subject: [libvirt] [PATCH v3 4/5] nwfilter: Convert _virNWFilterObjList to use virObjectRWLockable
Implement the self locking object list for nwfilter object lists
that uses two hash tables to store the nwfilter object by UUID or
by Name.
As part of this alter the uuid argument to virNWFilterObjLookupByUUID
to expect an already formatted uuidstr.
Alter the existing list traversal code to implement the hash table
find/lookup/search functionality.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/conf/virnwfilterobj.c | 402 ++++++++++++++++++++++++++++-------------
src/conf/virnwfilterobj.h | 2 +-
src/nwfilter/nwfilter_driver.c | 5 +-
3 files changed, 282 insertions(+), 127 deletions(-)
diff --git a/src/conf/virnwfilterobj.c b/src/conf/virnwfilterobj.c
index 6b4758656f..a4e6a03d29 100644
--- a/src/conf/virnwfilterobj.c
+++ b/src/conf/virnwfilterobj.c
@@ -43,12 +43,21 @@ struct _virNWFilterObj {
};
struct _virNWFilterObjList {
- size_t count;
- virNWFilterObjPtr *objs;
+ virObjectRWLockable parent;
+
+ /* uuid string -> virNWFilterObj mapping
+ * for O(1), lockless lookup-by-uuid */
+ virHashTable *objs;
+
+ /* name -> virNWFilterObj mapping for O(1),
+ * lockless lookup-by-name */
+ virHashTable *objsName;
};
static virClassPtr virNWFilterObjClass;
+static virClassPtr virNWFilterObjListClass;
static void virNWFilterObjDispose(void *opaque);
+static void virNWFilterObjListDispose(void *opaque);
static int
@@ -60,6 +69,12 @@ virNWFilterObjOnceInit(void)
virNWFilterObjDispose)))
return -1;
+ if (!(virNWFilterObjListClass = virClassNew(virClassForObjectRWLockable(),
+ "virNWFilterObjList",
+ sizeof(virNWFilterObjList),
+ virNWFilterObjListDispose)))
+ return -1;
+
return 0;
}
@@ -144,14 +159,20 @@ virNWFilterObjDispose(void *opaque)
}
+static void
+virNWFilterObjListDispose(void *opaque)
+{
+ virNWFilterObjListPtr nwfilters = opaque;
+
+ virHashFree(nwfilters->objs);
+ virHashFree(nwfilters->objsName);
+}
+
+
void
virNWFilterObjListFree(virNWFilterObjListPtr nwfilters)
{
- size_t i;
- for (i = 0; i < nwfilters->count; i++)
- virObjectUnref(nwfilters->objs[i]);
- VIR_FREE(nwfilters->objs);
- VIR_FREE(nwfilters);
+ virObjectUnref(nwfilters);
}
@@ -160,8 +181,23 @@ virNWFilterObjListNew(void)
{
virNWFilterObjListPtr nwfilters;
- if (VIR_ALLOC(nwfilters) < 0)
+ if (virNWFilterObjInitialize() < 0)
+ return NULL;
+
+ if (!(nwfilters = virObjectRWLockableNew(virNWFilterObjListClass)))
+ return NULL;
+
+ if (!(nwfilters->objs = virHashCreate(10, virObjectFreeHashData))) {
+ virObjectUnref(nwfilters);
+ return NULL;
+ }
+
+ if (!(nwfilters->objsName = virHashCreate(10, virObjectFreeHashData))) {
+ virHashFree(nwfilters->objs);
+ virObjectUnref(nwfilters);
return NULL;
+ }
+
return nwfilters;
}
@@ -170,83 +206,105 @@ void
virNWFilterObjListRemove(virNWFilterObjListPtr nwfilters,
virNWFilterObjPtr obj)
{
- size_t i;
-
- virObjectRWUnlock(obj);
+ char uuidstr[VIR_UUID_STRING_BUFLEN];
+ virNWFilterDefPtr def;
- for (i = 0; i < nwfilters->count; i++) {
- virObjectRWLockWrite(nwfilters->objs[i]);
- if (nwfilters->objs[i] == obj) {
- virObjectRWUnlock(nwfilters->objs[i]);
- virObjectUnref(nwfilters->objs[i]);
+ if (!obj)
+ return;
+ def = obj->def;
- VIR_DELETE_ELEMENT(nwfilters->objs, i, nwfilters->count);
- break;
- }
- virObjectRWUnlock(nwfilters->objs[i]);
- }
+ virUUIDFormat(def->uuid, uuidstr);
+ virObjectRef(obj);
+ virObjectRWUnlock(obj);
+ virObjectRWLockWrite(nwfilters);
+ virObjectRWLockWrite(obj);
+ virHashRemoveEntry(nwfilters->objs, uuidstr);
+ virHashRemoveEntry(nwfilters->objsName, def->name);
+ virObjectRWUnlock(obj);
+ virObjectUnref(obj);
+ virObjectRWUnlock(nwfilters);
}
/**
- * virNWFilterObjListFindByUUID
+ * virNWFilterObjListFindByUUID[Locked]
* @nwfilters: Pointer to filter list
- * @uuid: UUID to use to lookup the object
+ * @uuidstr: UUID to use to lookup the object
+ *
+ * The static [Locked] version would only be used when the Object List is
+ * already locked, such as is the case during virNWFilterObjListAssignDef.
+ * The caller is thus responsible for locking the object.
*
* Search for the object by uuidstr in the hash table and return a read
* locked copy of the object.
*
+ * Returns: A reffed object or NULL on error
+ */
+static virNWFilterObjPtr
+virNWFilterObjListFindByUUIDLocked(virNWFilterObjListPtr nwfilters,
+ const char *uuidstr)
+{
+ return virObjectRef(virHashLookup(nwfilters->objs, uuidstr));
+}
+
+
+/*
* Returns: A reffed and read locked object or NULL on error
*/
virNWFilterObjPtr
virNWFilterObjListFindByUUID(virNWFilterObjListPtr nwfilters,
- const unsigned char *uuid)
+ const char *uuidstr)
{
- size_t i;
virNWFilterObjPtr obj;
- virNWFilterDefPtr def;
- for (i = 0; i < nwfilters->count; i++) {
- obj = nwfilters->objs[i];
+ virObjectRWLockRead(nwfilters);
+ obj = virNWFilterObjListFindByUUIDLocked(nwfilters, uuidstr);
+ virObjectRWUnlock(nwfilters);
+ if (obj)
virObjectRWLockRead(obj);
- def = obj->def;
- if (!memcmp(def->uuid, uuid, VIR_UUID_BUFLEN))
- return virObjectRef(obj);
- virObjectRWUnlock(obj);
- }
- return NULL;
+ return obj;
}
/**
- * virNWFilterObjListFindByName
+ * virNWFilterObjListFindByName[Locked]
* @nwfilters: Pointer to filter list
* @name: filter name to use to lookup the object
*
+ * The static [Locked] version would only be used when the Object List is
+ * already locked, such as is the case during virNWFilterObjListAssignDef.
+ * The caller is thus responsible for locking the object.
+ *
* Search for the object by name in the hash table and return a read
* locked copy of the object.
*
+ * Returns: A reffed object or NULL on error
+ */
+static virNWFilterObjPtr
+virNWFilterObjListFindByNameLocked(virNWFilterObjListPtr nwfilters,
+ const char *name)
+{
+ return virObjectRef(virHashLookup(nwfilters->objsName, name));
+}
+
+
+/*
* Returns: A reffed and read locked object or NULL on error
*/
virNWFilterObjPtr
virNWFilterObjListFindByName(virNWFilterObjListPtr nwfilters,
const char *name)
{
- size_t i;
virNWFilterObjPtr obj;
- virNWFilterDefPtr def;
- for (i = 0; i < nwfilters->count; i++) {
- obj = nwfilters->objs[i];
+ virObjectRWLockRead(nwfilters);
+ obj = virNWFilterObjListFindByNameLocked(nwfilters, name);
+ virObjectRWUnlock(nwfilters);
+ if (obj)
virObjectRWLockRead(obj);
- def = obj->def;
- if (STREQ_NULLABLE(def->name, name))
- return virObjectRef(obj);
- virObjectRWUnlock(obj);
- }
- return NULL;
+ return obj;
}
@@ -391,8 +449,11 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
{
virNWFilterObjPtr obj;
virNWFilterDefPtr objdef;
+ char uuidstr[VIR_UUID_STRING_BUFLEN];
- if ((obj = virNWFilterObjListFindByUUID(nwfilters, def->uuid))) {
+ virUUIDFormat(def->uuid, uuidstr);
+
+ if ((obj = virNWFilterObjListFindByUUID(nwfilters, uuidstr))) {
objdef = obj->def;
if (STRNEQ(def->name, objdef->name)) {
@@ -406,10 +467,7 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
virNWFilterObjEndAPI(&obj);
} else {
if ((obj = virNWFilterObjListFindByName(nwfilters, def->name))) {
- char uuidstr[VIR_UUID_STRING_BUFLEN];
-
objdef = obj->def;
- virUUIDFormat(objdef->uuid, uuidstr);
virReportError(VIR_ERR_OPERATION_FAILED,
_("filter '%s' already exists with uuid
%s"),
def->name, uuidstr);
@@ -424,11 +482,13 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
return NULL;
}
-
- /* Get a READ lock and immediately promote to WRITE while we adjust
- * data within. */
- if ((obj = virNWFilterObjListFindByName(nwfilters, def->name))) {
- virNWFilterObjPromoteToWrite(obj);
+ /* We're about to make some changes to objects on the list - so get
+ * the list READ lock in order to Find the object and WRITE lock it
+ * while we adjust data within. */
+ virObjectRWLockRead(nwfilters);
+ if ((obj = virNWFilterObjListFindByNameLocked(nwfilters, def->name))) {
+ virObjectRWUnlock(nwfilters);
+ virObjectRWLockWrite(obj);
objdef = obj->def;
if (virNWFilterDefEqual(def, objdef)) {
@@ -458,37 +518,112 @@ virNWFilterObjListAssignDef(virNWFilterObjListPtr nwfilters,
return obj;
}
+ /* Promote the nwfilters to add a new object */
+ virObjectRWUnlock(nwfilters);
+ virObjectRWLockWrite(nwfilters);
if (!(obj = virNWFilterObjNew()))
- return NULL;
+ goto cleanup;
- if (VIR_APPEND_ELEMENT_COPY(nwfilters->objs,
- nwfilters->count, obj) < 0) {
- virNWFilterObjEndAPI(&obj);
- return NULL;
+ if (virHashAddEntry(nwfilters->objs, uuidstr, obj) < 0)
+ goto error;
+ virObjectRef(obj);
+
+ if (virHashAddEntry(nwfilters->objsName, def->name, obj) < 0) {
+ virHashRemoveEntry(nwfilters->objs, uuidstr);
+ goto error;
}
+ virObjectRef(obj);
+
obj->def = def;
- return virObjectRef(obj);
+ cleanup:
+ virObjectRWUnlock(nwfilters);
+ return obj;
+
+ error:
+ virObjectRWUnlock(obj);
+ virObjectUnref(obj);
+ virObjectRWUnlock(nwfilters);
+ return NULL;
}
+struct virNWFilterCountData {
+ virConnectPtr conn;
+ virNWFilterObjListFilter filter;
+ int nelems;
+};
+
+static int
+virNWFilterObjListNumOfNWFiltersCallback(void *payload,
+ const void *name ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ virNWFilterObjPtr obj = payload;
+ struct virNWFilterCountData *data = opaque;
+
+ virObjectRWLockRead(obj);
+ if (!data->filter || data->filter(data->conn, obj->def))
+ data->nelems++;
+ virObjectRWUnlock(obj);
+ return 0;
+}
+
int
virNWFilterObjListNumOfNWFilters(virNWFilterObjListPtr nwfilters,
virConnectPtr conn,
virNWFilterObjListFilter filter)
{
- size_t i;
- int nfilters = 0;
+ struct virNWFilterCountData data = { .conn = conn,
+ .filter = filter, .nelems = 0 };
- for (i = 0; i < nwfilters->count; i++) {
- virNWFilterObjPtr obj = nwfilters->objs[i];
- virObjectRWLockRead(obj);
- if (!filter || filter(conn, obj->def))
- nfilters++;
- virObjectRWUnlock(obj);
+ virObjectRWLockRead(nwfilters);
+ virHashForEach(nwfilters->objs, virNWFilterObjListNumOfNWFiltersCallback,
+ &data);
+ virObjectRWUnlock(nwfilters);
+
+ return data.nelems;
+}
+
+
+struct virNWFilterListData {
+ virConnectPtr conn;
+ virNWFilterObjListFilter filter;
+ int nelems;
+ char **elems;
+ int maxelems;
+ bool error;
+};
+
+static int
+virNWFilterObjListGetNamesCallback(void *payload,
+ const void *name ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ virNWFilterObjPtr obj = payload;
+ virNWFilterDefPtr def;
+ struct virNWFilterListData *data = opaque;
+
+ if (data->error)
+ return 0;
+
+ if (data->maxelems >= 0 && data->nelems == data->maxelems)
+ return 0;
+
+ virObjectRWLockRead(obj);
+ def = obj->def;
+
+ if (!data->filter || data->filter(data->conn, def)) {
+ if (VIR_STRDUP(data->elems[data->nelems], def->name) < 0) {
+ data->error = true;
+ goto cleanup;
+ }
+ data->nelems++;
}
- return nfilters;
+ cleanup:
+ virObjectRWUnlock(obj);
+ return 0;
}
@@ -499,82 +634,103 @@ virNWFilterObjListGetNames(virNWFilterObjListPtr nwfilters,
char **const names,
int maxnames)
{
- int nnames = 0;
- size_t i;
- virNWFilterDefPtr def;
+ struct virNWFilterListData data = { .conn = conn, .filter = filter,
+ .nelems = 0, .elems = names, .maxelems = maxnames, .error = false };
- for (i = 0; i < nwfilters->count && nnames < maxnames; i++) {
- virNWFilterObjPtr obj = nwfilters->objs[i];
- virObjectRWLockRead(obj);
- def = obj->def;
- if (!filter || filter(conn, def)) {
- if (VIR_STRDUP(names[nnames], def->name) < 0) {
- virObjectRWUnlock(obj);
- goto failure;
- }
- nnames++;
- }
- virObjectRWUnlock(obj);
- }
+ virObjectRWLockRead(nwfilters);
+ virHashForEach(nwfilters->objs, virNWFilterObjListGetNamesCallback, &data);
+ virObjectRWUnlock(nwfilters);
- return nnames;
+ if (data.error)
+ goto error;
- failure:
- while (--nnames >= 0)
- VIR_FREE(names[nnames]);
+ return data.nelems;
+ error:
+ while (--data.nelems >= 0)
+ VIR_FREE(data.elems[data.nelems]);
return -1;
}
+struct virNWFilterExportData {
+ virConnectPtr conn;
+ virNWFilterObjListFilter filter;
+ virNWFilterPtr *filters;
+ int nfilters;
+ bool error;
+};
+
+static int
+virNWFilterObjListExportCallback(void *payload,
+ const void *name ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ virNWFilterObjPtr obj = payload;
+ virNWFilterDefPtr def;
+
+ struct virNWFilterExportData *data = opaque;
+ virNWFilterPtr nwfilter;
+
+ if (data->error)
+ return 0;
+
+ virObjectRWLockRead(obj);
+ def = obj->def;
+
+ if (data->filter && !data->filter(data->conn, def))
+ goto cleanup;
+
+ if (!data->filters) {
+ data->nfilters++;
+ goto cleanup;
+ }
+
+ if (!(nwfilter = virGetNWFilter(data->conn, def->name, def->uuid))) {
+ data->error = true;
+ goto cleanup;
+ }
+ data->filters[data->nfilters++] = nwfilter;
+
+ cleanup:
+ virObjectRWUnlock(obj);
+ return 0;
+}
+
+
int
virNWFilterObjListExport(virConnectPtr conn,
virNWFilterObjListPtr nwfilters,
virNWFilterPtr **filters,
virNWFilterObjListFilter filter)
{
- virNWFilterPtr *tmp_filters = NULL;
- int nfilters = 0;
- virNWFilterPtr nwfilter = NULL;
- virNWFilterObjPtr obj = NULL;
- virNWFilterDefPtr def;
- size_t i;
- int ret = -1;
+ struct virNWFilterExportData data = { .conn = conn, .filter = filter,
+ .filters = NULL, .nfilters = 0, .error = false };
- if (!filters) {
- ret = nwfilters->count;
- goto cleanup;
+ virObjectRWLockRead(nwfilters);
+ if (filters &&
+ VIR_ALLOC_N(data.filters, virHashSize(nwfilters->objs) + 1) < 0) {
+ virObjectRWUnlock(nwfilters);
+ return -1;
}
- if (VIR_ALLOC_N(tmp_filters, nwfilters->count + 1) < 0)
- goto cleanup;
+ virHashForEach(nwfilters->objs, virNWFilterObjListExportCallback, &data);
+ virObjectRWUnlock(nwfilters);
- for (i = 0; i < nwfilters->count; i++) {
- obj = nwfilters->objs[i];
- virObjectRWLockRead(obj);
- def = obj->def;
- if (!filter || filter(conn, def)) {
- if (!(nwfilter = virGetNWFilter(conn, def->name, def->uuid))) {
- virObjectRWUnlock(obj);
- goto cleanup;
- }
- tmp_filters[nfilters++] = nwfilter;
- }
- virObjectRWUnlock(obj);
+ if (data.error)
+ goto cleanup;
+
+ if (data.filters) {
+ /* trim the array to the final size */
+ ignore_value(VIR_REALLOC_N(data.filters, data.nfilters + 1));
+ *filters = data.filters;
}
- *filters = tmp_filters;
- tmp_filters = NULL;
- ret = nfilters;
+ return data.nfilters;
cleanup:
- if (tmp_filters) {
- for (i = 0; i < nfilters; i ++)
- virObjectUnref(tmp_filters[i]);
- }
- VIR_FREE(tmp_filters);
-
- return ret;
+ virObjectListFree(data.filters);
+ return -1;
}
diff --git a/src/conf/virnwfilterobj.h b/src/conf/virnwfilterobj.h
index 0281bc5f56..cabb42a71e 100644
--- a/src/conf/virnwfilterobj.h
+++ b/src/conf/virnwfilterobj.h
@@ -65,7 +65,7 @@ virNWFilterObjListRemove(virNWFilterObjListPtr nwfilters,
virNWFilterObjPtr
virNWFilterObjListFindByUUID(virNWFilterObjListPtr nwfilters,
- const unsigned char *uuid);
+ const char *uuidstr);
virNWFilterObjPtr
virNWFilterObjListFindByName(virNWFilterObjListPtr nwfilters,
diff --git a/src/nwfilter/nwfilter_driver.c b/src/nwfilter/nwfilter_driver.c
index a1d93f7af0..fee132cfd1 100644
--- a/src/nwfilter/nwfilter_driver.c
+++ b/src/nwfilter/nwfilter_driver.c
@@ -375,11 +375,10 @@ nwfilterObjFromNWFilter(const unsigned char *uuid)
virNWFilterObjPtr obj;
char uuidstr[VIR_UUID_STRING_BUFLEN];
- if (!(obj = virNWFilterObjListFindByUUID(driver->nwfilters, uuid))) {
- virUUIDFormat(uuid, uuidstr);
+ virUUIDFormat(uuid, uuidstr);
+ if (!(obj = virNWFilterObjListFindByUUID(driver->nwfilters, uuidstr)))
virReportError(VIR_ERR_NO_NWFILTER,
_("no nwfilter with matching uuid '%s'"),
uuidstr);
- }
return obj;
}
--
2.13.6
6:32 p.m.
New subject: [libvirt] [PATCH v3 5/5] nwfilter: Remove need for nwfilterDriverLock in some API's
Now that nwfilters object list is self locking, it's no longer
necessary to hold the driver level lock for certain API's.
However, for the DefineXML, Undefine, and Reload processing keeping
that lock ensures for serialization required in order to process
the filter Instantiation properly.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/nwfilter/nwfilter_driver.c | 51 +++++++++++++++++-------------------------
1 file changed, 20 insertions(+), 31 deletions(-)
diff --git a/src/nwfilter/nwfilter_driver.c b/src/nwfilter/nwfilter_driver.c
index fee132cfd1..906035d492 100644
--- a/src/nwfilter/nwfilter_driver.c
+++ b/src/nwfilter/nwfilter_driver.c
@@ -301,6 +301,10 @@ nwfilterStateReload(void)
/* shut down all threads -- they will be restarted if necessary */
virNWFilterLearnThreadsTerminate(true);
+ /* Serialization of virNWFilterObjListLoadAllConfigs is extremely
+ * important as it relates to virNWFilterObjListFindInstantiateFilter
+ * processing via virNWFilterTriggerVMFilterRebuild that occurs during
+ * virNWFilterObjListAssignDef */
nwfilterDriverLock();
virNWFilterWriteLockFilterUpdates();
virNWFilterCallbackDriversLock();
@@ -391,11 +395,7 @@ nwfilterLookupByUUID(virConnectPtr conn,
virNWFilterDefPtr def;
virNWFilterPtr nwfilter = NULL;
- nwfilterDriverLock();
- obj = nwfilterObjFromNWFilter(uuid);
- nwfilterDriverUnlock();
-
- if (!obj)
+ if (!(obj = nwfilterObjFromNWFilter(uuid)))
return NULL;
def = virNWFilterObjGetDef(obj);
@@ -418,11 +418,7 @@ nwfilterLookupByName(virConnectPtr conn,
virNWFilterDefPtr def;
virNWFilterPtr nwfilter = NULL;
- nwfilterDriverLock();
- obj = virNWFilterObjListFindByName(driver->nwfilters, name);
- nwfilterDriverUnlock();
-
- if (!obj) {
+ if (!(obj = virNWFilterObjListFindByName(driver->nwfilters, name))) {
virReportError(VIR_ERR_NO_NWFILTER,
_("no nwfilter with matching name '%s'"),
name);
return NULL;
@@ -456,17 +452,12 @@ nwfilterConnectListNWFilters(virConnectPtr conn,
char **const names,
int maxnames)
{
- int nnames;
-
if (virConnectListNWFiltersEnsureACL(conn) < 0)
return -1;
- nwfilterDriverLock();
- nnames = virNWFilterObjListGetNames(driver->nwfilters, conn,
- virConnectListNWFiltersCheckACL,
- names, maxnames);
- nwfilterDriverUnlock();
- return nnames;
+ return virNWFilterObjListGetNames(driver->nwfilters, conn,
+ virConnectListNWFiltersCheckACL,
+ names, maxnames);
}
@@ -475,19 +466,13 @@ nwfilterConnectListAllNWFilters(virConnectPtr conn,
virNWFilterPtr **nwfilters,
unsigned int flags)
{
- int ret;
-
virCheckFlags(0, -1);
if (virConnectListAllNWFiltersEnsureACL(conn) < 0)
return -1;
- nwfilterDriverLock();
- ret = virNWFilterObjListExport(conn, driver->nwfilters, nwfilters,
- virConnectListAllNWFiltersCheckACL);
- nwfilterDriverUnlock();
-
- return ret;
+ return virNWFilterObjListExport(conn, driver->nwfilters, nwfilters,
+ virConnectListAllNWFiltersCheckACL);
}
static virNWFilterPtr
@@ -505,6 +490,10 @@ nwfilterDefineXML(virConnectPtr conn,
return NULL;
}
+ /* Serialization of *one* DefineXML consumer is extremely important
+ * as it relates to virNWFilterObjListFindInstantiateFilter processing
+ * via virNWFilterTriggerVMFilterRebuild that occurs during
+ * virNWFilterObjListAssignDef */
nwfilterDriverLock();
virNWFilterWriteLockFilterUpdates();
virNWFilterCallbackDriversLock();
@@ -547,6 +536,10 @@ nwfilterUndefine(virNWFilterPtr nwfilter)
virNWFilterDefPtr def;
int ret = -1;
+ /* Serialization of *one* Undefine consumer is extremely important
+ * as it relates to virNWFilterObjListFindInstantiateFilter processing
+ * via virNWFilterTriggerVMFilterRebuild that occurs during
+ * virNWFilterObjTestUnassignDef */
nwfilterDriverLock();
virNWFilterWriteLockFilterUpdates();
virNWFilterCallbackDriversLock();
@@ -593,11 +586,7 @@ nwfilterGetXMLDesc(virNWFilterPtr nwfilter,
virCheckFlags(0, NULL);
- nwfilterDriverLock();
- obj = nwfilterObjFromNWFilter(nwfilter->uuid);
- nwfilterDriverUnlock();
-
- if (!obj)
+ if (!(obj = nwfilterObjFromNWFilter(nwfilter->uuid)))
return NULL;
def = virNWFilterObjGetDef(obj);
--
2.13.6
3:07 p.m.
Ping?
Any brave souls out there?
Tks,
John
On 10/05/2017 07:32 PM, John Ferlan wrote:
v2:
https://www.redhat.com/archives/libvir-list/2017-July/msg00673.html
(and a few pings along the way)
Don't think much survived from v2 - this is a fresh start anyway.
Perhaps old patch 2 the same, but beyond that a different approach
to remove recursive read/write locks and replace with using rwlock
read/write where the write's are in very tight confines.
I've run the changes through avocado with success. There were some
really strange deadlocks along the way - even causing libvirtd to
go defunct. There's a lot of strange ways to use/access the nwfilters.
John Ferlan (5):
nwfilter: Add update locking to Initialization
nwfilter: Remove unnecessary UUID comparison bypass
nwfilter: Convert _virNWFilterObj to use virObjectRWLockable
nwfilter: Convert _virNWFilterObjList to use virObjectRWLockable
nwfilter: Remove need for nwfilterDriverLock in some API's
src/conf/virnwfilterobj.c | 555 +++++++++++++++++++++++----------
src/conf/virnwfilterobj.h | 11 +-
src/libvirt_private.syms | 3 +-
src/nwfilter/nwfilter_driver.c | 77 +++--
src/nwfilter/nwfilter_gentech_driver.c | 11 +-
5 files changed, 433 insertions(+), 224 deletions(-)
2570
days inactive
2604
days old
6 comments
1 participants
participants (1)
-
John Ferlan