interfaces: Convert virInterfaceObjList to virObjectRWLockable

Rather than a forward linked list, let's use the virHashTable in
order to manage the objsName data.

Requires numerous changes from List to Object management similar to
many other drivers/vir*obj.c modules

src/conf/virinterfaceobj.c

@@ -25,6 +25,7 @@
 #include "viralloc.h"
 #include "virerror.h"
 #include "virinterfaceobj.h"
+#include "virhash.h"
 #include "virlog.h"
 #include "virstring.h"
 
@@ -42,8 +43,9 @@ struct _virInterfaceObj {
 struct _virInterfaceObjList {
     virObjectRWLockable parent;
 
-    size_t count;
+    /* name string -> virInterfaceObj  mapping
-    virInterfaceObjPtr *objs;
+     * for O(1), lockless lookup-by-name */
+    virHashTable *objsName;
 };
 
 /* virInterfaceObj manipulation */
@@ -146,127 +148,182 @@ virInterfaceObjListNew(void)
     if (!(interfaces = virObjectRWLockableNew(virInterfaceObjListClass)))
         return NULL;
 
+    if (!(interfaces->objsName = virHashCreate(10, virObjectFreeHashData))) {
+        virObjectUnref(interfaces);
+        return NULL;
+    }
+
     return interfaces;
 }
 
 
+struct _virInterfaceObjFindMACData {
+    const char *matchStr;
+    bool error;
+    int nmacs;
+    int maxmacs;
+    char **const macs;
+};
+
+static int
+virInterfaceObjListFindByMACStringCb(void *payload,
+                                     const void *name ATTRIBUTE_UNUSED,
+                                     void *opaque)
+{
+    virInterfaceObjPtr obj = payload;
+    struct _virInterfaceObjFindMACData *data = opaque;
+
+    if (data->error)
+        return 0;
+
+    if (data->nmacs == data->maxmacs)
+        return 0;
+
+    virObjectLock(obj);
+
+    if (STRCASEEQ(obj->def->mac, data->matchStr)) {
+        if (VIR_STRDUP(data->macs[data->nmacs], data->matchStr) < 0) {
+            data->error = true;
+            goto cleanup;
+        }
+        data->nmacs++;
+    }
+
+ cleanup:
+    virObjectUnlock(obj);
+    return 0;
+}
+
+
 int
 virInterfaceObjListFindByMACString(virInterfaceObjListPtr interfaces,
                                    const char *mac,
                                    char **const matches,
                                    int maxmatches)
 {
-    size_t i;
+    struct _virInterfaceObjFindMACData data = { .matchStr = mac,
-    int matchct = 0;
+                                                .error = false,
+                                                .nmacs = 0,
+                                                .maxmacs = maxmatches,
+                                                .macs = matches };
 
     virObjectRWLockRead(interfaces);
-    for (i = 0; i < interfaces->count; i++) {
+    virHashForEach(interfaces->objsName, virInterfaceObjListFindByMACStringCb,
-        virInterfaceObjPtr obj = interfaces->objs[i];
+                   &data);
-        virInterfaceDefPtr def;
-
-        virObjectLock(obj);
-        def = obj->def;
-        if (STRCASEEQ(def->mac, mac)) {
-            if (matchct < maxmatches) {
-                if (VIR_STRDUP(matches[matchct], def->name) < 0) {
-                    virObjectUnlock(obj);
-                    goto error;
-                }
-                matchct++;
-            }
-        }
-        virObjectUnlock(obj);
-    }
     virObjectRWUnlock(interfaces);
-    return matchct;
+
+    if (data.error)
+        goto error;
+
+    return data.nmacs;
 
  error:
-    while (--matchct >= 0)
+    while (--data.nmacs >= 0)
-        VIR_FREE(matches[matchct]);
+        VIR_FREE(data.macs[data.nmacs]);
-    virObjectRWUnlock(interfaces);
 
     return -1;
 }
 
 
