7:10 a.m.
Posted as RFC mainly for the benefit of patches 5-8. The first 4 patches
could be considered non-RFC material, but posting half of each just didn't
seem reasonable.
Before I get "too far" into this virobject adjustment and inheritance model,
I wanted to be sure the chosen names were suitable and that I read the
comments from responses to patch 2 of my previous RFC correctly:
https://www.redhat.com/archives/libvir-list/2017-February/msg00521.html
at least with respect to how the inheritence should work. Secondarily,
like a "real object" - should the API's that act upon the object be
part of the object? Of course since virObjectLockable didn't do that
I figured I wouldn't do so either (eg, rather than virObjectLock and
virObjectUnlock, it could have been obj->Lock() and obj->Unlock()).
The next 'logical' step after patch 8 would be to create an object
that uses virObjectPoolableHashElement that would be able to effectly
look like my previous virPoolObj objects insomuch as it'd have the
'def' pointer, all the various flags, etc. That object then would be
consumed by each driver rather than virObjectLockable parent. That's
where the real fun begins. Once that's there - moving the add, remove,
search/find, etc. API's into virobject with callbacks to do vir*obj.c
specific things.
So far in my local branches I have a working model of the secret
driver using everything here. It's been a painful process to extract
out patches and move things along "more slowly", but it's allowed
at least one optimization that I didn't consider originally - using
primary/secondary names rather than assuming UUID/Name.
John Ferlan (8):
util: Formatting cleanups to virobject API
util: Introduce virObjectGetLockableObj
util: Generate a common internal only error print
util: Add magic_marker for all virObjects
util: Introduce virObjectPoolableHashTable
util: Add the hash tables to virObjectPoolableHashTable
util: Introduce virObjectPoolableHashElement
util: Add virObjectPoolableHashElementGet*Key
src/libvirt_private.syms | 8 +
src/util/virobject.c | 375 ++++++++++++++++++++++++++++++++++++++++++-----
src/util/virobject.h | 132 ++++++++++++++---
3 files changed, 461 insertions(+), 54 deletions(-)
--
2.9.3
7:10 a.m.
New subject: [libvirt] [RFC PATCH 1/8] util: Formatting cleanups to virobject API
Alter to use more recent formatting guidelines
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/util/virobject.c | 64 ++++++++++++++++++++++++++++++++++------------------
src/util/virobject.h | 59 ++++++++++++++++++++++++++++++++----------------
2 files changed, 82 insertions(+), 41 deletions(-)
diff --git a/src/util/virobject.c b/src/util/virobject.c
index 51876b9..792685b 100644
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -52,7 +52,8 @@ static virClassPtr virObjectLockableClass;
static void virObjectLockableDispose(void *anyobj);
-static int virObjectOnceInit(void)
+static int
+virObjectOnceInit(void)
{
if (!(virObjectClass = virClassNew(NULL,
"virObject",
@@ -77,7 +78,8 @@ VIR_ONCE_GLOBAL_INIT(virObject);
*
* Returns the class instance for the base virObject type
*/
-virClassPtr virClassForObject(void)
+virClassPtr
+virClassForObject(void)
{
if (virObjectInitialize() < 0)
return NULL;
@@ -91,7 +93,8 @@ virClassPtr virClassForObject(void)
*
* Returns the class instance for the virObjectLockable type
*/
-virClassPtr virClassForObjectLockable(void)
+virClassPtr
+virClassForObjectLockable(void)
{
if (virObjectInitialize() < 0)
return NULL;
@@ -116,10 +119,11 @@ virClassPtr virClassForObjectLockable(void)
*
* Returns a new class instance
*/
-virClassPtr virClassNew(virClassPtr parent,
- const char *name,
- size_t objectSize,
- virObjectDisposeCallback dispose)
+virClassPtr
+virClassNew(virClassPtr parent,
+ const char *name,
+ size_t objectSize,
+ virObjectDisposeCallback dispose)
{
virClassPtr klass;
@@ -162,8 +166,9 @@ virClassPtr virClassNew(virClassPtr parent,
*
* Return true if @klass is derived from @parent, false otherwise
*/
-bool virClassIsDerivedFrom(virClassPtr klass,
- virClassPtr parent)
+bool
+virClassIsDerivedFrom(virClassPtr klass,
+ virClassPtr parent)
{
while (klass) {
if (klass->magic == parent->magic)
@@ -186,7 +191,8 @@ bool virClassIsDerivedFrom(virClassPtr klass,
*
* Returns the new object
*/
-void *virObjectNew(virClassPtr klass)
+void *
+virObjectNew(virClassPtr klass)
{
virObjectPtr obj = NULL;
@@ -205,7 +211,8 @@ void *virObjectNew(virClassPtr klass)
}
-void *virObjectLockableNew(virClassPtr klass)
+void *
+virObjectLockableNew(virClassPtr klass)
{
virObjectLockablePtr obj;
@@ -230,13 +237,15 @@ void *virObjectLockableNew(virClassPtr klass)
}
-static void virObjectLockableDispose(void *anyobj)
+static void
+virObjectLockableDispose(void *anyobj)
{
virObjectLockablePtr obj = anyobj;
virMutexDestroy(&obj->lock);
}
+
/**
* virObjectUnref:
* @anyobj: any instance of virObjectPtr
@@ -248,7 +257,8 @@ static void virObjectLockableDispose(void *anyobj)
* Returns true if the remaining reference count is
* non-zero, false if the object was disposed of
*/
-bool virObjectUnref(void *anyobj)
+bool
+virObjectUnref(void *anyobj)
{
virObjectPtr obj = anyobj;
@@ -286,7 +296,8 @@ bool virObjectUnref(void *anyobj)
*
* Returns @anyobj
*/
-void *virObjectRef(void *anyobj)
+void *
+virObjectRef(void *anyobj)
{
virObjectPtr obj = anyobj;
@@ -310,7 +321,8 @@ void *virObjectRef(void *anyobj)
* The object must be unlocked before releasing this
* reference.
*/
-void virObjectLock(void *anyobj)
+void
+virObjectLock(void *anyobj)
{
virObjectLockablePtr obj = anyobj;
@@ -331,7 +343,8 @@ void virObjectLock(void *anyobj)
* Release a lock on @anyobj. The lock must have been
* acquired by virObjectLock.
*/
-void virObjectUnlock(void *anyobj)
+void
+virObjectUnlock(void *anyobj)
{
virObjectLockablePtr obj = anyobj;
@@ -355,8 +368,9 @@ void virObjectUnlock(void *anyobj)
*
* Returns true if @anyobj is an instance of @klass
*/
-bool virObjectIsClass(void *anyobj,
- virClassPtr klass)
+bool
+virObjectIsClass(void *anyobj,
+ virClassPtr klass)
{
virObjectPtr obj = anyobj;
if (!obj)
@@ -372,7 +386,8 @@ bool virObjectIsClass(void *anyobj,
*
* Returns the name of @klass
*/
-const char *virClassName(virClassPtr klass)
+const char *
+virClassName(virClassPtr klass)
{
return klass->name;
}
@@ -401,7 +416,9 @@ void virObjectFreeCallback(void *opaque)
* but with the signature matching the virHashDataFree
* typedef.
*/
-void virObjectFreeHashData(void *opaque, const void *name ATTRIBUTE_UNUSED)
+void
+virObjectFreeHashData(void *opaque,
+ const void *name ATTRIBUTE_UNUSED)
{
virObjectUnref(opaque);
}
@@ -413,7 +430,8 @@ void virObjectFreeHashData(void *opaque, const void *name
ATTRIBUTE_UNUSED)
*
* Unrefs all members of @list and frees the list itself.
*/
-void virObjectListFree(void *list)
+void
+virObjectListFree(void *list)
{
void **next;
@@ -434,7 +452,9 @@ void virObjectListFree(void *list)
*
* Unrefs all members of @list and frees the list itself.
*/
-void virObjectListFreeCount(void *list, size_t count)
+void
+virObjectListFreeCount(void *list,
+ size_t count)
{
size_t i;
diff --git a/src/util/virobject.h b/src/util/virobject.h
index c3ecc1e..f4c292b 100644
--- a/src/util/virobject.h
+++ b/src/util/virobject.h
@@ -66,40 +66,61 @@ virClassPtr virClassForObjectLockable(void);
# ifndef VIR_PARENT_REQUIRED
# define VIR_PARENT_REQUIRED ATTRIBUTE_NONNULL(1)
# endif
-virClassPtr virClassNew(virClassPtr parent,
- const char *name,
- size_t objectSize,
- virObjectDisposeCallback dispose)
+virClassPtr
+virClassNew(virClassPtr parent,
+ const char *name,
+ size_t objectSize,
+ virObjectDisposeCallback dispose)
VIR_PARENT_REQUIRED ATTRIBUTE_NONNULL(2);
-const char *virClassName(virClassPtr klass)
+const char *
+virClassName(virClassPtr klass)
ATTRIBUTE_NONNULL(1);
-bool virClassIsDerivedFrom(virClassPtr klass,
- virClassPtr parent)
+bool
+virClassIsDerivedFrom(virClassPtr klass,
+ virClassPtr parent)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void *virObjectNew(virClassPtr klass)
+void *
+virObjectNew(virClassPtr klass)
ATTRIBUTE_NONNULL(1);
-bool virObjectUnref(void *obj);
-void *virObjectRef(void *obj);
-bool virObjectIsClass(void *obj,
- virClassPtr klass)
+bool
+virObjectUnref(void *obj);
+
+void *
+virObjectRef(void *obj);
+
+bool
+virObjectIsClass(void *obj,
+ virClassPtr klass)
ATTRIBUTE_NONNULL(2);
-void virObjectFreeCallback(void *opaque);
-void virObjectFreeHashData(void *opaque, const void *name);
+void
+virObjectFreeCallback(void *opaque);
+
+void
+virObjectFreeHashData(void *opaque,
+ const void *name);
-void *virObjectLockableNew(virClassPtr klass)
+void *
+virObjectLockableNew(virClassPtr klass)
ATTRIBUTE_NONNULL(1);
-void virObjectLock(void *lockableobj)
+void
+virObjectLock(void *lockableobj)
ATTRIBUTE_NONNULL(1);
-void virObjectUnlock(void *lockableobj)
+
+void
+virObjectUnlock(void *lockableobj)
ATTRIBUTE_NONNULL(1);
-void virObjectListFree(void *list);
-void virObjectListFreeCount(void *list, size_t count);
+void
+virObjectListFree(void *list);
+
+void
+virObjectListFreeCount(void *list,
+ size_t count);
#endif /* __VIR_OBJECT_H */
--
2.9.3
7:10 a.m.
New subject: [libvirt] [RFC PATCH 2/8] util: Introduce virObjectGetLockableObj
Split out the object fetch in virObject{Lock|Unlock} into a helper
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/util/virobject.c | 31 +++++++++++++++++++++----------
1 file changed, 21 insertions(+), 10 deletions(-)
diff --git a/src/util/virobject.c b/src/util/virobject.c
index 792685b..5d5b6a3 100644
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -309,6 +309,23 @@ virObjectRef(void *anyobj)
}
+static virObjectLockablePtr
+virObjectGetLockableObj(void *anyobj)
+{
+ virObjectPtr obj;
+
+ if (virObjectIsClass(anyobj, virObjectLockableClass))
+ return anyobj;
+
+ obj = anyobj;
+ VIR_WARN("Object %p (%s) is not a virObjectLockable instance",
+ anyobj, obj ? obj->klass->name : "(unknown)");
+
+ return NULL;
+
+}
+
+
/**
* virObjectLock:
* @anyobj: any instance of virObjectLockablePtr
@@ -324,13 +341,10 @@ virObjectRef(void *anyobj)
void
virObjectLock(void *anyobj)
{
- virObjectLockablePtr obj = anyobj;
+ virObjectLockablePtr obj = virObjectGetLockableObj(anyobj);
- if (!virObjectIsClass(obj, virObjectLockableClass)) {
- VIR_WARN("Object %p (%s) is not a virObjectLockable instance",
- obj, obj ? obj->parent.klass->name : "(unknown)");
+ if (!obj)
return;
- }
virMutexLock(&obj->lock);
}
@@ -346,13 +360,10 @@ virObjectLock(void *anyobj)
void
virObjectUnlock(void *anyobj)
{
- virObjectLockablePtr obj = anyobj;
+ virObjectLockablePtr obj = virObjectGetLockableObj(anyobj);
- if (!virObjectIsClass(obj, virObjectLockableClass)) {
- VIR_WARN("Object %p (%s) is not a virObjectLockable instance",
- obj, obj ? obj->parent.klass->name : "(unknown)");
+ if (!obj)
return;
- }
virMutexUnlock(&obj->lock);
}
--
2.9.3
7:10 a.m.
New subject: [libvirt] [RFC PATCH 3/8] util: Generate a common internal only error print
If virObjectIsClass fails "internally" to virobject.c, create a macro to
generate the VIR_WARN describing what the problem is. Also improve the
checks and message a bit to indicate which was the failure - whether the
obj was NULL or just not the right class
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/util/virobject.c | 16 +++++++++++-----
1 file changed, 11 insertions(+), 5 deletions(-)
diff --git a/src/util/virobject.c b/src/util/virobject.c
index 5d5b6a3..9fe4e71 100644
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -47,6 +47,16 @@ struct _virClass {
virObjectDisposeCallback dispose;
};
+#define VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, objclass) \
+ do { \
+ virObjectPtr obj = anyobj; \
+ if (!obj) \
+ VIR_WARN("Object %p is not a virObject class instance", anyobj);\
+ else \
+ VIR_WARN("Object %p (%s) is not a %s instance", \
+ anyobj, obj->klass->name, #objclass); \
+ } while (0)
+
static virClassPtr virObjectClass;
static virClassPtr virObjectLockableClass;
@@ -312,14 +322,10 @@ virObjectRef(void *anyobj)
static virObjectLockablePtr
virObjectGetLockableObj(void *anyobj)
{
- virObjectPtr obj;
-
if (virObjectIsClass(anyobj, virObjectLockableClass))
return anyobj;
- obj = anyobj;
- VIR_WARN("Object %p (%s) is not a virObjectLockable instance",
- anyobj, obj ? obj->klass->name : "(unknown)");
+ VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, virObjectLockableClass);
return NULL;
--
2.9.3
7:10 a.m.
New subject: [libvirt] [RFC PATCH 4/8] util: Add magic_marker for all virObjects
The virObject logic "assumes" that whatever is passed to its API's
would be some sort of virObjectPtr; however, if it is not then some
really bad things can happen.
So far there's been only virObject{Ref|Unref}, virObject{Lock|Unlock},
and virObjectIsClass and the virObject and virObjectLockable class
consumers have been well behaved and code well tested. Soon there will
be more consumers and one such consumer tripped over this during testing
by passing a virHashTablePtr to virObjectIsClass which ends up calling
virClassIsDerivedFrom using "obj->klass", which wasn't really a klass
object causing one of those bad things to happen.
To avoid the future possibility that a non virObject class memory was
passed to some virObject* API, let's add a "magic_marker" to the base
virObject class that contains a value "0xFEEDBEEF", then any place in
the code which would accept or process the base opaque virObjectPtr,
compare the magic_marker against 0xFEEDBEEF to make sure this is an
object allocated by this code.
It is still left up to the caller to handle the failed API calls just
as it would be if it passed a NULL opaque pointer anyobj.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/util/virobject.c | 12 ++++++++----
src/util/virobject.h | 1 +
2 files changed, 9 insertions(+), 4 deletions(-)
diff --git a/src/util/virobject.c b/src/util/virobject.c
index 9fe4e71..aea8a6d 100644
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -47,10 +47,12 @@ struct _virClass {
virObjectDisposeCallback dispose;
};
+#define VIR_OBJECT_NOTVALID(obj) (!obj || obj->magic_marker != 0xFEEDBEEF)
+
#define VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, objclass) \
do { \
virObjectPtr obj = anyobj; \
- if (!obj) \
+ if (VIR_OBJECT_NOTVALID(obj)) \
VIR_WARN("Object %p is not a virObject class instance", anyobj);\
else \
VIR_WARN("Object %p (%s) is not a %s instance", \
@@ -212,6 +214,7 @@ virObjectNew(virClassPtr klass)
return NULL;
obj->u.s.magic = klass->magic;
+ obj->magic_marker = 0xFEEDBEEF;
obj->klass = klass;
virAtomicIntSet(&obj->u.s.refs, 1);
@@ -272,7 +275,7 @@ virObjectUnref(void *anyobj)
{
virObjectPtr obj = anyobj;
- if (!obj)
+ if (VIR_OBJECT_NOTVALID(obj))
return false;
bool lastRef = virAtomicIntDecAndTest(&obj->u.s.refs);
@@ -289,6 +292,7 @@ virObjectUnref(void *anyobj)
/* Clear & poison object */
memset(obj, 0, obj->klass->objectSize);
obj->u.s.magic = 0xDEADBEEF;
+ obj->magic_marker = 0xDEADBEEF;
obj->klass = (void*)0xDEADBEEF;
VIR_FREE(obj);
}
@@ -311,7 +315,7 @@ virObjectRef(void *anyobj)
{
virObjectPtr obj = anyobj;
- if (!obj)
+ if (VIR_OBJECT_NOTVALID(obj))
return NULL;
virAtomicIntInc(&obj->u.s.refs);
PROBE(OBJECT_REF, "obj=%p", obj);
@@ -390,7 +394,7 @@ virObjectIsClass(void *anyobj,
virClassPtr klass)
{
virObjectPtr obj = anyobj;
- if (!obj)
+ if (VIR_OBJECT_NOTVALID(obj))
return false;
return virClassIsDerivedFrom(obj->klass, klass);
diff --git a/src/util/virobject.h b/src/util/virobject.h
index f4c292b..89f8050 100644
--- a/src/util/virobject.h
+++ b/src/util/virobject.h
@@ -51,6 +51,7 @@ struct _virObject {
int refs;
} s;
} u;
+ unsigned int magic_marker;
virClassPtr klass;
};
--
2.9.3
7:10 a.m.
New subject: [libvirt] [RFC PATCH 5/8] util: Introduce virObjectPoolableHashTable
Add the initial infrastructure to define a new object which will be
a child of the virObjectLockable class that can be used to create an
object that has two hash tables for object consumers to be able to
utilize to store elements in one or two hash tables depending on the
need to have more than one lookup mechanism for the same object
TODO: Remove VIR_DEBUG's or add separately
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/libvirt_private.syms | 2 ++
src/util/virobject.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++-
src/util/virobject.h | 29 +++++++++++++++++++
3 files changed, 102 insertions(+), 1 deletion(-)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 92083e5..6861155 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -2223,6 +2223,7 @@ virNumaSetupMemoryPolicy;
# util/virobject.h
virClassForObject;
virClassForObjectLockable;
+virClassForObjectPoolableHashTable;
virClassIsDerivedFrom;
virClassName;
virClassNew;
@@ -2234,6 +2235,7 @@ virObjectListFreeCount;
virObjectLock;
virObjectLockableNew;
virObjectNew;
+virObjectPoolableHashTableNew;
virObjectRef;
virObjectUnlock;
virObjectUnref;
diff --git a/src/util/virobject.c b/src/util/virobject.c
index aea8a6d..d284dde 100644
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -61,8 +61,11 @@ struct _virClass {
static virClassPtr virObjectClass;
static virClassPtr virObjectLockableClass;
+static virClassPtr virObjectPoolableHashTableClass;
static void virObjectLockableDispose(void *anyobj);
+static void virObjectPoolableHashTableDispose(void *anyobj);
+
static int
virObjectOnceInit(void)
@@ -79,6 +82,13 @@ virObjectOnceInit(void)
virObjectLockableDispose)))
return -1;
+ if (!(virObjectPoolableHashTableClass =
+ virClassNew(virObjectLockableClass,
+ "virObjectPoolableHashTable",
+ sizeof(virObjectPoolableHashTable),
+ virObjectPoolableHashTableDispose)))
+ return -1;
+
return 0;
}
@@ -96,6 +106,7 @@ virClassForObject(void)
if (virObjectInitialize() < 0)
return NULL;
+ VIR_DEBUG("virObjectClass=%p", virObjectClass);
return virObjectClass;
}
@@ -111,11 +122,29 @@ virClassForObjectLockable(void)
if (virObjectInitialize() < 0)
return NULL;
+ VIR_DEBUG("virObjectLockableClass=%p", virObjectLockableClass);
return virObjectLockableClass;
}
/**
+ * virClassForObjectPoolableHashTable:
+ *
+ * Returns the class instance for the virObjectPoolableHashTable type
+ */
+virClassPtr
+virClassForObjectPoolableHashTable(void)
+{
+ if (virObjectInitialize() < 0)
+ return NULL;
+
+ VIR_DEBUG("virObjectPoolableHashTableClass=%p",
+ virObjectPoolableHashTableClass);
+ return virObjectPoolableHashTableClass;
+}
+
+
+/**
* virClassNew:
* @parent: the parent class
* @name: the class name
@@ -139,6 +168,9 @@ virClassNew(virClassPtr parent,
{
virClassPtr klass;
+ VIR_DEBUG("parent=%p, name=%s, objectSize=%zu, dispose=%p",
+ parent, name, objectSize, dispose);
+
if (parent == NULL &&
STRNEQ(name, "virObject")) {
virReportInvalidNonNullArg(parent);
@@ -246,6 +278,7 @@ virObjectLockableNew(virClassPtr klass)
return NULL;
}
+ VIR_DEBUG("lockable new obj=%p", obj);
return obj;
}
@@ -255,10 +288,46 @@ virObjectLockableDispose(void *anyobj)
{
virObjectLockablePtr obj = anyobj;
+ VIR_DEBUG("lockable dispose obj=%p", obj);
virMutexDestroy(&obj->lock);
}
+void *
+virObjectPoolableHashTableNew(virClassPtr klass,
+ virObjectPoolableHashTableObjType objtype)
+{
+ virObjectPoolableHashTablePtr obj;
+
+ if (!virClassIsDerivedFrom(klass, virClassForObjectPoolableHashTable())) {
+ virReportInvalidArg(klass,
+ _("Class %s must derive from "
+ "virObjectPoolableHashTable"),
+ virClassName(klass));
+ return NULL;
+ }
+
+ if (!(obj = virObjectLockableNew(klass)))
+ return NULL;
+
+ obj->objtype = objtype;
+
+ VIR_DEBUG("poolable new obj=%p, type=%d",
+ obj, objtype);
+
+ return obj;
+
+}
+
+static void
+virObjectPoolableHashTableDispose(void *anyobj)
+{
+ virObjectPoolableHashTablePtr obj = anyobj;
+
+ VIR_DEBUG("poolable dispose obj=%p", obj);
+}
+
+
/**
* virObjectUnref:
* @anyobj: any instance of virObjectPtr
@@ -326,7 +395,8 @@ virObjectRef(void *anyobj)
static virObjectLockablePtr
virObjectGetLockableObj(void *anyobj)
{
- if (virObjectIsClass(anyobj, virObjectLockableClass))
+ if (virObjectIsClass(anyobj, virObjectLockableClass) ||
+ virObjectIsClass(anyobj, virObjectPoolableHashTableClass))
return anyobj;
VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, virObjectLockableClass);
diff --git a/src/util/virobject.h b/src/util/virobject.h
index 89f8050..30ce6a1 100644
--- a/src/util/virobject.h
+++ b/src/util/virobject.h
@@ -23,6 +23,7 @@
# define __VIR_OBJECT_H__
# include "internal.h"
+# include "virhash.h"
# include "virthread.h"
typedef struct _virClass virClass;
@@ -34,6 +35,9 @@ typedef virObject *virObjectPtr;
typedef struct _virObjectLockable virObjectLockable;
typedef virObjectLockable *virObjectLockablePtr;
+typedef struct _virObjectPoolableHashTable virObjectPoolableHashTable;
+typedef virObjectPoolableHashTable *virObjectPoolableHashTablePtr;
+
typedef void (*virObjectDisposeCallback)(void *obj);
/* Most code should not play with the contents of this struct; however,
@@ -60,9 +64,29 @@ struct _virObjectLockable {
virMutex lock;
};
+typedef enum {
+ VIR_OBJECTPOOLABLE_NODEDEVICE,
+ VIR_OBJECTPOOLABLE_INTERFACE,
+ VIR_OBJECTPOOLABLE_NWFILTER,
+ VIR_OBJECTPOOLABLE_VOLUME,
+ VIR_OBJECTPOOLABLE_BLOCK_STORAGE,
+ VIR_OBJECTPOOLABLE_SECRET,
+ VIR_OBJECTPOOLABLE_NETWORK,
+ VIR_OBJECTPOOLABLE_SNAPSHOT,
+ VIR_OBJECTPOOLABLE_DOMAIN,
+
+ VIR_OBJECTPOOLABLE_LAST
+} virObjectPoolableHashTableObjType;
+
+struct _virObjectPoolableHashTable {
+ virObjectLockable parent;
+ virObjectPoolableHashTableObjType objtype;
+};
+
virClassPtr virClassForObject(void);
virClassPtr virClassForObjectLockable(void);
+virClassPtr virClassForObjectPoolableHashTable(void);
# ifndef VIR_PARENT_REQUIRED
# define VIR_PARENT_REQUIRED ATTRIBUTE_NONNULL(1)
@@ -109,6 +133,11 @@ void *
virObjectLockableNew(virClassPtr klass)
ATTRIBUTE_NONNULL(1);
+void *
+virObjectPoolableHashTableNew(virClassPtr klass,
+ virObjectPoolableHashTableObjType objtype)
+ ATTRIBUTE_NONNULL(1);
+
void
virObjectLock(void *lockableobj)
ATTRIBUTE_NONNULL(1);
--
2.9.3
7:10 a.m.
New subject: [libvirt] [RFC PATCH 6/8] util: Add the hash tables to virObjectPoolableHashTable
Add a pair of hash tables to the object - a primary and a secondary one.
If the consumer requested only a primary, then only it will be created.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/libvirt_private.syms | 2 ++
src/util/virobject.c | 78 +++++++++++++++++++++++++++++++++++++++++++++---
src/util/virobject.h | 22 +++++++++++++-
3 files changed, 97 insertions(+), 5 deletions(-)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 6861155..9b3345a 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -2235,6 +2235,8 @@ virObjectListFreeCount;
virObjectLock;
virObjectLockableNew;
virObjectNew;
+virObjectPoolableHashTableGetPrimary;
+virObjectPoolableHashTableGetSecondary;
virObjectPoolableHashTableNew;
virObjectRef;
virObjectUnlock;
diff --git a/src/util/virobject.c b/src/util/virobject.c
index d284dde..625bf90 100644
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -295,7 +295,9 @@ virObjectLockableDispose(void *anyobj)
void *
virObjectPoolableHashTableNew(virClassPtr klass,
- virObjectPoolableHashTableObjType objtype)
+ virObjectPoolableHashTableObjType objtype,
+ int tableElemsStart,
+ bool primaryOnly)
{
virObjectPoolableHashTablePtr obj;
@@ -311,20 +313,39 @@ virObjectPoolableHashTableNew(virClassPtr klass,
return NULL;
obj->objtype = objtype;
+ obj->tableElemsStart = tableElemsStart;
- VIR_DEBUG("poolable new obj=%p, type=%d",
- obj, objtype);
+ if (!(obj->objsPrimary = virHashCreate(tableElemsStart,
+ virObjectFreeHashData)))
+ goto error;
+
+ if (!primaryOnly &&
+ !(obj->objsSecondary = virHashCreate(tableElemsStart,
+ virObjectFreeHashData)))
+ goto error;
+
+
+ VIR_DEBUG("obj=%p, type=%d, elems=%d objsPrimary=%p objsSecondary=%p",
+ obj, objtype, tableElemsStart,
+ obj->objsPrimary, obj->objsSecondary);
return obj;
+ error:
+ virObjectUnref(obj);
+ return NULL;
}
+
static void
virObjectPoolableHashTableDispose(void *anyobj)
{
virObjectPoolableHashTablePtr obj = anyobj;
VIR_DEBUG("poolable dispose obj=%p", obj);
+
+ virHashFree(obj->objsPrimary);
+ virHashFree(obj->objsSecondary);
}
@@ -402,7 +423,6 @@ virObjectGetLockableObj(void *anyobj)
VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, virObjectLockableClass);
return NULL;
-
}
@@ -557,3 +577,53 @@ virObjectListFreeCount(void *list,
VIR_FREE(list);
}
+
+
+static virObjectPoolableHashTablePtr
+virObjectGetPoolableHashTableObj(void *anyobj)
+{
+ if (virObjectIsClass(anyobj, virObjectPoolableHashTableClass))
+ return anyobj;
+
+ VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, virObjectPoolableHashTableClass);
+
+ return NULL;
+}
+
+
+/**
+ * virObjectPoolableHashTableGetPrimary
+ * @anyobj: Pointer to a PoolableHashTable object
+ *
+ * Returns: Pointer to the Primary Hash Table or NULL on failure
+ */
+virHashTablePtr
+virObjectPoolableHashTableGetPrimary(void *anyobj)
+{
+ virObjectPoolableHashTablePtr obj =
+ virObjectGetPoolableHashTableObj(anyobj);
+
+ if (!obj)
+ return NULL;
+
+ return obj->objsPrimary;
+}
+
+
+/**
+ * virObjectPoolableHashTableGetSecondary
+ * @anyobj: Pointer to a PoolableHashTable object
+ *
+ * Returns: Pointer to the Secondary Hash Table or NULL on failure
+ */
+virHashTablePtr
+virObjectPoolableHashTableGetSecondary(void *anyobj)
+{
+ virObjectPoolableHashTablePtr obj =
+ virObjectGetPoolableHashTableObj(anyobj);
+
+ if (!obj)
+ return NULL;
+
+ return obj->objsSecondary;
+}
diff --git a/src/util/virobject.h b/src/util/virobject.h
index 30ce6a1..ac21190 100644
--- a/src/util/virobject.h
+++ b/src/util/virobject.h
@@ -81,6 +81,18 @@ typedef enum {
struct _virObjectPoolableHashTable {
virObjectLockable parent;
virObjectPoolableHashTableObjType objtype;
+
+ int tableElemsStart;
+
+ /* primary key -> object mapping for O(1),
+ * lockless lookup-by-primary */
+ virHashTable *objsPrimary;
+
+ /* uuid string -> virPoolObj mapping
+ * for O(1), lockless lookup-by-uuid */
+ /* secondary key -> object mapping for O(1),
+ * lockless lookup-by-secondary */
+ virHashTable *objsSecondary;
};
@@ -135,7 +147,9 @@ virObjectLockableNew(virClassPtr klass)
void *
virObjectPoolableHashTableNew(virClassPtr klass,
- virObjectPoolableHashTableObjType objtype)
+ virObjectPoolableHashTableObjType objtype,
+ int tableElemsStart,
+ bool primaryOnly)
ATTRIBUTE_NONNULL(1);
void
@@ -153,4 +167,10 @@ void
virObjectListFreeCount(void *list,
size_t count);
+virHashTablePtr
+virObjectPoolableHashTableGetPrimary(void *anyobj);
+
+virHashTablePtr
+virObjectPoolableHashTableGetSecondary(void *anyobj);
+
#endif /* __VIR_OBJECT_H */
--
2.9.3
7:10 a.m.
New subject: [libvirt] [RFC PATCH 7/8] util: Introduce virObjectPoolableHashElement
Add a new virObjectLockable child which will be used to describe
elements that would be inserted into the virObjectPoolableHashTable.
Each virObjectPoolableHashElement will have a primaryKey and a secondaryKey
which can be used to insert the same object into both of the hash tables
that are part of the virObjectPoolableHashTable. This allows for lookup
of the object by more than one means.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/libvirt_private.syms | 2 ++
src/util/virobject.c | 77 ++++++++++++++++++++++++++++++++++++++++++++++--
src/util/virobject.h | 17 +++++++++++
3 files changed, 94 insertions(+), 2 deletions(-)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 9b3345a..74d4bf8 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -2223,6 +2223,7 @@ virNumaSetupMemoryPolicy;
# util/virobject.h
virClassForObject;
virClassForObjectLockable;
+virClassForObjectPoolableHashElement;
virClassForObjectPoolableHashTable;
virClassIsDerivedFrom;
virClassName;
@@ -2235,6 +2236,7 @@ virObjectListFreeCount;
virObjectLock;
virObjectLockableNew;
virObjectNew;
+virObjectPoolableHashElementNew;
virObjectPoolableHashTableGetPrimary;
virObjectPoolableHashTableGetSecondary;
virObjectPoolableHashTableNew;
diff --git a/src/util/virobject.c b/src/util/virobject.c
index 625bf90..c9e631c 100644
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -62,10 +62,11 @@ struct _virClass {
static virClassPtr virObjectClass;
static virClassPtr virObjectLockableClass;
static virClassPtr virObjectPoolableHashTableClass;
+static virClassPtr virObjectPoolableHashElementClass;
static void virObjectLockableDispose(void *anyobj);
static void virObjectPoolableHashTableDispose(void *anyobj);
-
+static void virObjectPoolableHashElementDispose(void *anyobj);
static int
virObjectOnceInit(void)
@@ -89,6 +90,13 @@ virObjectOnceInit(void)
virObjectPoolableHashTableDispose)))
return -1;
+ if (!(virObjectPoolableHashElementClass =
+ virClassNew(virObjectLockableClass,
+ "virObjectPoolableHashElement",
+ sizeof(virObjectPoolableHashElement),
+ virObjectPoolableHashElementDispose)))
+ return -1;
+
return 0;
}
@@ -145,6 +153,23 @@ virClassForObjectPoolableHashTable(void)
/**
+ * virClassForObjectPoolableHashElement:
+ *
+ * Returns the class instance for the virObjectPoolableHashElement type
+ */
+virClassPtr
+virClassForObjectPoolableHashElement(void)
+{
+ if (virObjectInitialize() < 0)
+ return NULL;
+
+ VIR_DEBUG("virObjectPoolableHashElementClass=%p",
+ virObjectPoolableHashElementClass);
+ return virObjectPoolableHashElementClass;
+}
+
+
+/**
* virClassNew:
* @parent: the parent class
* @name: the class name
@@ -349,6 +374,53 @@ virObjectPoolableHashTableDispose(void *anyobj)
}
+void *
+virObjectPoolableHashElementNew(virClassPtr klass,
+ const char *primaryKey,
+ const char *secondaryKey)
+{
+ virObjectPoolableHashElementPtr obj;
+
+ if (!virClassIsDerivedFrom(klass, virClassForObjectPoolableHashElement())) {
+ virReportInvalidArg(klass,
+ _("Class %s must derive from "
+ "virObjectPoolableHashElement"),
+ virClassName(klass));
+ return NULL;
+ }
+
+ if (!(obj = virObjectLockableNew(klass)))
+ return NULL;
+
+ if (VIR_STRDUP(obj->primaryKey, primaryKey) < 0)
+ goto error;
+
+ if (secondaryKey && VIR_STRDUP(obj->secondaryKey, secondaryKey) < 0)
+ goto error;
+
+ VIR_DEBUG("obj=%p, primary=%s secondary=%s",
+ obj, obj->primaryKey, NULLSTR(obj->secondaryKey));
+
+ return obj;
+
+ error:
+ virObjectUnref(obj);
+ return NULL;
+
+}
+
+static void
+virObjectPoolableHashElementDispose(void *anyobj)
+{
+ virObjectPoolableHashElementPtr obj = anyobj;
+
+ VIR_DEBUG("dispose obj=%p", obj);
+
+ VIR_FREE(obj->primaryKey);
+ VIR_FREE(obj->secondaryKey);
+}
+
+
/**
* virObjectUnref:
* @anyobj: any instance of virObjectPtr
@@ -417,7 +489,8 @@ static virObjectLockablePtr
virObjectGetLockableObj(void *anyobj)
{
if (virObjectIsClass(anyobj, virObjectLockableClass) ||
- virObjectIsClass(anyobj, virObjectPoolableHashTableClass))
+ virObjectIsClass(anyobj, virObjectPoolableHashTableClass) ||
+ virObjectIsClass(anyobj, virObjectPoolableHashElementClass))
return anyobj;
VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, virObjectLockableClass);
diff --git a/src/util/virobject.h b/src/util/virobject.h
index ac21190..36fd842 100644
--- a/src/util/virobject.h
+++ b/src/util/virobject.h
@@ -38,6 +38,9 @@ typedef virObjectLockable *virObjectLockablePtr;
typedef struct _virObjectPoolableHashTable virObjectPoolableHashTable;
typedef virObjectPoolableHashTable *virObjectPoolableHashTablePtr;
+typedef struct _virObjectPoolableHashElement virObjectPoolableHashElement;
+typedef virObjectPoolableHashElement *virObjectPoolableHashElementPtr;
+
typedef void (*virObjectDisposeCallback)(void *obj);
/* Most code should not play with the contents of this struct; however,
@@ -96,9 +99,17 @@ struct _virObjectPoolableHashTable {
};
+struct _virObjectPoolableHashElement {
+ virObjectLockable parent;
+
+ char *primaryKey;
+ char *secondaryKey;
+};
+
virClassPtr virClassForObject(void);
virClassPtr virClassForObjectLockable(void);
virClassPtr virClassForObjectPoolableHashTable(void);
+virClassPtr virClassForObjectPoolableHashElement(void);
# ifndef VIR_PARENT_REQUIRED
# define VIR_PARENT_REQUIRED ATTRIBUTE_NONNULL(1)
@@ -152,6 +163,12 @@ virObjectPoolableHashTableNew(virClassPtr klass,
bool primaryOnly)
ATTRIBUTE_NONNULL(1);
+void *
+virObjectPoolableHashElementNew(virClassPtr klass,
+ const char *primaryKey,
+ const char *secondaryKey)
+ ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+
void
virObjectLock(void *lockableobj)
ATTRIBUTE_NONNULL(1);
--
2.9.3
7:10 a.m.
New subject: [libvirt] [RFC PATCH 8/8] util: Add virObjectPoolableHashElementGet*Key
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/libvirt_private.syms | 2 ++
src/util/virobject.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++++
src/util/virobject.h | 6 ++++++
3 files changed, 59 insertions(+)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 74d4bf8..b18614b 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -2236,6 +2236,8 @@ virObjectListFreeCount;
virObjectLock;
virObjectLockableNew;
virObjectNew;
+virObjectPoolableHashElementGetPrimaryKey;
+virObjectPoolableHashElementGetSecondaryKey;
virObjectPoolableHashElementNew;
virObjectPoolableHashTableGetPrimary;
virObjectPoolableHashTableGetSecondary;
diff --git a/src/util/virobject.c b/src/util/virobject.c
index c9e631c..87bf56a 100644
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -700,3 +700,54 @@ virObjectPoolableHashTableGetSecondary(void *anyobj)
return obj->objsSecondary;
}
+
+
+static virObjectPoolableHashElementPtr
+virObjectGetPoolableHashElementObj(void *anyobj)
+{
+ if (virObjectIsClass(anyobj, virObjectPoolableHashElementClass))
+ return anyobj;
+
+ VIR_OBJECT_USAGE_PRINT_WARNING(anyobj, virObjectPoolableHashElementClass);
+
+ return NULL;
+
+}
+
+
+/**
+ * virObjectPoolableHashElementGetPrimaryKey
+ * @anyobj: Pointer to a PoolableHashElement object
+ *
+ * Returns: Pointer to the primaryKey or NULL on failure
+ */
+const char *
+virObjectPoolableHashElementGetPrimaryKey(void *anyobj)
+{
+ virObjectPoolableHashElementPtr obj =
+ virObjectGetPoolableHashElementObj(anyobj);
+
+ if (!obj)
+ return NULL;
+
+ return obj->primaryKey;
+}
+
+
+/**
+ * virObjectPoolableHashElementGetSecondaryKey
+ * @anyobj: Pointer to a PoolableHashElement object
+ *
+ * Returns: Pointer to the secondaryKey which may be NULL
+ */
+const char *
+virObjectPoolableHashElementGetSecondaryKey(void *anyobj)
+{
+ virObjectPoolableHashElementPtr obj =
+ virObjectGetPoolableHashElementObj(anyobj);
+
+ if (!obj)
+ return NULL;
+
+ return obj->secondaryKey;
+}
diff --git a/src/util/virobject.h b/src/util/virobject.h
index 36fd842..c1e40da 100644
--- a/src/util/virobject.h
+++ b/src/util/virobject.h
@@ -190,4 +190,10 @@ virObjectPoolableHashTableGetPrimary(void *anyobj);
virHashTablePtr
virObjectPoolableHashTableGetSecondary(void *anyobj);
+const char *
+virObjectPoolableHashElementGetPrimaryKey(void *anyobj);
+
+const char *
+virObjectPoolableHashElementGetSecondaryKey(void *anyobj);
+
#endif /* __VIR_OBJECT_H */
--
2.9.3
2787
days inactive
2787
days old
8 comments
1 participants
participants (1)
-
John Ferlan