+static virInterfaceObjPtr
+virInterfaceObjListFindByNameLocked(virInterfaceObjListPtr interfaces,
+                                    const char *name)
+{
+    return virObjectRef(virHashLookup(interfaces->objsName, name));
+}
+
+
 virInterfaceObjPtr
 virInterfaceObjListFindByName(virInterfaceObjListPtr interfaces,
                               const char *name)
 {
-    size_t i;
+    virInterfaceObjPtr obj;
-
     virObjectRWLockRead(interfaces);
-    for (i = 0; i < interfaces->count; i++) {
+    obj = virInterfaceObjListFindByNameLocked(interfaces, name);
-        virInterfaceObjPtr obj = interfaces->objs[i];
-        virInterfaceDefPtr def;
-
-        virObjectLock(obj);
-        def = obj->def;
-        if (STREQ(def->name, name)) {
-            virObjectRWUnlock(interfaces);
-            return virObjectRef(obj);
-        }
-        virObjectUnlock(obj);
-    }
     virObjectRWUnlock(interfaces);
+    if (obj)
+        virObjectLock(obj);
 
-    return NULL;
+    return obj;
 }
 
 
 void
 virInterfaceObjListDispose(void *obj)
 {
-    size_t i;
     virInterfaceObjListPtr interfaces = obj;
 
-    for (i = 0; i < interfaces->count; i++)
+    virHashFree(interfaces->objsName);
-        virObjectUnref(interfaces->objs[i]);
+}
-    VIR_FREE(interfaces->objs);
+
+
+struct _virInterfaceObjListCloneData {
+    bool error;
+    virInterfaceObjListPtr dest;
+};
+
+static int
+virInterfaceObjListCloneCb(void *payload,
+                           const void *name ATTRIBUTE_UNUSED,
+                           void *opaque)
+{
+    virInterfaceObjPtr srcObj = payload;
+    struct _virInterfaceObjListCloneData *data = opaque;
+    char *xml = NULL;
+    virInterfaceDefPtr backup = NULL;
+    virInterfaceObjPtr obj;
+
+    if (data->error)
+        return 0;
+
+    virObjectLock(srcObj);
+
+    if (!(xml = virInterfaceDefFormat(srcObj->def)))
+        goto error;
+
+    if (!(backup = virInterfaceDefParseString(xml)))
+        goto error;
+    VIR_FREE(xml);
+
+    if (!(obj = virInterfaceObjListAssignDef(data->dest, backup)))
+        goto error;
+    virInterfaceObjEndAPI(&obj);
+
+    virObjectUnlock(srcObj);
+    return 0;
+
+ error:
+    data->error = true;
+    VIR_FREE(xml);
+    virInterfaceDefFree(backup);
+    virObjectUnlock(srcObj);
+    return 0;
 }
 
 
 virInterfaceObjListPtr
 virInterfaceObjListClone(virInterfaceObjListPtr interfaces)
 {
-    size_t i;
+    struct _virInterfaceObjListCloneData data = { .error = false,
-    unsigned int cnt;
+                                                  .dest = NULL };
-    virInterfaceObjListPtr dest;
 
     if (!interfaces)
         return NULL;
 
-    if (!(dest = virInterfaceObjListNew()))
+    if (!(data.dest = virInterfaceObjListNew()))
         return NULL;
 
     virObjectRWLockRead(interfaces);
-    cnt = interfaces->count;
+    virHashForEach(interfaces->objsName, virInterfaceObjListCloneCb, &data);
-    for (i = 0; i < cnt; i++) {
-        virInterfaceObjPtr srcobj = interfaces->objs[i];
-        virInterfaceDefPtr backup;
-        virInterfaceObjPtr obj;
-        char *xml = virInterfaceDefFormat(srcobj->def);
-
-        if (!xml)
-            goto error;
-
-        if (!(backup = virInterfaceDefParseString(xml))) {
-            VIR_FREE(xml);
-            goto error;
-        }
-
-        VIR_FREE(xml);
-        if (!(obj = virInterfaceObjListAssignDef(dest, backup)))
-            goto error;
-        virInterfaceObjEndAPI(&obj);
-    }
     virObjectRWUnlock(interfaces);
 
-    return dest;
+    if (data.error)
+        goto error;
+
+    return data.dest;
 
  error:
-    virObjectUnref(dest);
+    virObjectUnref(data.dest);
-    virObjectRWUnlock(interfaces);
     return NULL;
 }
 
@@ -277,26 +334,27 @@ virInterfaceObjListAssignDef(virInterfaceObjListPtr interfaces,
 {
     virInterfaceObjPtr obj;
 
-    if ((obj = virInterfaceObjListFindByName(interfaces, def->name))) {
-        virInterfaceDefFree(obj->def);
-        obj->def = def;
-
-        return obj;
-    }
-
-    if (!(obj = virInterfaceObjNew()))
-        return NULL;
-
     virObjectRWLockWrite(interfaces);
-    if (VIR_APPEND_ELEMENT_COPY(interfaces->objs,
+    if ((obj = virInterfaceObjListFindByNameLocked(interfaces, def->name))) {
-                                interfaces->count, obj) < 0) {
+        virInterfaceDefFree(obj->def);
-        virInterfaceObjEndAPI(&obj);
+    } else {
-        virObjectRWUnlock(interfaces);
+        if (!(obj = virInterfaceObjNew()))
-        return NULL;
+            goto error;
+
+        if (virHashAddEntry(interfaces->objsName, def->name, obj) < 0)
+            goto error;
+        virObjectRef(obj);
     }
+
     obj->def = def;
     virObjectRWUnlock(interfaces);
-    return virObjectRef(obj);
+
+    return obj;
+
+ error:
+    virInterfaceObjEndAPI(&obj);
+    virObjectRWUnlock(interfaces);
+    return NULL;
 }
 
 
@@ -304,43 +362,96 @@ void
 virInterfaceObjListRemove(virInterfaceObjListPtr interfaces,
                           virInterfaceObjPtr obj)
 {
-    size_t i;
+    if (!obj)
+        return;
 
+    virObjectRef(obj);
     virObjectUnlock(obj);
     virObjectRWLockWrite(interfaces);
-    for (i = 0; i < interfaces->count; i++) {
+    virObjectLock(obj);
-        virObjectLock(interfaces->objs[i]);
+    virHashRemoveEntry(interfaces->objsName, obj->def->name);
-        if (interfaces->objs[i] == obj) {
+    virObjectUnlock(obj);
-            virObjectUnlock(interfaces->objs[i]);
+    virObjectUnref(obj);
-            virObjectUnref(interfaces->objs[i]);
-
-            VIR_DELETE_ELEMENT(interfaces->objs, i, interfaces->count);
-            break;
-        }
-        virObjectUnlock(interfaces->objs[i]);
-    }
     virObjectRWUnlock(interfaces);
 }
 
 
+struct _virInterfaceObjNumOfInterfacesData {
+    bool wantActive;
+    int count;
+};
+
+static int
+virInterfaceObjListNumOfInterfacesCb(void *payload,
+                                     const void *name ATTRIBUTE_UNUSED,
+                                     void *opaque)
+{
+    virInterfaceObjPtr obj = payload;
+    struct _virInterfaceObjNumOfInterfacesData *data = opaque;
+
+    virObjectLock(obj);
+
+    if (data->wantActive == virInterfaceObjIsActive(obj))
+        data->count++;
+
+    virObjectUnlock(obj);
+    return 0;
+}
+
+
 int
 virInterfaceObjListNumOfInterfaces(virInterfaceObjListPtr interfaces,
                                    bool wantActive)
 {
-    size_t i;
+    struct _virInterfaceObjNumOfInterfacesData data = {
-    int ninterfaces = 0;
+        .wantActive = wantActive, .count = 0 };
 
     virObjectRWLockRead(interfaces);
-    for (i = 0; (i < interfaces->count); i++) {
+    virHashForEach(interfaces->objsName, virInterfaceObjListNumOfInterfacesCb,
-        virInterfaceObjPtr obj = interfaces->objs[i];
+                   &data);
-        virObjectLock(obj);
-        if (wantActive == virInterfaceObjIsActive(obj))
-            ninterfaces++;
-        virObjectUnlock(obj);
-    }
     virObjectRWUnlock(interfaces);
 
-    return ninterfaces;
+    return data.count;
+}
+
+
+struct _virInterfaceObjGetNamesData {
+    bool wantActive;
+    bool error;
+    int nnames;
+    int maxnames;
+    char **const names;
+};
+
+static int
+virInterfaceObjListGetNamesCb(void *payload,
+                              const void *name ATTRIBUTE_UNUSED,
+                              void *opaque)
+{
+    virInterfaceObjPtr obj = payload;
+    struct _virInterfaceObjGetNamesData *data = opaque;
+
+    if (data->error)
+        return 0;
+
+    if (data->maxnames >= 0 && data->nnames == data->maxnames)
+        return 0;
+
+    virObjectLock(obj);
+
+    if (data->wantActive != virInterfaceObjIsActive(obj))
+        goto cleanup;
+
+    if (VIR_STRDUP(data->names[data->nnames], obj->def->name) < 0) {
+        data->error = true;
+        goto cleanup;
+    }
+
+    data->nnames++;
+
+ cleanup:
+    virObjectUnlock(obj);
+    return 0;
 }
 
 
@@ -350,32 +461,22 @@ virInterfaceObjListGetNames(virInterfaceObjListPtr interfaces,
                             char **const names,
                             int maxnames)
 {
-    int nnames = 0;
+    struct _virInterfaceObjGetNamesData data = {
-    size_t i;
+        .wantActive = wantActive, .error = false, .nnames = 0,
+        .maxnames = maxnames,  .names = names };
 
     virObjectRWLockRead(interfaces);
-    for (i = 0; i < interfaces->count && nnames < maxnames; i++) {
+    virHashForEach(interfaces->objsName, virInterfaceObjListGetNamesCb, &data);
-        virInterfaceObjPtr obj = interfaces->objs[i];
-        virInterfaceDefPtr def;
-
-        virObjectLock(obj);
-        def = obj->def;
-        if (wantActive == virInterfaceObjIsActive(obj)) {
-            if (VIR_STRDUP(names[nnames], def->name) < 0) {
-                virObjectUnlock(obj);
-                goto failure;
-            }
-            nnames++;
-        }
-        virObjectUnlock(obj);
-    }
     virObjectRWUnlock(interfaces);
 
-    return nnames;
+    if (data.error)
+        goto error;
 
- failure:
+    return data.nnames;
-    while (--nnames >= 0)
+
-        VIR_FREE(names[nnames]);
+ error:
+    while (--data.nnames >= 0)
+        VIR_FREE(data.names[data.nnames]);
 
     return -1;
 }