11:05 a.m.
Our hash table API was surprisingly close to glibs.
v2:
- pushed ACK'd patch
- typo fix
- rebased on current master
- hashing function not replaced as our has random initialization
Peter Krempa (12):
virhashtest: testHashGetItems: Remove test case for sorting by value
util: hash: Rewrite sorting of elements in virHashGetItems
util: hash: Introduce virHashForEachSorted
Use virHashForEachSorted in tested code
tests: remove virdeterministichashmock.so
util: hash: Add delete-safe hash iterator
util: hash: Use virHashForEachSafe in places which might delete the
element
util: hash: Don't use 'const' with virHashTablePtr
util: hash: Reimplement virHashTable using GHashTable
util: hash: Retire 'virHashTable' in favor of 'GHashTable'
util: hash: Add deprecation notices for functions which have
g_hash_table replacements
tests: Remove 'virhashtest'
src/conf/backup_conf.c | 2 +-
src/conf/domain_addr.h | 2 +-
src/conf/domain_conf.c | 12 +-
src/conf/domain_conf.h | 2 +-
src/conf/nwfilter_conf.h | 2 +-
src/conf/nwfilter_ipaddrmap.c | 2 +-
src/conf/nwfilter_params.c | 34 +-
src/conf/nwfilter_params.h | 18 +-
src/conf/snapshot_conf.c | 2 +-
src/conf/virchrdev.c | 4 +-
src/conf/virdomainmomentobjlist.c | 4 +-
src/conf/virdomainobjlist.c | 6 +-
src/conf/virinterfaceobj.c | 2 +-
src/conf/virnetworkobj.c | 8 +-
src/conf/virnodedeviceobj.c | 2 +-
src/conf/virnwfilterbindingdef.h | 2 +-
src/conf/virnwfilterbindingobjlist.c | 4 +-
src/conf/virsecretobj.c | 2 +-
src/conf/virstorageobj.c | 14 +-
src/hyperv/hyperv_driver.c | 4 +-
src/hyperv/hyperv_wmi.c | 18 +-
src/hyperv/hyperv_wmi.h | 12 +-
src/hypervisor/virclosecallbacks.c | 2 +-
src/libvirt_private.syms | 2 +
src/libxl/libxl_logger.c | 2 +-
src/locking/lock_daemon.c | 4 +-
src/nwfilter/nwfilter_dhcpsnoop.c | 6 +-
src/nwfilter/nwfilter_ebiptables_driver.c | 19 +-
src/nwfilter/nwfilter_gentech_driver.c | 36 +-
src/nwfilter/nwfilter_gentech_driver.h | 2 +-
src/nwfilter/nwfilter_learnipaddr.c | 4 +-
src/nwfilter/nwfilter_tech_driver.h | 2 +-
src/qemu/qemu_agent.c | 4 +-
src/qemu/qemu_backup.c | 14 +-
src/qemu/qemu_backup.h | 2 +-
src/qemu/qemu_block.c | 42 +-
src/qemu/qemu_block.h | 18 +-
src/qemu/qemu_blockjob.c | 6 +-
src/qemu/qemu_capabilities.c | 8 +-
src/qemu/qemu_checkpoint.c | 6 +-
src/qemu/qemu_checkpoint.h | 2 +-
src/qemu/qemu_conf.c | 4 +-
src/qemu/qemu_conf.h | 2 +-
src/qemu/qemu_domain.c | 8 +-
src/qemu/qemu_domain.h | 2 +-
src/qemu/qemu_driver.c | 24 +-
src/qemu/qemu_interop_config.c | 13 +-
src/qemu/qemu_migration.c | 2 +-
src/qemu/qemu_migration_cookie.c | 2 +-
src/qemu/qemu_monitor.c | 28 +-
src/qemu/qemu_monitor.h | 20 +-
src/qemu/qemu_monitor_json.c | 50 +-
src/qemu/qemu_monitor_json.h | 22 +-
src/qemu/qemu_process.c | 18 +-
src/qemu/qemu_qapi.c | 14 +-
src/qemu/qemu_qapi.h | 6 +-
src/qemu/qemu_snapshot.c | 16 +-
src/rpc/virnetdaemon.c | 13 +-
src/security/security_selinux.c | 2 +-
src/util/virfilecache.c | 2 +-
src/util/virhash.c | 571 ++++++++----------
src/util/virhash.h | 47 +-
src/util/viriptables.c | 4 +-
src/util/virlockspace.c | 4 +-
src/util/virmacmap.c | 4 +-
src/util/virstoragefile.c | 8 +-
src/util/virsystemd.c | 2 +-
tests/meson.build | 2 -
tests/nwfilterxml2firewalltest.c | 24 +-
tests/qemublocktest.c | 26 +-
tests/qemuhotplugtest.c | 6 +-
tests/qemumigparamstest.c | 4 +-
tests/qemumonitorjsontest.c | 30 +-
tests/qemumonitortestutils.c | 6 +-
tests/qemumonitortestutils.h | 4 +-
tests/qemusecuritymock.c | 4 +-
.../blockjob-blockdev-in.xml | 116 ++--
tests/qemuxml2argvtest.c | 4 +-
tests/qemuxml2xmltest.c | 5 +-
tests/testutilsqemu.c | 6 +-
tests/testutilsqemu.h | 4 +-
tests/testutilsqemuschema.c | 10 +-
tests/testutilsqemuschema.h | 8 +-
tests/virdeterministichashmock.c | 36 --
tests/virhashdata.h | 284 ---------
tests/virhashtest.c | 564 -----------------
tests/virmacmaptest.c | 2 +-
87 files changed, 690 insertions(+), 1682 deletions(-)
delete mode 100644 tests/virdeterministichashmock.c
delete mode 100644 tests/virhashdata.h
delete mode 100644 tests/virhashtest.c
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 01/12] virhashtest: testHashGetItems: Remove test case for sorting by value
Upcoming patch will rewrite virHashGetItems to remove the sorting
function since the prevalent mode is to order by keys.
Remove the test for it.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
tests/virhashtest.c | 19 -------------------
1 file changed, 19 deletions(-)
diff --git a/tests/virhashtest.c b/tests/virhashtest.c
index ad50aae003..8cc3109929 100644
--- a/tests/virhashtest.c
+++ b/tests/virhashtest.c
@@ -368,13 +368,6 @@ testHashGetItemsCompKey(const virHashKeyValuePair *a,
return strcmp(a->key, b->key);
}
-static int
-testHashGetItemsCompValue(const virHashKeyValuePair *a,
- const virHashKeyValuePair *b)
-{
- return strcmp(a->value, b->value);
-}
-
static int
testHashGetItems(const void *data G_GNUC_UNUSED)
{
@@ -416,18 +409,6 @@ testHashGetItems(const void *data G_GNUC_UNUSED)
}
VIR_FREE(array);
- if (!(array = virHashGetItems(hash, testHashGetItemsCompValue)) ||
- STRNEQ(array[0].key, "c") ||
- STRNEQ(array[0].value, "1") ||
- STRNEQ(array[1].key, "b") ||
- STRNEQ(array[1].value, "2") ||
- STRNEQ(array[2].key, "a") ||
- STRNEQ(array[2].value, "3") ||
- array[3].key || array[3].value) {
- VIR_TEST_VERBOSE("\nfailed to get items with value sort");
- goto cleanup;
- }
-
ret = 0;
cleanup:
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 02/12] util: hash: Rewrite sorting of elements in virHashGetItems
All but one of the callers either use the list in arbitrary order or
sorted by key. Rewrite the function so that it supports sorting by key
natively and make it return the element count. This in turn allows to
rewrite the only caller to sort by value internally.
This allows to remove multiple sorting functions which were sorting by
key and the function will be also later reused for some hash operations
internally.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/conf/nwfilter_params.c | 10 +---
src/hyperv/hyperv_wmi.c | 2 +-
src/locking/lock_daemon.c | 2 +-
src/nwfilter/nwfilter_ebiptables_driver.c | 13 +++--
src/qemu/qemu_interop_config.c | 9 +---
src/rpc/virnetdaemon.c | 11 +---
src/util/virhash.c | 66 ++++++++++++++---------
src/util/virhash.h | 5 +-
src/util/virlockspace.c | 2 +-
tests/virhashtest.c | 11 +---
10 files changed, 59 insertions(+), 72 deletions(-)
diff --git a/src/conf/nwfilter_params.c b/src/conf/nwfilter_params.c
index 73160a38a4..dd2b92c97b 100644
--- a/src/conf/nwfilter_params.c
+++ b/src/conf/nwfilter_params.c
@@ -755,13 +755,6 @@ virNWFilterParseParamAttributes(xmlNodePtr cur)
}
-static int
-virNWFilterFormatParameterNameSorter(const virHashKeyValuePair *a,
- const virHashKeyValuePair *b)
-{
- return strcmp(a->key, b->key);
-}
-
int
virNWFilterFormatParamAttributes(virBufferPtr buf,
virHashTablePtr table,
@@ -779,8 +772,7 @@ virNWFilterFormatParamAttributes(virBufferPtr buf,
return -1;
}
- items = virHashGetItems(table,
- virNWFilterFormatParameterNameSorter);
+ items = virHashGetItems(table, NULL, true);
if (!items)
return -1;
diff --git a/src/hyperv/hyperv_wmi.c b/src/hyperv/hyperv_wmi.c
index 1d0d33ec6d..7a66e4810e 100644
--- a/src/hyperv/hyperv_wmi.c
+++ b/src/hyperv/hyperv_wmi.c
@@ -681,7 +681,7 @@ hypervSerializeEmbeddedParam(hypervParamPtr p, const char
*resourceUri,
/* retrieve parameters out of hash table */
numKeys = virHashSize(p->embedded.table);
- items = virHashGetItems(p->embedded.table, NULL);
+ items = virHashGetItems(p->embedded.table, NULL, false);
if (!items) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not read embedded param hash table"));
diff --git a/src/locking/lock_daemon.c b/src/locking/lock_daemon.c
index 8f16dfd064..021792cc69 100644
--- a/src/locking/lock_daemon.c
+++ b/src/locking/lock_daemon.c
@@ -730,7 +730,7 @@ virLockDaemonPreExecRestart(const char *state_file,
}
- tmp = pairs = virHashGetItems(lockDaemon->lockspaces, NULL);
+ tmp = pairs = virHashGetItems(lockDaemon->lockspaces, NULL, false);
while (tmp && tmp->key) {
virLockSpacePtr lockspace = (virLockSpacePtr)tmp->value;
diff --git a/src/nwfilter/nwfilter_ebiptables_driver.c
b/src/nwfilter/nwfilter_ebiptables_driver.c
index da6f88f135..8dfc870ab7 100644
--- a/src/nwfilter/nwfilter_ebiptables_driver.c
+++ b/src/nwfilter/nwfilter_ebiptables_driver.c
@@ -3126,9 +3126,12 @@ virNWFilterRuleInstSortPtr(const void *a, const void *b)
static int
-ebiptablesFilterOrderSort(const virHashKeyValuePair *a,
- const virHashKeyValuePair *b)
+ebiptablesFilterOrderSort(const void *va,
+ const void *vb)
{
+ const virHashKeyValuePair *a = va;
+ const virHashKeyValuePair *b = vb;
+
/* elements' values has been limited to range [-1000, 1000] */
return *(virNWFilterChainPriority *)a->value -
*(virNWFilterChainPriority *)b->value;
@@ -3288,13 +3291,15 @@ ebtablesGetSubChainInsts(virHashTablePtr chains,
size_t *ninsts)
{
g_autofree virHashKeyValuePairPtr filter_names = NULL;
+ size_t nfilter_names;
size_t i;
- filter_names = virHashGetItems(chains,
- ebiptablesFilterOrderSort);
+ filter_names = virHashGetItems(chains, &nfilter_names, false);
if (filter_names == NULL)
return -1;
+ qsort(filter_names, nfilter_names, sizeof(*filter_names),
ebiptablesFilterOrderSort);
+
for (i = 0; filter_names[i].key; i++) {
g_autofree ebtablesSubChainInstPtr inst = NULL;
enum l3_proto_idx idx = ebtablesGetProtoIdxByFiltername(
diff --git a/src/qemu/qemu_interop_config.c b/src/qemu/qemu_interop_config.c
index e1c20aff11..c8b81c59a8 100644
--- a/src/qemu/qemu_interop_config.c
+++ b/src/qemu/qemu_interop_config.c
@@ -79,13 +79,6 @@ qemuBuildFileList(virHashTablePtr files, const char *dir)
return 0;
}
-static int
-qemuConfigFilesSorter(const virHashKeyValuePair *a,
- const virHashKeyValuePair *b)
-{
- return strcmp(a->key, b->key);
-}
-
#define QEMU_SYSTEM_LOCATION PREFIX "/share/qemu"
#define QEMU_ETC_LOCATION SYSCONFDIR "/qemu"
@@ -141,7 +134,7 @@ qemuInteropFetchConfigs(const char *name,
if (virHashSize(files) == 0)
return 0;
- if (!(pairs = virHashGetItems(files, qemuConfigFilesSorter)))
+ if (!(pairs = virHashGetItems(files, NULL, true)))
return -1;
for (tmp = pairs; tmp->key; tmp++) {
diff --git a/src/rpc/virnetdaemon.c b/src/rpc/virnetdaemon.c
index ce13f0d927..525cbb3ce6 100644
--- a/src/rpc/virnetdaemon.c
+++ b/src/rpc/virnetdaemon.c
@@ -378,15 +378,6 @@ virNetDaemonNewPostExecRestart(virJSONValuePtr object,
}
-static int
-daemonServerCompare(const virHashKeyValuePair *a, const virHashKeyValuePair *b)
-{
- const char *as = a->key;
- const char *bs = b->key;
-
- return strcmp(as, bs);
-}
-
virJSONValuePtr
virNetDaemonPreExecRestart(virNetDaemonPtr dmn)
{
@@ -402,7 +393,7 @@ virNetDaemonPreExecRestart(virNetDaemonPtr dmn)
goto error;
}
- if (!(srvArray = virHashGetItems(dmn->servers, daemonServerCompare)))
+ if (!(srvArray = virHashGetItems(dmn->servers, NULL, true)))
goto error;
for (i = 0; srvArray[i].key; i++) {
diff --git a/src/util/virhash.c b/src/util/virhash.c
index b30db8a87a..f644990712 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -626,49 +626,63 @@ void *virHashSearch(const virHashTable *ctable,
return NULL;
}
-struct getKeysIter
-{
- virHashKeyValuePair *sortArray;
- size_t arrayIdx;
+
+struct virHashGetItemsIteratorData {
+ virHashKeyValuePair *items;
+ size_t i;
};
-static int virHashGetKeysIterator(void *payload,
- const char *key, void *data)
+
+static int
+virHashGetItemsIterator(void *payload,
+ const char *key,
+ void *opaque)
{
- struct getKeysIter *iter = data;
+ struct virHashGetItemsIteratorData *data = opaque;
- iter->sortArray[iter->arrayIdx].key = key;
- iter->sortArray[iter->arrayIdx].value = payload;
+ data->items[data->i].key = key;
+ data->items[data->i].value = payload;
- iter->arrayIdx++;
+ data->i++;
return 0;
}
-typedef int (*qsort_comp)(const void *, const void *);
-virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table,
- virHashKeyComparator compar)
+static int
+virHashGetItemsKeySorter(const void *va,
+ const void *vb)
{
- ssize_t numElems = virHashSize(table);
- struct getKeysIter iter = {
- .arrayIdx = 0,
- .sortArray = NULL,
- };
+ const virHashKeyValuePair *a = va;
+ const virHashKeyValuePair *b = vb;
- if (numElems < 0)
- return NULL;
+ return strcmp(a->key, b->key);
+}
+
+
+virHashKeyValuePairPtr
+virHashGetItems(virHashTablePtr table,
+ size_t *nitems,
+ bool sortKeys)
+{
+ size_t dummy;
+ struct virHashGetItemsIteratorData data = { .items = NULL, .i = 0 };
- iter.sortArray = g_new0(virHashKeyValuePair, numElems + 1);
+ if (!nitems)
+ nitems = &dummy;
- virHashForEach(table, virHashGetKeysIterator, &iter);
+ *nitems = virHashSize(table);
- if (compar)
- qsort(&iter.sortArray[0], numElems, sizeof(iter.sortArray[0]),
- (qsort_comp)compar);
+ data.items = g_new0(virHashKeyValuePair, *nitems + 1);
- return iter.sortArray;
+ virHashForEach(table, virHashGetItemsIterator, &data);
+
+ if (sortKeys)
+ qsort(data.items, *nitems, sizeof(* data.items), virHashGetItemsKeySorter);
+
+ return data.items;
}
+
struct virHashEqualData
{
bool equal;
diff --git a/src/util/virhash.h b/src/util/virhash.h
index b2ea5c9a96..688e1adf4d 100644
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -116,10 +116,9 @@ struct _virHashKeyValuePair {
const void *key;
const void *value;
};
-typedef int (*virHashKeyComparator)(const virHashKeyValuePair *,
- const virHashKeyValuePair *);
virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table,
- virHashKeyComparator compar);
+ size_t *nitems,
+ bool sortedKeys);
/*
* Compare two tables for equality: the lookup of a key's value in
diff --git a/src/util/virlockspace.c b/src/util/virlockspace.c
index 2731d46dfc..d39f2c026f 100644
--- a/src/util/virlockspace.c
+++ b/src/util/virlockspace.c
@@ -435,7 +435,7 @@ virJSONValuePtr virLockSpacePreExecRestart(virLockSpacePtr lockspace)
goto error;
}
- tmp = pairs = virHashGetItems(lockspace->resources, NULL);
+ tmp = pairs = virHashGetItems(lockspace->resources, NULL, false);
while (tmp && tmp->value) {
virLockSpaceResourcePtr res = (virLockSpaceResourcePtr)tmp->value;
virJSONValuePtr child = virJSONValueNewObject();
diff --git a/tests/virhashtest.c b/tests/virhashtest.c
index 8cc3109929..93949d8b7a 100644
--- a/tests/virhashtest.c
+++ b/tests/virhashtest.c
@@ -361,13 +361,6 @@ testHashSearch(const void *data G_GNUC_UNUSED)
}
-static int
-testHashGetItemsCompKey(const virHashKeyValuePair *a,
- const virHashKeyValuePair *b)
-{
- return strcmp(a->key, b->key);
-}
-
static int
testHashGetItems(const void *data G_GNUC_UNUSED)
{
@@ -389,14 +382,14 @@ testHashGetItems(const void *data G_GNUC_UNUSED)
goto cleanup;
}
- if (!(array = virHashGetItems(hash, NULL)) ||
+ if (!(array = virHashGetItems(hash, NULL, false)) ||
array[3].key || array[3].value) {
VIR_TEST_VERBOSE("\nfailed to get items with NULL sort");
goto cleanup;
}
VIR_FREE(array);
- if (!(array = virHashGetItems(hash, testHashGetItemsCompKey)) ||
+ if (!(array = virHashGetItems(hash, NULL, true)) ||
STRNEQ(array[0].key, "a") ||
STRNEQ(array[0].value, "3") ||
STRNEQ(array[1].key, "b") ||
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 03/12] util: hash: Introduce virHashForEachSorted
Iterate the hash elements sorted by key. This is useful to provide a
stable ordering such as in cases when the output is checked in tests.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/libvirt_private.syms | 1 +
src/util/virhash.c | 39 +++++++++++++++++++++++++++++++++++----
src/util/virhash.h | 1 +
3 files changed, 37 insertions(+), 4 deletions(-)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 95e50835ad..1793b81ad9 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -2203,6 +2203,7 @@ virHashAtomicSteal;
virHashAtomicUpdate;
virHashEqual;
virHashForEach;
+virHashForEachSorted;
virHashFree;
virHashGetItems;
virHashHasEntry;
diff --git a/src/util/virhash.c b/src/util/virhash.c
index f644990712..f205291de9 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -481,14 +481,25 @@ virHashRemoveEntry(virHashTablePtr table, const char *name)
/**
- * virHashForEach
+ * virHashForEach, virHashForEachSorted
* @table: the hash table to process
* @iter: callback to process each element
* @opaque: opaque data to pass to the iterator
*
- * Iterates over every element in the hash table, invoking the
- * 'iter' callback. The callback is allowed to remove the current element
- * using virHashRemoveEntry but calling other virHash* functions is prohibited.
+ * Iterates over every element in the hash table, invoking the 'iter' callback.
+ *
+ * The elements are iterated in arbitrary order.
+ *
+ * virHashForEach allows the callback to remove the current
+ * element using virHashRemoveEntry but calling other virHash* functions is
+ * prohibited. Note that removing the entry invalidates @key and @payload in
+ * the callback.
+ *
+ * virHashForEachSorted iterates the elements in order by sorted key.
+ *
+ * virHashForEachSorted is more computationally
+ * expensive than virHashForEach.
+ *
* If @iter fails and returns a negative value, the evaluation is stopped and -1
* is returned.
*
@@ -520,6 +531,26 @@ virHashForEach(virHashTablePtr table, virHashIterator iter, void
*opaque)
}
+int
+virHashForEachSorted(virHashTablePtr table,
+ virHashIterator iter,
+ void *opaque)
+{
+ g_autofree virHashKeyValuePairPtr items = virHashGetItems(table, NULL, true);
+ size_t i;
+
+ if (!items)
+ return -1;
+
+ for (i = 0; items[i].key; i++) {
+ if (iter((void *)items[i].value, items[i].key, opaque) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+
/**
* virHashRemoveSet
* @table: the hash table to process
diff --git a/src/util/virhash.h b/src/util/virhash.h
index 688e1adf4d..1a59e9799d 100644
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -136,6 +136,7 @@ bool virHashEqual(const virHashTable *table1,
* Iterators
*/
int virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque);
+int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void *opaque);
ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void
*opaque);
void *virHashSearch(const virHashTable *table, virHashSearcher iter,
const void *opaque, char **name);
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 04/12] Use virHashForEachSorted in tested code
The simplest way to write tests is to check the output against expected
output, but we must ensure that the output is stable. We can use
virHashForEachSorted as a hash iterator to ensure stable ordering.
This patch fixes 3 instances of hash iteration which is tested in
various parts, including test output changes in appropriate places.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/qemu/qemu_domain.c | 6 +-
src/util/virmacmap.c | 2 +-
tests/qemumonitorjsontest.c | 2 +-
.../blockjob-blockdev-in.xml | 116 +++++++++---------
4 files changed, 63 insertions(+), 63 deletions(-)
diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index d7dbca487a..e770940aca 100644
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -2223,9 +2223,9 @@ qemuDomainObjPrivateXMLFormatBlockjobs(virBufferPtr buf,
virTristateBoolTypeToString(virTristateBoolFromBool(bj)));
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV) &&
- virHashForEach(priv->blockjobs,
- qemuDomainObjPrivateXMLFormatBlockjobIterator,
- &iterdata) < 0)
+ virHashForEachSorted(priv->blockjobs,
+ qemuDomainObjPrivateXMLFormatBlockjobIterator,
+ &iterdata) < 0)
return -1;
virXMLFormatElement(buf, "blockjobs", &attrBuf, &childBuf);
diff --git a/src/util/virmacmap.c b/src/util/virmacmap.c
index 2d203e72af..fe71b06dd7 100644
--- a/src/util/virmacmap.c
+++ b/src/util/virmacmap.c
@@ -244,7 +244,7 @@ virMacMapDumpStrLocked(virMacMapPtr mgr,
arr = virJSONValueNewArray();
- if (virHashForEach(mgr->macs, virMACMapHashDumper, arr) < 0)
+ if (virHashForEachSorted(mgr->macs, virMACMapHashDumper, arr) < 0)
goto cleanup;
if (!(*str = virJSONValueToString(arr, true)))
diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c
index 2a0377bae3..9231fa835a 100644
--- a/tests/qemumonitorjsontest.c
+++ b/tests/qemumonitorjsontest.c
@@ -2792,7 +2792,7 @@ testBlockNodeNameDetect(const void *opaque)
blockstatsJson)))
goto cleanup;
- virHashForEach(nodedata, testBlockNodeNameDetectFormat, &buf);
+ virHashForEachSorted(nodedata, testBlockNodeNameDetectFormat, &buf);
virBufferTrim(&buf, "\n");
diff --git a/tests/qemustatusxml2xmldata/blockjob-blockdev-in.xml
b/tests/qemustatusxml2xmldata/blockjob-blockdev-in.xml
index 8ffc91bdcb..c70742418b 100644
--- a/tests/qemustatusxml2xmldata/blockjob-blockdev-in.xml
+++ b/tests/qemustatusxml2xmldata/blockjob-blockdev-in.xml
@@ -234,9 +234,12 @@
<allowReboot value='yes'/>
<nodename index='0'/>
<blockjobs active='yes'>
- <blockjob name='pull-vdb-libvirt-3-format' type='pull'
state='running'>
- <disk dst='vdb'/>
- <base node='libvirt-14-format'/>
+ <blockjob name='broken-test' type='broken' state='ready'
brokentype='commit'/>
+ <blockjob name='commit-vdc-libvirt-9-format' type='commit'
state='running' jobflags='0x0'>
+ <disk dst='vdc'/>
+ <base node='libvirt-11-format'/>
+ <top node='libvirt-9-format'/>
+ <topparent node='libvirt-2-format'/>
</blockjob>
<blockjob name='commit-vde-libvirt-17-format' type='active-commit'
state='ready'>
<disk dst='vde'/>
@@ -244,9 +247,61 @@
<top node='libvirt-17-format'/>
<deleteCommittedImages/>
</blockjob>
+ <blockjob name='copy-vdd-libvirt-4321-format' type='copy'
state='ready' jobflags='0x0' shallownew='yes'>
+ <disk dst='vdd'/>
+ </blockjob>
+ <blockjob name='create-libvirt-1337-storage' type='create'
state='running'>
+ <create mode='storage'/>
+ <src type='network' format='qcow2'>
+ <source protocol='rbd' name='pool/volname.qcow2'
tlsFromConfig='0' index='1337'>
+ <host name='example.org'/>
+ <privateData>
+ <nodenames>
+ <nodename type='storage'
name='libvirt-1337-storage'/>
+ <nodename type='format' name='libvirt-1337-format'/>
+ </nodenames>
+ <objects>
+ <secret type='auth'
alias='libvirt-1337-storage-secret0'/>
+ </objects>
+ </privateData>
+ </source>
+ </src>
+ </blockjob>
+ <blockjob name='create-libvirt-1338-format' type='create'
state='running' jobflags='0xabcd'>
+ <chains>
+ <disk type='file' format='qcow2'>
+ <source file='/create/src1.qcow2' index='1339'>
+ <privateData>
+ <nodenames>
+ <nodename type='storage'
name='libvirt-1339-storage'/>
+ <nodename type='format'
name='libvirt-1339-format'/>
+ </nodenames>
+ </privateData>
+ </source>
+ <backingStore/>
+ </disk>
+ </chains>
+ <src type='file' format='qcow2'>
+ <source file='/tmp/create/overlay.qcow2' index='1338'>
+ <privateData>
+ <nodenames>
+ <nodename type='storage'
name='libvirt-1338-storage'/>
+ <nodename type='format' name='libvirt-1338-format'/>
+ </nodenames>
+ <objects>
+ <secret type='encryption'
alias='libvirt-1338-storage-secret0'/>
+ </objects>
+ </privateData>
+ </source>
+ </src>
+ </blockjob>
<blockjob name='drive-virtio-disk0' type='copy'
state='ready' jobflags='0x0'>
<disk dst='vda' mirror='yes'/>
</blockjob>
+ <blockjob name='pull-vdb-libvirt-3-format' type='pull'
state='running'>
+ <disk dst='vdb'/>
+ <base node='libvirt-14-format'/>
+ </blockjob>
<blockjob name='test-orphan-job0' type='copy'
state='ready'>
<chains>
<disk type='file' format='qcow2'>
@@ -284,61 +339,6 @@
</mirror>
</chains>
</blockjob>
- <blockjob name='broken-test' type='broken' state='ready'
brokentype='commit'/>
- <blockjob name='create-libvirt-1338-format' type='create'
state='running' jobflags='0xabcd'>
- <chains>
- <disk type='file' format='qcow2'>
- <source file='/create/src1.qcow2' index='1339'>
- <privateData>
- <nodenames>
- <nodename type='storage'
name='libvirt-1339-storage'/>
- <nodename type='format'
name='libvirt-1339-format'/>
- </nodenames>
- </privateData>
- </source>
- <backingStore/>
- </disk>
- </chains>
- <src type='file' format='qcow2'>
- <source file='/tmp/create/overlay.qcow2' index='1338'>
- <privateData>
- <nodenames>
- <nodename type='storage'
name='libvirt-1338-storage'/>
- <nodename type='format' name='libvirt-1338-format'/>
- </nodenames>
- <objects>
- <secret type='encryption'
alias='libvirt-1338-storage-secret0'/>
- </objects>
- </privateData>
- </source>
- </src>
- </blockjob>
- <blockjob name='commit-vdc-libvirt-9-format' type='commit'
state='running' jobflags='0x0'>
- <disk dst='vdc'/>
- <base node='libvirt-11-format'/>
- <top node='libvirt-9-format'/>
- <topparent node='libvirt-2-format'/>
- </blockjob>
- <blockjob name='create-libvirt-1337-storage' type='create'
state='running'>
- <create mode='storage'/>
- <src type='network' format='qcow2'>
- <source protocol='rbd' name='pool/volname.qcow2'
tlsFromConfig='0' index='1337'>
- <host name='example.org'/>
- <privateData>
- <nodenames>
- <nodename type='storage'
name='libvirt-1337-storage'/>
- <nodename type='format' name='libvirt-1337-format'/>
- </nodenames>
- <objects>
- <secret type='auth'
alias='libvirt-1337-storage-secret0'/>
- </objects>
- </privateData>
- </source>
- </src>
- </blockjob>
- <blockjob name='copy-vdd-libvirt-4321-format' type='copy'
state='ready' jobflags='0x0' shallownew='yes'>
- <disk dst='vdd'/>
- </blockjob>
</blockjobs>
<agentTimeout>-2</agentTimeout>
<domain type='kvm' id='4'>
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 05/12] tests: remove virdeterministichashmock.so
Code which is sensitive to ordering now uses deterministic iterator
functions, so we can remove the mock override.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
tests/meson.build | 1 -
tests/qemublocktest.c | 2 +-
tests/qemumonitorjsontest.c | 2 +-
tests/qemuxml2xmltest.c | 3 +--
tests/virdeterministichashmock.c | 36 --------------------------------
tests/virmacmaptest.c | 2 +-
6 files changed, 4 insertions(+), 42 deletions(-)
delete mode 100644 tests/virdeterministichashmock.c
diff --git a/tests/meson.build b/tests/meson.build
index a59002c083..6984780066 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -56,7 +56,6 @@ mock_libs = [
{ 'name': 'domaincapsmock' },
{ 'name': 'shunload', 'sources': [ 'shunloadhelper.c' ]
},
{ 'name': 'vircgroupmock' },
- { 'name': 'virdeterministichashmock' },
{ 'name': 'virfilecachemock' },
{ 'name': 'virgdbusmock' },
{ 'name': 'virhostcpumock' },
diff --git a/tests/qemublocktest.c b/tests/qemublocktest.c
index c39f96716f..70dce54d0e 100644
--- a/tests/qemublocktest.c
+++ b/tests/qemublocktest.c
@@ -1385,4 +1385,4 @@ mymain(void)
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
-VIR_TEST_MAIN_PRELOAD(mymain, VIR_TEST_MOCK("virdeterministichash"))
+VIR_TEST_MAIN(mymain)
diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c
index 9231fa835a..cd52a0019a 100644
--- a/tests/qemumonitorjsontest.c
+++ b/tests/qemumonitorjsontest.c
@@ -3480,4 +3480,4 @@ mymain(void)
return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
-VIR_TEST_MAIN_PRELOAD(mymain, VIR_TEST_MOCK("virdeterministichash"))
+VIR_TEST_MAIN(mymain)
diff --git a/tests/qemuxml2xmltest.c b/tests/qemuxml2xmltest.c
index 44ac9fbce7..3e56d0fc50 100644
--- a/tests/qemuxml2xmltest.c
+++ b/tests/qemuxml2xmltest.c
@@ -1528,8 +1528,7 @@ mymain(void)
VIR_TEST_MAIN_PRELOAD(mymain,
VIR_TEST_MOCK("virpci"),
VIR_TEST_MOCK("virrandom"),
- VIR_TEST_MOCK("domaincaps"),
- VIR_TEST_MOCK("virdeterministichash"))
+ VIR_TEST_MOCK("domaincaps"))
#else
diff --git a/tests/virdeterministichashmock.c b/tests/virdeterministichashmock.c
deleted file mode 100644
index 4d0c88f600..0000000000
--- a/tests/virdeterministichashmock.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2016 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see
- * <http://www.gnu.org/licenses/>;.
- */
-
-#include <config.h>
-
-#include "util/virhashcode.h"
-
-uint32_t
-virHashCodeGen(const void *key,
- size_t len,
- uint32_t seed G_GNUC_UNUSED)
-{
- const uint8_t *k = key;
- uint32_t h = 0;
- size_t i;
-
- for (i = 0; i < len; i++)
- h += k[i];
-
- return h;
-}
diff --git a/tests/virmacmaptest.c b/tests/virmacmaptest.c
index 15ad23932e..8fd9916b95 100644
--- a/tests/virmacmaptest.c
+++ b/tests/virmacmaptest.c
@@ -225,4 +225,4 @@ mymain(void)
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
-VIR_TEST_MAIN_PRELOAD(mymain, VIR_TEST_MOCK("virdeterministichash"))
+VIR_TEST_MAIN(mymain)
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 06/12] util: hash: Add delete-safe hash iterator
'virHashForEach' historically allowed deletion of the current element as
'virHashRemoveSet' didn't exits. To prevent us from having to deepy
analyse all iterators add virHashForEachSafe which first gets a list of
elements and iterates them outside of the hash table.
This will allow replace the internals of the hash table with other
implementation which don't allow such operation.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/libvirt_private.syms | 1 +
src/util/virhash.c | 26 +++++++++++++++++++++++---
src/util/virhash.h | 1 +
3 files changed, 25 insertions(+), 3 deletions(-)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 1793b81ad9..f7b0d11ca2 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -2203,6 +2203,7 @@ virHashAtomicSteal;
virHashAtomicUpdate;
virHashEqual;
virHashForEach;
+virHashForEachSafe;
virHashForEachSorted;
virHashFree;
virHashGetItems;
diff --git a/src/util/virhash.c b/src/util/virhash.c
index f205291de9..e54052985f 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -481,7 +481,7 @@ virHashRemoveEntry(virHashTablePtr table, const char *name)
/**
- * virHashForEach, virHashForEachSorted
+ * virHashForEach, virHashForEachSorted, virHashForEachSafe
* @table: the hash table to process
* @iter: callback to process each element
* @opaque: opaque data to pass to the iterator
@@ -490,14 +490,14 @@ virHashRemoveEntry(virHashTablePtr table, const char *name)
*
* The elements are iterated in arbitrary order.
*
- * virHashForEach allows the callback to remove the current
+ * virHashForEach, virHashForEachSafe allow the callback to remove the current
* element using virHashRemoveEntry but calling other virHash* functions is
* prohibited. Note that removing the entry invalidates @key and @payload in
* the callback.
*
* virHashForEachSorted iterates the elements in order by sorted key.
*
- * virHashForEachSorted is more computationally
+ * virHashForEachSorted and virHashForEachSafe are more computationally
* expensive than virHashForEach.
*
* If @iter fails and returns a negative value, the evaluation is stopped and -1
@@ -531,6 +531,26 @@ virHashForEach(virHashTablePtr table, virHashIterator iter, void
*opaque)
}
+int
+virHashForEachSafe(virHashTablePtr table,
+ virHashIterator iter,
+ void *opaque)
+{
+ g_autofree virHashKeyValuePairPtr items = virHashGetItems(table, NULL, false);
+ size_t i;
+
+ if (!items)
+ return -1;
+
+ for (i = 0; items[i].key; i++) {
+ if (iter((void *)items[i].value, items[i].key, opaque) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+
int
virHashForEachSorted(virHashTablePtr table,
virHashIterator iter,
diff --git a/src/util/virhash.h b/src/util/virhash.h
index 1a59e9799d..b00ab0447e 100644
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -136,6 +136,7 @@ bool virHashEqual(const virHashTable *table1,
* Iterators
*/
int virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque);
+int virHashForEachSafe(virHashTablePtr table, virHashIterator iter, void *opaque);
int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void *opaque);
ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void
*opaque);
void *virHashSearch(const virHashTable *table, virHashSearcher iter,
--
2.26.2
7:41 a.m.
New subject: [PATCH v2 06/12] util: hash: Add delete-safe hash iterator
On 11/4/20 2:05 PM, Peter Krempa wrote:
'virHashForEach' historically allowed deletion of the current
element as
'virHashRemoveSet' didn't exits. To prevent us from having to deepy
s/exits/exist
Not sure if you meant 'deeply' instead of deepy (apparently deepy is a
slang for deep, according to google). Either way is fine AFAIC.
Reviewed-by: Daniel Henrique Barboza <danielhb413(a)gmail.com>
analyse all iterators add virHashForEachSafe which first gets a list
of
elements and iterates them outside of the hash table.
This will allow replace the internals of the hash table with other
implementation which don't allow such operation.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/libvirt_private.syms | 1 +
src/util/virhash.c | 26 +++++++++++++++++++++++---
src/util/virhash.h | 1 +
3 files changed, 25 insertions(+), 3 deletions(-)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 1793b81ad9..f7b0d11ca2 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -2203,6 +2203,7 @@ virHashAtomicSteal;
virHashAtomicUpdate;
virHashEqual;
virHashForEach;
+virHashForEachSafe;
virHashForEachSorted;
virHashFree;
virHashGetItems;
diff --git a/src/util/virhash.c b/src/util/virhash.c
index f205291de9..e54052985f 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -481,7 +481,7 @@ virHashRemoveEntry(virHashTablePtr table, const char *name)
/**
- * virHashForEach, virHashForEachSorted
+ * virHashForEach, virHashForEachSorted, virHashForEachSafe
* @table: the hash table to process
* @iter: callback to process each element
* @opaque: opaque data to pass to the iterator
@@ -490,14 +490,14 @@ virHashRemoveEntry(virHashTablePtr table, const char *name)
*
* The elements are iterated in arbitrary order.
*
- * virHashForEach allows the callback to remove the current
+ * virHashForEach, virHashForEachSafe allow the callback to remove the current
* element using virHashRemoveEntry but calling other virHash* functions is
* prohibited. Note that removing the entry invalidates @key and @payload in
* the callback.
*
* virHashForEachSorted iterates the elements in order by sorted key.
*
- * virHashForEachSorted is more computationally
+ * virHashForEachSorted and virHashForEachSafe are more computationally
* expensive than virHashForEach.
*
* If @iter fails and returns a negative value, the evaluation is stopped and -1
@@ -531,6 +531,26 @@ virHashForEach(virHashTablePtr table, virHashIterator iter, void
*opaque)
}
+int
+virHashForEachSafe(virHashTablePtr table,
+ virHashIterator iter,
+ void *opaque)
+{
+ g_autofree virHashKeyValuePairPtr items = virHashGetItems(table, NULL, false);
+ size_t i;
+
+ if (!items)
+ return -1;
+
+ for (i = 0; items[i].key; i++) {
+ if (iter((void *)items[i].value, items[i].key, opaque) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+
int
virHashForEachSorted(virHashTablePtr table,
virHashIterator iter,
diff --git a/src/util/virhash.h b/src/util/virhash.h
index 1a59e9799d..b00ab0447e 100644
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -136,6 +136,7 @@ bool virHashEqual(const virHashTable *table1,
* Iterators
*/
int virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque);
+int virHashForEachSafe(virHashTablePtr table, virHashIterator iter, void *opaque);
int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void *opaque);
ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void
*opaque);
void *virHashSearch(const virHashTable *table, virHashSearcher iter,
11:05 a.m.
New subject: [PATCH v2 07/12] util: hash: Use virHashForEachSafe in places which might delete the element
Convert all calls to virHashForEach where it's not obvious that the
callback is _not_ deleting the current element from the hash to
virHashForEachSafe which will be deemed safe to do such operation.
Now that no iterator used with virHashForEach deletes current element we
can document that virHashForEach must not touch the hash table in any
way.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/conf/virchrdev.c | 2 +-
src/conf/virdomainmomentobjlist.c | 2 +-
src/conf/virdomainobjlist.c | 2 +-
src/conf/virnetworkobj.c | 4 ++--
src/conf/virnwfilterbindingobjlist.c | 2 +-
src/conf/virstorageobj.c | 4 ++--
src/util/virhash.c | 4 +++-
tests/virhashtest.c | 2 +-
8 files changed, 12 insertions(+), 10 deletions(-)
diff --git a/src/conf/virchrdev.c b/src/conf/virchrdev.c
index 5e5c03d03b..f35ae6a93e 100644
--- a/src/conf/virchrdev.c
+++ b/src/conf/virchrdev.c
@@ -299,7 +299,7 @@ void virChrdevFree(virChrdevsPtr devs)
return;
virMutexLock(&devs->lock);
- virHashForEach(devs->hash, virChrdevFreeClearCallbacks, NULL);
+ virHashForEachSafe(devs->hash, virChrdevFreeClearCallbacks, NULL);
virHashFree(devs->hash);
virMutexUnlock(&devs->lock);
virMutexDestroy(&devs->lock);
diff --git a/src/conf/virdomainmomentobjlist.c b/src/conf/virdomainmomentobjlist.c
index 511bf1d415..5665819874 100644
--- a/src/conf/virdomainmomentobjlist.c
+++ b/src/conf/virdomainmomentobjlist.c
@@ -475,7 +475,7 @@ virDomainMomentForEach(virDomainMomentObjListPtr moments,
virHashIterator iter,
void *data)
{
- return virHashForEach(moments->objs, iter, data);
+ return virHashForEachSafe(moments->objs, iter, data);
}
diff --git a/src/conf/virdomainobjlist.c b/src/conf/virdomainobjlist.c
index 9c10090b32..6767fb308e 100644
--- a/src/conf/virdomainobjlist.c
+++ b/src/conf/virdomainobjlist.c
@@ -837,7 +837,7 @@ virDomainObjListForEach(virDomainObjListPtr doms,
virObjectRWLockWrite(doms);
else
virObjectRWLockRead(doms);
- virHashForEach(doms->objs, virDomainObjListHelper, &data);
+ virHashForEachSafe(doms->objs, virDomainObjListHelper, &data);
virObjectRWUnlock(doms);
return data.ret;
}
diff --git a/src/conf/virnetworkobj.c b/src/conf/virnetworkobj.c
index 8b3eb0f41c..f5e35dbca4 100644
--- a/src/conf/virnetworkobj.c
+++ b/src/conf/virnetworkobj.c
@@ -1468,7 +1468,7 @@ virNetworkObjListForEach(virNetworkObjListPtr nets,
struct virNetworkObjListForEachHelperData data = {
.callback = callback, .opaque = opaque, .ret = 0};
virObjectRWLockRead(nets);
- virHashForEach(nets->objs, virNetworkObjListForEachHelper, &data);
+ virHashForEachSafe(nets->objs, virNetworkObjListForEachHelper, &data);
virObjectRWUnlock(nets);
return data.ret;
}
@@ -1841,7 +1841,7 @@ virNetworkObjPortForEach(virNetworkObjPtr obj,
void *opaque)
{
virNetworkObjPortListForEachData data = { iter, opaque, false };
- virHashForEach(obj->ports, virNetworkObjPortForEachCallback, &data);
+ virHashForEachSafe(obj->ports, virNetworkObjPortForEachCallback, &data);
if (data.err)
return -1;
return 0;
diff --git a/src/conf/virnwfilterbindingobjlist.c b/src/conf/virnwfilterbindingobjlist.c
index 194348d062..e1b7f0622e 100644
--- a/src/conf/virnwfilterbindingobjlist.c
+++ b/src/conf/virnwfilterbindingobjlist.c
@@ -364,7 +364,7 @@ virNWFilterBindingObjListForEach(virNWFilterBindingObjListPtr
bindings,
callback, opaque, 0,
};
virObjectRWLockRead(bindings);
- virHashForEach(bindings->objs, virNWFilterBindingObjListHelper, &data);
+ virHashForEachSafe(bindings->objs, virNWFilterBindingObjListHelper, &data);
virObjectRWUnlock(bindings);
return data.ret;
}
diff --git a/src/conf/virstorageobj.c b/src/conf/virstorageobj.c
index 4aff62434f..d7a9003783 100644
--- a/src/conf/virstorageobj.c
+++ b/src/conf/virstorageobj.c
@@ -465,7 +465,7 @@ virStoragePoolObjListForEach(virStoragePoolObjListPtr pools,
struct _virStoragePoolObjListForEachData data = { .iter = iter,
.opaque = opaque };
- virHashForEach(pools->objs, virStoragePoolObjListForEachCb, &data);
+ virHashForEachSafe(pools->objs, virStoragePoolObjListForEachCb, &data);
}
@@ -753,7 +753,7 @@ virStoragePoolObjForEachVolume(virStoragePoolObjPtr obj,
.iter = iter, .opaque = opaque };
virObjectRWLockRead(obj->volumes);
- virHashForEach(obj->volumes->objsKey, virStoragePoolObjForEachVolumeCb,
+ virHashForEachSafe(obj->volumes->objsKey, virStoragePoolObjForEachVolumeCb,
&data);
virObjectRWUnlock(obj->volumes);
return 0;
diff --git a/src/util/virhash.c b/src/util/virhash.c
index e54052985f..4f8df8fae3 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -490,7 +490,9 @@ virHashRemoveEntry(virHashTablePtr table, const char *name)
*
* The elements are iterated in arbitrary order.
*
- * virHashForEach, virHashForEachSafe allow the callback to remove the current
+ * virHashForEach prohibits @iter from modifying @table
+ *
+ * virHashForEachSafe allows the callback to remove the current
* element using virHashRemoveEntry but calling other virHash* functions is
* prohibited. Note that removing the entry invalidates @key and @payload in
* the callback.
diff --git a/tests/virhashtest.c b/tests/virhashtest.c
index 93949d8b7a..4e1d41395f 100644
--- a/tests/virhashtest.c
+++ b/tests/virhashtest.c
@@ -218,7 +218,7 @@ testHashRemoveForEach(const void *data)
if (!(hash = testHashInit()))
return -1;
- if (virHashForEach(hash, (virHashIterator) info->data, hash)) {
+ if (virHashForEachSafe(hash, (virHashIterator) info->data, hash)) {
VIR_TEST_VERBOSE("\nvirHashForEach didn't go through all
entries");
goto cleanup;
}
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 08/12] util: hash: Don't use 'const' with virHashTablePtr
We didn't use it rigorously and some helpers even cast it away. Remove
const from all hash utility functions.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/conf/nwfilter_params.c | 2 +-
src/conf/nwfilter_params.h | 2 +-
src/util/virhash.c | 17 ++++++++---------
src/util/virhash.h | 12 ++++++------
4 files changed, 16 insertions(+), 17 deletions(-)
diff --git a/src/conf/nwfilter_params.c b/src/conf/nwfilter_params.c
index dd2b92c97b..33bd7437f1 100644
--- a/src/conf/nwfilter_params.c
+++ b/src/conf/nwfilter_params.c
@@ -983,7 +983,7 @@ virNWFilterVarAccessGetIntIterId(const virNWFilterVarAccess *vap)
bool
virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *varAccess,
- const virHashTable *hash)
+ virHashTablePtr hash)
{
const char *varName = virNWFilterVarAccessGetVarName(varAccess);
const char *res;
diff --git a/src/conf/nwfilter_params.h b/src/conf/nwfilter_params.h
index 4962a86864..b91f830c31 100644
--- a/src/conf/nwfilter_params.h
+++ b/src/conf/nwfilter_params.h
@@ -119,7 +119,7 @@ virNWFilterVarAccessType virNWFilterVarAccessGetType(
unsigned int virNWFilterVarAccessGetIterId(const virNWFilterVarAccess *vap);
unsigned int virNWFilterVarAccessGetIndex(const virNWFilterVarAccess *vap);
bool virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *vap,
- const virHashTable *hash);
+ virHashTablePtr hash);
typedef struct _virNWFilterVarCombIterEntry virNWFilterVarCombIterEntry;
typedef virNWFilterVarCombIterEntry *virNWFilterVarCombIterEntryPtr;
diff --git a/src/util/virhash.c b/src/util/virhash.c
index 4f8df8fae3..a5ab48dbf5 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -360,7 +360,8 @@ virHashGetEntry(const virHashTable *table,
* Returns a pointer to the userdata
*/
void *
-virHashLookup(const virHashTable *table, const char *name)
+virHashLookup(virHashTablePtr table,
+ const char *name)
{
virHashEntryPtr entry = virHashGetEntry(table, name);
@@ -381,7 +382,7 @@ virHashLookup(const virHashTable *table, const char *name)
* Returns true if the entry exists and false otherwise
*/
bool
-virHashHasEntry(const virHashTable *table,
+virHashHasEntry(virHashTablePtr table,
const char *name)
{
return !!virHashGetEntry(table, name);
@@ -434,7 +435,7 @@ virHashAtomicSteal(virHashAtomicPtr table,
* -1 in case of error
*/
ssize_t
-virHashSize(const virHashTable *table)
+virHashSize(virHashTablePtr table)
{
if (table == NULL)
return -1;
@@ -652,15 +653,13 @@ virHashRemoveAll(virHashTablePtr table)
* The elements are processed in a undefined order. Caller is
* responsible for freeing the @name.
*/
-void *virHashSearch(const virHashTable *ctable,
+void *virHashSearch(virHashTablePtr table,
virHashSearcher iter,
const void *opaque,
char **name)
{
size_t i;
- /* Cast away const for internal detection of misuse. */
- virHashTablePtr table = (virHashTablePtr)ctable;
if (table == NULL || iter == NULL)
return NULL;
@@ -739,7 +738,7 @@ virHashGetItems(virHashTablePtr table,
struct virHashEqualData
{
bool equal;
- const virHashTable *table2;
+ virHashTablePtr table2;
virHashValueComparator compar;
};
@@ -760,8 +759,8 @@ static int virHashEqualSearcher(const void *payload, const char
*name,
return 0;
}
-bool virHashEqual(const virHashTable *table1,
- const virHashTable *table2,
+bool virHashEqual(virHashTablePtr table1,
+ virHashTablePtr table2,
virHashValueComparator compar)
{
struct virHashEqualData data = {
diff --git a/src/util/virhash.h b/src/util/virhash.h
index b00ab0447e..3af4786e9b 100644
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -60,7 +60,7 @@ typedef int (*virHashSearcher) (const void *payload, const char *name,
virHashTablePtr virHashNew(virHashDataFree dataFree);
virHashAtomicPtr virHashAtomicNew(virHashDataFree dataFree);
void virHashFree(virHashTablePtr table);
-ssize_t virHashSize(const virHashTable *table);
+ssize_t virHashSize(virHashTablePtr table);
/*
* Add a new entry to the hash table.
@@ -88,8 +88,8 @@ void virHashRemoveAll(virHashTablePtr table);
/*
* Retrieve the userdata.
*/
-void *virHashLookup(const virHashTable *table, const char *name);
-bool virHashHasEntry(const virHashTable *table, const char *name);
+void *virHashLookup(virHashTablePtr table, const char *name);
+bool virHashHasEntry(virHashTablePtr table, const char *name);
/*
* Retrieve & remove the userdata.
@@ -127,8 +127,8 @@ virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table,
* of two keys.
*/
typedef int (*virHashValueComparator)(const void *value1, const void *value2);
-bool virHashEqual(const virHashTable *table1,
- const virHashTable *table2,
+bool virHashEqual(virHashTablePtr table1,
+ virHashTablePtr table2,
virHashValueComparator compar);
@@ -139,7 +139,7 @@ int virHashForEach(virHashTablePtr table, virHashIterator iter, void
*opaque);
int virHashForEachSafe(virHashTablePtr table, virHashIterator iter, void *opaque);
int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void *opaque);
ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void
*opaque);
-void *virHashSearch(const virHashTable *table, virHashSearcher iter,
+void *virHashSearch(virHashTablePtr table, virHashSearcher iter,
const void *opaque, char **name);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, virHashFree);
--
2.26.2
7:50 a.m.
New subject: [PATCH v2 08/12] util: hash: Don't use 'const' with virHashTablePtr
On 11/4/20 2:05 PM, Peter Krempa wrote:
We didn't use it rigorously and some helpers even cast it away.
Remove
const from all hash utility functions.
Unrelated question: how much do we care about standardizing a bit the
'const' usage in the code? I for one had to rely on casting to satisfy
the conditions of "const" variables, that most of time are created because
some functions requires a "const" argument.
I can drop some patches here and there when I found these instances, but
I'm not sure if we want to get rid of 'const', as you're doing here,
or we want to make sure that all function args that aren't going to be
changed must always be 'const'. I prefer slightly the second approach
but I don't mind get away with the 'const' as well.
Thanks,
DHB
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/conf/nwfilter_params.c | 2 +-
src/conf/nwfilter_params.h | 2 +-
src/util/virhash.c | 17 ++++++++---------
src/util/virhash.h | 12 ++++++------
4 files changed, 16 insertions(+), 17 deletions(-)
diff --git a/src/conf/nwfilter_params.c b/src/conf/nwfilter_params.c
index dd2b92c97b..33bd7437f1 100644
--- a/src/conf/nwfilter_params.c
+++ b/src/conf/nwfilter_params.c
@@ -983,7 +983,7 @@ virNWFilterVarAccessGetIntIterId(const virNWFilterVarAccess *vap)
bool
virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *varAccess,
- const virHashTable *hash)
+ virHashTablePtr hash)
{
const char *varName = virNWFilterVarAccessGetVarName(varAccess);
const char *res;
diff --git a/src/conf/nwfilter_params.h b/src/conf/nwfilter_params.h
index 4962a86864..b91f830c31 100644
--- a/src/conf/nwfilter_params.h
+++ b/src/conf/nwfilter_params.h
@@ -119,7 +119,7 @@ virNWFilterVarAccessType virNWFilterVarAccessGetType(
unsigned int virNWFilterVarAccessGetIterId(const virNWFilterVarAccess *vap);
unsigned int virNWFilterVarAccessGetIndex(const virNWFilterVarAccess *vap);
bool virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *vap,
- const virHashTable *hash);
+ virHashTablePtr hash);
typedef struct _virNWFilterVarCombIterEntry virNWFilterVarCombIterEntry;
typedef virNWFilterVarCombIterEntry *virNWFilterVarCombIterEntryPtr;
diff --git a/src/util/virhash.c b/src/util/virhash.c
index 4f8df8fae3..a5ab48dbf5 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -360,7 +360,8 @@ virHashGetEntry(const virHashTable *table,
* Returns a pointer to the userdata
*/
void *
-virHashLookup(const virHashTable *table, const char *name)
+virHashLookup(virHashTablePtr table,
+ const char *name)
{
virHashEntryPtr entry = virHashGetEntry(table, name);
@@ -381,7 +382,7 @@ virHashLookup(const virHashTable *table, const char *name)
* Returns true if the entry exists and false otherwise
*/
bool
-virHashHasEntry(const virHashTable *table,
+virHashHasEntry(virHashTablePtr table,
const char *name)
{
return !!virHashGetEntry(table, name);
@@ -434,7 +435,7 @@ virHashAtomicSteal(virHashAtomicPtr table,
* -1 in case of error
*/
ssize_t
-virHashSize(const virHashTable *table)
+virHashSize(virHashTablePtr table)
{
if (table == NULL)
return -1;
@@ -652,15 +653,13 @@ virHashRemoveAll(virHashTablePtr table)
* The elements are processed in a undefined order. Caller is
* responsible for freeing the @name.
*/
-void *virHashSearch(const virHashTable *ctable,
+void *virHashSearch(virHashTablePtr table,
virHashSearcher iter,
const void *opaque,
char **name)
{
size_t i;
- /* Cast away const for internal detection of misuse. */
- virHashTablePtr table = (virHashTablePtr)ctable;
if (table == NULL || iter == NULL)
return NULL;
@@ -739,7 +738,7 @@ virHashGetItems(virHashTablePtr table,
struct virHashEqualData
{
bool equal;
- const virHashTable *table2;
+ virHashTablePtr table2;
virHashValueComparator compar;
};
@@ -760,8 +759,8 @@ static int virHashEqualSearcher(const void *payload, const char
*name,
return 0;
}
-bool virHashEqual(const virHashTable *table1,
- const virHashTable *table2,
+bool virHashEqual(virHashTablePtr table1,
+ virHashTablePtr table2,
virHashValueComparator compar)
{
struct virHashEqualData data = {
diff --git a/src/util/virhash.h b/src/util/virhash.h
index b00ab0447e..3af4786e9b 100644
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -60,7 +60,7 @@ typedef int (*virHashSearcher) (const void *payload, const char *name,
virHashTablePtr virHashNew(virHashDataFree dataFree);
virHashAtomicPtr virHashAtomicNew(virHashDataFree dataFree);
void virHashFree(virHashTablePtr table);
-ssize_t virHashSize(const virHashTable *table);
+ssize_t virHashSize(virHashTablePtr table);
/*
* Add a new entry to the hash table.
@@ -88,8 +88,8 @@ void virHashRemoveAll(virHashTablePtr table);
/*
* Retrieve the userdata.
*/
-void *virHashLookup(const virHashTable *table, const char *name);
-bool virHashHasEntry(const virHashTable *table, const char *name);
+void *virHashLookup(virHashTablePtr table, const char *name);
+bool virHashHasEntry(virHashTablePtr table, const char *name);
/*
* Retrieve & remove the userdata.
@@ -127,8 +127,8 @@ virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table,
* of two keys.
*/
typedef int (*virHashValueComparator)(const void *value1, const void *value2);
-bool virHashEqual(const virHashTable *table1,
- const virHashTable *table2,
+bool virHashEqual(virHashTablePtr table1,
+ virHashTablePtr table2,
virHashValueComparator compar);
@@ -139,7 +139,7 @@ int virHashForEach(virHashTablePtr table, virHashIterator iter, void
*opaque);
int virHashForEachSafe(virHashTablePtr table, virHashIterator iter, void *opaque);
int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void *opaque);
ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void
*opaque);
-void *virHashSearch(const virHashTable *table, virHashSearcher iter,
+void *virHashSearch(virHashTablePtr table, virHashSearcher iter,
const void *opaque, char **name);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, virHashFree);
9:26 a.m.
New subject: [PATCH v2 08/12] util: hash: Don't use 'const' with virHashTablePtr
On Thu, Nov 05, 2020 at 10:50:23 -0300, Daniel Henrique Barboza wrote:
On 11/4/20 2:05 PM, Peter Krempa wrote:
> We didn't use it rigorously and some helpers even cast it away. Remove
> const from all hash utility functions.
Unrelated question: how much do we care about standardizing a bit the
'const' usage in the code? I for one had to rely on casting to satisfy
the conditions of "const" variables, that most of time are created because
some functions requires a "const" argument.
I can drop some patches here and there when I found these instances, but
I'm not sure if we want to get rid of 'const', as you're doing here,
or we want to make sure that all function args that aren't going to be
changed must always be 'const'. I prefer slightly the second approach
but I don't mind get away with the 'const' as well.
In this specific instance, this prepares for change to glibs
GHashTable. The glib APIs don't use const so we can't do much.
Additionally, it in some cases really depends on the semantics you want
to achieve (not what actually C allows you):
> diff --git a/src/util/virhash.h b/src/util/virhash.h
> index b00ab0447e..3af4786e9b 100644
> --- a/src/util/virhash.h
> +++ b/src/util/virhash.h
> @@ -60,7 +60,7 @@ typedef int (*virHashSearcher) (const void *payload, const char
*name,
> virHashTablePtr virHashNew(virHashDataFree dataFree);
> virHashAtomicPtr virHashAtomicNew(virHashDataFree dataFree);
> void virHashFree(virHashTablePtr table);
> -ssize_t virHashSize(const virHashTable *table);
> +ssize_t virHashSize(virHashTablePtr table);
For example here we really don't modify the hash table at all, so const
makes sense.
> @@ -88,8 +88,8 @@ void virHashRemoveAll(virHashTablePtr table);
> /*
> * Retrieve the userdata.
> */
> -void *virHashLookup(const virHashTable *table, const char *name);
But virHashLookup returns the pointer to the payload, which you then can
modify. So while you don't modify the hash table container, you are able
to modify the payload. So one can see that as modifying the hash table
itself.
> -bool virHashHasEntry(const virHashTable *table, const char
*name);
> +void *virHashLookup(virHashTablePtr table, const char *name);
> +bool virHashHasEntry(virHashTablePtr table, const char *name);
Here again we don't modify it ...
> @@ -127,8 +127,8 @@ virHashKeyValuePairPtr
virHashGetItems(virHashTablePtr table,
> * of two keys.
> */
> typedef int (*virHashValueComparator)(const void *value1, const void *value2);
> -bool virHashEqual(const virHashTable *table1,
> - const virHashTable *table2,
> +bool virHashEqual(virHashTablePtr table1,
> + virHashTablePtr table2,
> virHashValueComparator compar);
Same here, this is just for the glib compatibility.
> @@ -139,7 +139,7 @@ int virHashForEach(virHashTablePtr table,
virHashIterator iter, void *opaque);
> int virHashForEachSafe(virHashTablePtr table, virHashIterator iter, void
*opaque);
> int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void
*opaque);
> ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void
*opaque);
> -void *virHashSearch(const virHashTable *table, virHashSearcher iter,
> +void *virHashSearch(virHashTablePtr table, virHashSearcher iter,
> const void *opaque, char **name);
But in this case you again get the payload pointer which you can modify.
In general C's const keyword is a hint for the programmer at best, in
many cases it doesn't do what you want and specifically in case of
structs it doesn't guarantee that the internals can't be changed, so I'd
not really bother that much with being rigorous in this regards.
9:57 a.m.
New subject: [PATCH v2 08/12] util: hash: Don't use 'const' with virHashTablePtr
On 11/5/20 12:26 PM, Peter Krempa wrote:
On Thu, Nov 05, 2020 at 10:50:23 -0300, Daniel Henrique Barboza
wrote:
>
>
> On 11/4/20 2:05 PM, Peter Krempa wrote:
>> We didn't use it rigorously and some helpers even cast it away. Remove
>> const from all hash utility functions.
>
> Unrelated question: how much do we care about standardizing a bit the
> 'const' usage in the code? I for one had to rely on casting to satisfy
> the conditions of "const" variables, that most of time are created because
> some functions requires a "const" argument.
>
[...]
But in this case you again get the payload pointer which you can modify.
In general C's const keyword is a hint for the programmer at best, in
many cases it doesn't do what you want and specifically in case of
structs it doesn't guarantee that the internals can't be changed, so I'd
not really bother that much with being rigorous in this regards.
It's also easier to deal without 'const' here and there in the code. I mean,
as you said, it's more of a hint to the developer. One that comes with the
cost of adding casts here and there when needed.
Thanks for the reply. Guess I'll keep an eye for the 'const' cases I come
across from now on and see if it can be removed/simplified.
DHB
11:05 a.m.
New subject: [PATCH v2 09/12] util: hash: Reimplement virHashTable using GHashTable
Glib's hash table provides basically the same functionality as our hash
table.
In most cases the only thing that remains in the virHash* wrappers is
NULL-checks of '@table' argument as glib's hash functions don't tolerate
NULL.
In case of iterators, we adapt the existing API of iterators to glibs to
prevent having rewrite all callers at this point.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/util/virhash.c | 432 +++++++++++++--------------------------------
src/util/virhash.h | 4 +-
2 files changed, 129 insertions(+), 307 deletions(-)
diff --git a/src/util/virhash.c b/src/util/virhash.c
index a5ab48dbf5..6d03d4035f 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -21,42 +21,15 @@
#include "virerror.h"
#include "virhash.h"
-#include "viralloc.h"
#include "virlog.h"
#include "virhashcode.h"
#include "virrandom.h"
-#include "virstring.h"
#include "virobject.h"
#define VIR_FROM_THIS VIR_FROM_NONE
VIR_LOG_INIT("util.hash");
-#define MAX_HASH_LEN 8
-
-/* #define DEBUG_GROW */
-
-/*
- * A single entry in the hash table
- */
-typedef struct _virHashEntry virHashEntry;
-typedef virHashEntry *virHashEntryPtr;
-struct _virHashEntry {
- struct _virHashEntry *next;
- char *name;
- void *payload;
-};
-
-/*
- * The entire hash table
- */
-struct _virHashTable {
- virHashEntryPtr *table;
- uint32_t seed;
- size_t size;
- size_t nbElems;
- virHashDataFree dataFree;
-};
struct _virHashAtomic {
virObjectLockable parent;
@@ -76,11 +49,28 @@ static int virHashAtomicOnceInit(void)
VIR_ONCE_GLOBAL_INIT(virHashAtomic);
-static size_t
-virHashComputeKey(const virHashTable *table, const char *name)
+
+/**
+ * Our hash function uses a random seed to provide uncertainity from run to run
+ * to prevent pre-crafting of colliding hash keys.
+ */
+static uint32_t virHashTableSeed;
+
+static int virHashTableSeedOnceInit(void)
+{
+ virHashTableSeed = virRandomBits(32);
+ return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(virHashTableSeed);
+
+
+static unsigned int
+virHashTableStringKey(const void *vkey)
{
- uint32_t value = virHashCodeGen(name, strlen(name), table->seed);
- return value % table->size;
+ const char *key = vkey;
+
+ return virHashCodeGen(key, strlen(key), virHashTableSeed);
}
@@ -95,18 +85,9 @@ virHashComputeKey(const virHashTable *table, const char *name)
virHashTablePtr
virHashNew(virHashDataFree dataFree)
{
- virHashTablePtr table = NULL;
-
- table = g_new0(virHashTable, 1);
-
- table->seed = virRandomBits(32);
- table->size = 32;
- table->nbElems = 0;
- table->dataFree = dataFree;
+ ignore_value(virHashTableSeedInitialize());
- table->table = g_new0(virHashEntryPtr, table->size);
-
- return table;
+ return g_hash_table_new_full(virHashTableStringKey, g_str_equal, g_free, dataFree);
}
@@ -138,66 +119,6 @@ virHashAtomicDispose(void *obj)
}
-/**
- * virHashGrow:
- * @table: the hash table
- * @size: the new size of the hash table
- *
- * resize the hash table
- *
- * Returns 0 in case of success, -1 in case of failure
- */
-static int
-virHashGrow(virHashTablePtr table, size_t size)
-{
- size_t oldsize, i;
- virHashEntryPtr *oldtable;
-
-#ifdef DEBUG_GROW
- size_t nbElem = 0;
-#endif
-
- if (table == NULL)
- return -1;
- if (size < 8)
- return -1;
- if (size > 8 * 2048)
- return -1;
-
- oldsize = table->size;
- oldtable = table->table;
- if (oldtable == NULL)
- return -1;
-
- table->table = g_new0(virHashEntryPtr, size);
- table->size = size;
-
- for (i = 0; i < oldsize; i++) {
- virHashEntryPtr iter = oldtable[i];
- while (iter) {
- virHashEntryPtr next = iter->next;
- size_t key = virHashComputeKey(table, iter->name);
-
- iter->next = table->table[key];
- table->table[key] = iter;
-
-#ifdef DEBUG_GROW
- nbElem++;
-#endif
- iter = next;
- }
- }
-
- VIR_FREE(oldtable);
-
-#ifdef DEBUG_GROW
- VIR_DEBUG("virHashGrow : from %d to %d, %ld elems", oldsize,
- size, nbElem);
-#endif
-
- return 0;
-}
-
/**
* virHashFree:
* @table: the hash table
@@ -208,76 +129,12 @@ virHashGrow(virHashTablePtr table, size_t size)
void
virHashFree(virHashTablePtr table)
{
- size_t i;
-
if (table == NULL)
return;
- for (i = 0; i < table->size; i++) {
- virHashEntryPtr iter = table->table[i];
- while (iter) {
- virHashEntryPtr next = iter->next;
-
- if (table->dataFree)
- table->dataFree(iter->payload);
- g_free(iter->name);
- VIR_FREE(iter);
- iter = next;
- }
- }
-
- VIR_FREE(table->table);
- VIR_FREE(table);
+ g_hash_table_unref(table);
}
-static int
-virHashAddOrUpdateEntry(virHashTablePtr table, const char *name,
- void *userdata,
- bool is_update)
-{
- size_t key, len = 0;
- virHashEntryPtr entry;
- virHashEntryPtr last = NULL;
-
- if ((table == NULL) || (name == NULL))
- return -1;
-
- key = virHashComputeKey(table, name);
-
- /* Check for duplicate entry */
- for (entry = table->table[key]; entry; entry = entry->next) {
- if (STREQ(entry->name, name)) {
- if (is_update) {
- if (table->dataFree)
- table->dataFree(entry->payload);
- entry->payload = userdata;
- return 0;
- } else {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Duplicate hash table key '%s'"),
name);
- return -1;
- }
- }
- last = entry;
- len++;
- }
-
- entry = g_new0(virHashEntry, 1);
- entry->name = g_strdup(name);
- entry->payload = userdata;
-
- if (last)
- last->next = entry;
- else
- table->table[key] = entry;
-
- table->nbElems++;
-
- if (len > MAX_HASH_LEN)
- virHashGrow(table, MAX_HASH_LEN * table->size);
-
- return 0;
-}
/**
* virHashAddEntry:
@@ -293,7 +150,18 @@ virHashAddOrUpdateEntry(virHashTablePtr table, const char *name,
int
virHashAddEntry(virHashTablePtr table, const char *name, void *userdata)
{
- return virHashAddOrUpdateEntry(table, name, userdata, false);
+ if (!table || !name)
+ return -1;
+
+ if (g_hash_table_contains(table, name)) {
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Duplicate hash table key '%s'"), name);
+ return -1;
+ }
+
+ g_hash_table_insert(table, g_strdup(name), userdata);
+
+ return 0;
}
/**
@@ -312,7 +180,12 @@ int
virHashUpdateEntry(virHashTablePtr table, const char *name,
void *userdata)
{
- return virHashAddOrUpdateEntry(table, name, userdata, true);
+ if (!table || !name)
+ return -1;
+
+ g_hash_table_insert(table, g_strdup(name), userdata);
+
+ return 0;
}
int
@@ -323,33 +196,13 @@ virHashAtomicUpdate(virHashAtomicPtr table,
int ret;
virObjectLock(table);
- ret = virHashAddOrUpdateEntry(table->hash, name, userdata, true);
+ ret = virHashUpdateEntry(table->hash, name, userdata);
virObjectUnlock(table);
return ret;
}
-static virHashEntryPtr
-virHashGetEntry(const virHashTable *table,
- const char *name)
-{
- size_t key;
- virHashEntryPtr entry;
-
- if (!table || !name)
- return NULL;
-
- key = virHashComputeKey(table, name);
- for (entry = table->table[key]; entry; entry = entry->next) {
- if (STREQ(entry->name, name))
- return entry;
- }
-
- return NULL;
-}
-
-
/**
* virHashLookup:
* @table: the hash table
@@ -363,12 +216,10 @@ void *
virHashLookup(virHashTablePtr table,
const char *name)
{
- virHashEntryPtr entry = virHashGetEntry(table, name);
-
- if (!entry)
+ if (!table || !name)
return NULL;
- return entry->payload;
+ return g_hash_table_lookup(table, name);
}
@@ -385,7 +236,10 @@ bool
virHashHasEntry(virHashTablePtr table,
const char *name)
{
- return !!virHashGetEntry(table, name);
+ if (!table || !name)
+ return false;
+
+ return g_hash_table_contains(table, name);
}
@@ -401,14 +255,19 @@ virHashHasEntry(virHashTablePtr table,
*/
void *virHashSteal(virHashTablePtr table, const char *name)
{
- void *data = virHashLookup(table, name);
- if (data) {
- virHashDataFree dataFree = table->dataFree;
- table->dataFree = NULL;
- virHashRemoveEntry(table, name);
- table->dataFree = dataFree;
- }
- return data;
+ g_autofree void *orig_name = NULL;
+ void *val = NULL;
+
+ if (!table || !name)
+ return NULL;
+
+ /* we can replace this by g_hash_table_steal_extended with glib 2.58 */
+ if (!(g_hash_table_lookup_extended(table, name, &orig_name, &val)))
+ return NULL;
+
+ g_hash_table_steal(table, name);
+
+ return val;
}
void *
@@ -439,7 +298,8 @@ virHashSize(virHashTablePtr table)
{
if (table == NULL)
return -1;
- return table->nbElems;
+
+ return g_hash_table_size(table);
}
@@ -455,27 +315,14 @@ virHashSize(virHashTablePtr table)
* Returns 0 if the removal succeeded and -1 in case of error or not found.
*/
int
-virHashRemoveEntry(virHashTablePtr table, const char *name)
+virHashRemoveEntry(virHashTablePtr table,
+ const char *name)
{
- virHashEntryPtr entry;
- virHashEntryPtr *nextptr;
-
- if (table == NULL || name == NULL)
+ if (!table || !name)
return -1;
- nextptr = table->table + virHashComputeKey(table, name);
- for (entry = *nextptr; entry; entry = entry->next) {
- if (STREQ(entry->name, name)) {
- if (table->dataFree)
- table->dataFree(entry->payload);
- g_free(entry->name);
- *nextptr = entry->next;
- VIR_FREE(entry);
- table->nbElems--;
- return 0;
- }
- nextptr = &entry->next;
- }
+ if (g_hash_table_remove(table, name))
+ return 0;
return -1;
}
@@ -511,23 +358,18 @@ virHashRemoveEntry(virHashTablePtr table, const char *name)
int
virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque)
{
- size_t i;
- int ret = -1;
+ GHashTableIter htitr;
+ void *key;
+ void *value;
- if (table == NULL || iter == NULL)
+ if (!table || !iter)
return -1;
- for (i = 0; i < table->size; i++) {
- virHashEntryPtr entry = table->table[i];
- while (entry) {
- virHashEntryPtr next = entry->next;
- ret = iter(entry->payload, entry->name, opaque);
+ g_hash_table_iter_init(&htitr, table);
- if (ret < 0)
- return ret;
-
- entry = next;
- }
+ while (g_hash_table_iter_next(&htitr, &key, &value)) {
+ if (iter(value, key, opaque) < 0)
+ return -1;
}
return 0;
@@ -574,6 +416,24 @@ virHashForEachSorted(virHashTablePtr table,
}
+struct virHashSearcherWrapFuncData {
+ virHashSearcher iter;
+ const void *opaque;
+ const char *name;
+};
+
+static gboolean
+virHashSearcherWrapFunc(gpointer key,
+ gpointer value,
+ gpointer opaque)
+{
+ struct virHashSearcherWrapFuncData *data = opaque;
+
+ data->name = key;
+
+ return !!(data->iter(value, key, data->opaque));
+}
+
/**
* virHashRemoveSet
* @table: the hash table to process
@@ -592,39 +452,12 @@ virHashRemoveSet(virHashTablePtr table,
virHashSearcher iter,
const void *opaque)
{
- size_t i, count = 0;
+ struct virHashSearcherWrapFuncData data = { iter, opaque, NULL };
if (table == NULL || iter == NULL)
return -1;
- for (i = 0; i < table->size; i++) {
- virHashEntryPtr *nextptr = table->table + i;
-
- while (*nextptr) {
- virHashEntryPtr entry = *nextptr;
- if (!iter(entry->payload, entry->name, opaque)) {
- nextptr = &entry->next;
- } else {
- count++;
- if (table->dataFree)
- table->dataFree(entry->payload);
- g_free(entry->name);
- *nextptr = entry->next;
- VIR_FREE(entry);
- table->nbElems--;
- }
- }
- }
-
- return count;
-}
-
-static int
-_virHashRemoveAllIter(const void *payload G_GNUC_UNUSED,
- const char *name G_GNUC_UNUSED,
- const void *opaque G_GNUC_UNUSED)
-{
- return 1;
+ return g_hash_table_foreach_remove(table, virHashSearcherWrapFunc, &data);
}
/**
@@ -637,7 +470,10 @@ _virHashRemoveAllIter(const void *payload G_GNUC_UNUSED,
void
virHashRemoveAll(virHashTablePtr table)
{
- virHashRemoveSet(table, _virHashRemoveAllIter, NULL);
+ if (!table)
+ return;
+
+ g_hash_table_remove_all(table);
}
/**
@@ -658,45 +494,19 @@ void *virHashSearch(virHashTablePtr table,
const void *opaque,
char **name)
{
- size_t i;
-
+ struct virHashSearcherWrapFuncData data = { iter, opaque, NULL };
+ void *ret;
- if (table == NULL || iter == NULL)
+ if (!table || !iter)
return NULL;
- for (i = 0; i < table->size; i++) {
- virHashEntryPtr entry;
- for (entry = table->table[i]; entry; entry = entry->next) {
- if (iter(entry->payload, entry->name, opaque)) {
- if (name)
- *name = g_strdup(entry->name);
- return entry->payload;
- }
- }
- }
-
- return NULL;
-}
-
-
-struct virHashGetItemsIteratorData {
- virHashKeyValuePair *items;
- size_t i;
-};
-
-
-static int
-virHashGetItemsIterator(void *payload,
- const char *key,
- void *opaque)
-{
- struct virHashGetItemsIteratorData *data = opaque;
+ if (!(ret = g_hash_table_find(table, virHashSearcherWrapFunc, &data)))
+ return NULL;
- data->items[data->i].key = key;
- data->items[data->i].value = payload;
+ if (name)
+ *name = g_strdup(data.name);
- data->i++;
- return 0;
+ return ret;
}
@@ -716,22 +526,34 @@ virHashGetItems(virHashTablePtr table,
size_t *nitems,
bool sortKeys)
{
+ virHashKeyValuePair *items;
size_t dummy;
- struct virHashGetItemsIteratorData data = { .items = NULL, .i = 0 };
+ GHashTableIter htitr;
+ void *key;
+ void *value;
+ size_t i = 0;
if (!nitems)
nitems = &dummy;
- *nitems = virHashSize(table);
+ if (!table)
+ return NULL;
+
+ *nitems = g_hash_table_size(table);
+ items = g_new0(virHashKeyValuePair, *nitems + 1);
- data.items = g_new0(virHashKeyValuePair, *nitems + 1);
+ g_hash_table_iter_init(&htitr, table);
- virHashForEach(table, virHashGetItemsIterator, &data);
+ while (g_hash_table_iter_next(&htitr, &key, &value)) {
+ items[i].key = key;
+ items[i].value = value;
+ i++;
+ }
if (sortKeys)
- qsort(data.items, *nitems, sizeof(* data.items), virHashGetItemsKeySorter);
+ qsort(items, *nitems, sizeof(*items), virHashGetItemsKeySorter);
- return data.items;
+ return items;
}
diff --git a/src/util/virhash.h b/src/util/virhash.h
index 3af4786e9b..70f74dbc5f 100644
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -12,7 +12,7 @@
/*
* The hash table.
*/
-typedef struct _virHashTable virHashTable;
+typedef GHashTable virHashTable;
typedef virHashTable *virHashTablePtr;
typedef struct _virHashAtomic virHashAtomic;
@@ -142,4 +142,4 @@ ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter,
const void
void *virHashSearch(virHashTablePtr table, virHashSearcher iter,
const void *opaque, char **name);
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, virHashFree);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, g_hash_table_unref);
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 10/12] util: hash: Retire 'virHashTable' in favor of 'GHashTable'
Don't hide our use of GHashTable behind our typedef. This will also
promote the use of glibs hash function directly.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/conf/backup_conf.c | 2 +-
src/conf/domain_addr.h | 2 +-
src/conf/domain_conf.c | 12 +++---
src/conf/domain_conf.h | 2 +-
src/conf/nwfilter_conf.h | 2 +-
src/conf/nwfilter_ipaddrmap.c | 2 +-
src/conf/nwfilter_params.c | 24 +++++------
src/conf/nwfilter_params.h | 18 ++++----
src/conf/snapshot_conf.c | 2 +-
src/conf/virchrdev.c | 2 +-
src/conf/virdomainmomentobjlist.c | 2 +-
src/conf/virdomainobjlist.c | 4 +-
src/conf/virinterfaceobj.c | 2 +-
src/conf/virnetworkobj.c | 4 +-
src/conf/virnodedeviceobj.c | 2 +-
src/conf/virnwfilterbindingdef.h | 2 +-
src/conf/virnwfilterbindingobjlist.c | 2 +-
src/conf/virsecretobj.c | 2 +-
src/conf/virstorageobj.c | 10 ++---
src/hyperv/hyperv_driver.c | 4 +-
src/hyperv/hyperv_wmi.c | 16 ++++----
src/hyperv/hyperv_wmi.h | 12 +++---
src/hypervisor/virclosecallbacks.c | 2 +-
src/libxl/libxl_logger.c | 2 +-
src/locking/lock_daemon.c | 2 +-
src/nwfilter/nwfilter_dhcpsnoop.c | 6 +--
src/nwfilter/nwfilter_ebiptables_driver.c | 6 +--
src/nwfilter/nwfilter_gentech_driver.c | 36 ++++++++--------
src/nwfilter/nwfilter_gentech_driver.h | 2 +-
src/nwfilter/nwfilter_learnipaddr.c | 4 +-
src/nwfilter/nwfilter_tech_driver.h | 2 +-
src/qemu/qemu_agent.c | 4 +-
src/qemu/qemu_backup.c | 14 +++----
src/qemu/qemu_backup.h | 2 +-
src/qemu/qemu_block.c | 42 +++++++++----------
src/qemu/qemu_block.h | 18 ++++----
src/qemu/qemu_blockjob.c | 6 +--
src/qemu/qemu_capabilities.c | 8 ++--
src/qemu/qemu_checkpoint.c | 6 +--
src/qemu/qemu_checkpoint.h | 2 +-
src/qemu/qemu_conf.c | 4 +-
src/qemu/qemu_conf.h | 2 +-
src/qemu/qemu_domain.c | 2 +-
src/qemu/qemu_domain.h | 2 +-
src/qemu/qemu_driver.c | 24 +++++------
src/qemu/qemu_interop_config.c | 4 +-
src/qemu/qemu_migration.c | 2 +-
src/qemu/qemu_migration_cookie.c | 2 +-
src/qemu/qemu_monitor.c | 28 ++++++-------
src/qemu/qemu_monitor.h | 20 ++++-----
src/qemu/qemu_monitor_json.c | 50 +++++++++++------------
src/qemu/qemu_monitor_json.h | 22 +++++-----
src/qemu/qemu_process.c | 18 ++++----
src/qemu/qemu_qapi.c | 14 +++----
src/qemu/qemu_qapi.h | 6 +--
src/qemu/qemu_snapshot.c | 16 ++++----
src/rpc/virnetdaemon.c | 2 +-
src/security/security_selinux.c | 2 +-
src/util/virfilecache.c | 2 +-
src/util/virhash.c | 42 +++++++++----------
src/util/virhash.h | 44 ++++++++------------
src/util/viriptables.c | 4 +-
src/util/virlockspace.c | 2 +-
src/util/virmacmap.c | 2 +-
src/util/virstoragefile.c | 8 ++--
src/util/virsystemd.c | 2 +-
tests/nwfilterxml2firewalltest.c | 24 +++++------
tests/qemublocktest.c | 24 +++++------
tests/qemuhotplugtest.c | 6 +--
tests/qemumigparamstest.c | 4 +-
tests/qemumonitorjsontest.c | 26 ++++++------
tests/qemumonitortestutils.c | 6 +--
tests/qemumonitortestutils.h | 4 +-
tests/qemusecuritymock.c | 4 +-
tests/qemuxml2argvtest.c | 4 +-
tests/qemuxml2xmltest.c | 2 +-
tests/testutilsqemu.c | 6 +--
tests/testutilsqemu.h | 4 +-
tests/testutilsqemuschema.c | 10 ++---
tests/testutilsqemuschema.h | 8 ++--
tests/virhashtest.c | 31 +++++++-------
81 files changed, 389 insertions(+), 394 deletions(-)
diff --git a/src/conf/backup_conf.c b/src/conf/backup_conf.c
index 5c475239ad..ea812cc432 100644
--- a/src/conf/backup_conf.c
+++ b/src/conf/backup_conf.c
@@ -519,7 +519,7 @@ virDomainBackupAlignDisks(virDomainBackupDefPtr def,
virDomainDefPtr dom,
const char *suffix)
{
- g_autoptr(virHashTable) disks = virHashNew(NULL);
+ g_autoptr(GHashTable) disks = virHashNew(NULL);
size_t i;
int ndisks;
bool backup_all = false;
diff --git a/src/conf/domain_addr.h b/src/conf/domain_addr.h
index 77dd091fd3..4fbc1d7f22 100644
--- a/src/conf/domain_addr.h
+++ b/src/conf/domain_addr.h
@@ -196,7 +196,7 @@ void virDomainPCIAddressSetAllMulti(virDomainDefPtr def)
ATTRIBUTE_NONNULL(1);
struct _virDomainCCWAddressSet {
- virHashTablePtr defined;
+ GHashTable *defined;
virDomainDeviceCCWAddress next;
};
typedef struct _virDomainCCWAddressSet virDomainCCWAddressSet;
diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index b47f43afd9..58d7d4e18a 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -5785,7 +5785,7 @@ virDomainDefCollectBootOrder(virDomainDefPtr def G_GNUC_UNUSED,
virDomainDeviceInfoPtr info,
void *data)
{
- virHashTablePtr bootHash = data;
+ GHashTable *bootHash = data;
g_autofree char *order = NULL;
if (info->bootIndex == 0)
@@ -5818,7 +5818,7 @@ virDomainDefCollectBootOrder(virDomainDefPtr def G_GNUC_UNUSED,
static int
virDomainDefBootOrderPostParse(virDomainDefPtr def)
{
- virHashTablePtr bootHash = NULL;
+ GHashTable *bootHash = NULL;
int ret = -1;
if (!(bootHash = virHashNew(NULL)))
@@ -6862,7 +6862,7 @@ virDomainDeviceDefValidateInternal(const virDomainDeviceDef *dev,
struct virDomainDefValidateAliasesData {
- virHashTablePtr aliases;
+ GHashTable *aliases;
};
@@ -6921,7 +6921,7 @@ virDomainDeviceDefValidateAliasesIterator(virDomainDefPtr def,
*/
static int
virDomainDefValidateAliases(const virDomainDef *def,
- virHashTablePtr *aliases)
+ GHashTable **aliases)
{
struct virDomainDefValidateAliasesData data;
int ret = -1;
@@ -6950,7 +6950,7 @@ static int
virDomainDeviceValidateAliasImpl(const virDomainDef *def,
virDomainDeviceDefPtr dev)
{
- virHashTablePtr aliases = NULL;
+ GHashTable *aliases = NULL;
virDomainDeviceInfoPtr info = virDomainDeviceGetInfo(dev);
int ret = -1;
@@ -11961,7 +11961,7 @@ virDomainNetDefParseXML(virDomainXMLOptionPtr xmlopt,
virDomainHostdevDefPtr hostdev;
xmlNodePtr cur;
xmlNodePtr tmpNode;
- virHashTablePtr filterparams = NULL;
+ GHashTable *filterparams = NULL;
virDomainActualNetDefPtr actual = NULL;
VIR_XPATH_NODE_AUTORESTORE(ctxt)
virDomainChrSourceReconnectDef reconnect = {0};
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index 170fc73af9..bbae7ffc1e 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -1091,7 +1091,7 @@ struct _virDomainNetDef {
virNetDevIPInfo guestIP;
virDomainDeviceInfo info;
char *filter;
- virHashTablePtr filterparams;
+ GHashTable *filterparams;
virNetDevBandwidthPtr bandwidth;
virNetDevVlan vlan;
int trustGuestRxFilters; /* enum virTristateBool */
diff --git a/src/conf/nwfilter_conf.h b/src/conf/nwfilter_conf.h
index 13db58e380..13c5723779 100644
--- a/src/conf/nwfilter_conf.h
+++ b/src/conf/nwfilter_conf.h
@@ -500,7 +500,7 @@ typedef struct _virNWFilterIncludeDef virNWFilterIncludeDef;
typedef virNWFilterIncludeDef *virNWFilterIncludeDefPtr;
struct _virNWFilterIncludeDef {
char *filterref;
- virHashTablePtr params;
+ GHashTable *params;
};
diff --git a/src/conf/nwfilter_ipaddrmap.c b/src/conf/nwfilter_ipaddrmap.c
index 487e7f22bd..02f2cabefc 100644
--- a/src/conf/nwfilter_ipaddrmap.c
+++ b/src/conf/nwfilter_ipaddrmap.c
@@ -33,7 +33,7 @@
#define VIR_FROM_THIS VIR_FROM_NWFILTER
static virMutex ipAddressMapLock = VIR_MUTEX_INITIALIZER;
-static virHashTablePtr ipAddressMap;
+static GHashTable *ipAddressMap;
/* Add an IP address to the list of IP addresses an interface is
diff --git a/src/conf/nwfilter_params.c b/src/conf/nwfilter_params.c
index 33bd7437f1..ae819024ad 100644
--- a/src/conf/nwfilter_params.c
+++ b/src/conf/nwfilter_params.c
@@ -330,7 +330,7 @@ virNWFilterVarCombIterEntryInit(virNWFilterVarCombIterEntryPtr cie,
static int
virNWFilterVarCombIterAddVariable(virNWFilterVarCombIterEntryPtr cie,
- virHashTablePtr hash,
+ GHashTable *hash,
const virNWFilterVarAccess *varAccess)
{
virNWFilterVarValuePtr varValue;
@@ -397,7 +397,7 @@ virNWFilterVarCombIterAddVariable(virNWFilterVarCombIterEntryPtr cie,
*/
static bool
virNWFilterVarCombIterEntryAreUniqueEntries(virNWFilterVarCombIterEntryPtr cie,
- virHashTablePtr hash)
+ GHashTable *hash)
{
size_t i, j;
virNWFilterVarValuePtr varValue, tmp;
@@ -455,7 +455,7 @@
virNWFilterVarCombIterEntryAreUniqueEntries(virNWFilterVarCombIterEntryPtr cie,
* be created.
*/
virNWFilterVarCombIterPtr
-virNWFilterVarCombIterCreate(virHashTablePtr hash,
+virNWFilterVarCombIterCreate(GHashTable *hash,
virNWFilterVarAccessPtr *varAccess,
size_t nVarAccess)
{
@@ -614,7 +614,7 @@ virNWFilterVarValueHashFree(void *payload)
struct addToTableStruct {
- virHashTablePtr target;
+ GHashTable *target;
int errOccurred;
};
@@ -644,8 +644,8 @@ addToTable(void *payload, const char *name, void *data)
int
-virNWFilterHashTablePutAll(virHashTablePtr src,
- virHashTablePtr dest)
+virNWFilterHashTablePutAll(GHashTable *src,
+ GHashTable *dest)
{
struct addToTableStruct atts = {
.target = dest,
@@ -671,8 +671,8 @@ virNWFilterVarValueCompare(const void *a, const void *b)
}
bool
-virNWFilterHashTableEqual(virHashTablePtr a,
- virHashTablePtr b)
+virNWFilterHashTableEqual(GHashTable *a,
+ GHashTable *b)
{
return virHashEqual(a, b, virNWFilterVarValueCompare);
}
@@ -696,13 +696,13 @@ virNWFilterParseVarValue(const char *val)
return virNWFilterVarValueCreateSimpleCopyValue(val);
}
-virHashTablePtr
+GHashTable *
virNWFilterParseParamAttributes(xmlNodePtr cur)
{
char *nam, *val;
virNWFilterVarValuePtr value;
- virHashTablePtr table = virHashNew(virNWFilterVarValueHashFree);
+ GHashTable *table = virHashNew(virNWFilterVarValueHashFree);
if (!table)
return NULL;
@@ -757,7 +757,7 @@ virNWFilterParseParamAttributes(xmlNodePtr cur)
int
virNWFilterFormatParamAttributes(virBufferPtr buf,
- virHashTablePtr table,
+ GHashTable *table,
const char *filterref)
{
virHashKeyValuePairPtr items;
@@ -983,7 +983,7 @@ virNWFilterVarAccessGetIntIterId(const virNWFilterVarAccess *vap)
bool
virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *varAccess,
- virHashTablePtr hash)
+ GHashTable *hash)
{
const char *varName = virNWFilterVarAccessGetVarName(varAccess);
const char *res;
diff --git a/src/conf/nwfilter_params.h b/src/conf/nwfilter_params.h
index b91f830c31..05a6a43399 100644
--- a/src/conf/nwfilter_params.h
+++ b/src/conf/nwfilter_params.h
@@ -63,15 +63,15 @@ int virNWFilterVarValueAddValue(virNWFilterVarValuePtr val, char
*value);
int virNWFilterVarValueAddValueCopy(virNWFilterVarValuePtr val, const char *value);
int virNWFilterVarValueDelValue(virNWFilterVarValuePtr val, const char *value);
-virHashTablePtr virNWFilterParseParamAttributes(xmlNodePtr cur);
+GHashTable *virNWFilterParseParamAttributes(xmlNodePtr cur);
int virNWFilterFormatParamAttributes(virBufferPtr buf,
- virHashTablePtr table,
+ GHashTable *table,
const char *filterref);
-int virNWFilterHashTablePutAll(virHashTablePtr src,
- virHashTablePtr dest);
-bool virNWFilterHashTableEqual(virHashTablePtr a,
- virHashTablePtr b);
+int virNWFilterHashTablePutAll(GHashTable *src,
+ GHashTable *dest);
+bool virNWFilterHashTableEqual(GHashTable *a,
+ GHashTable *b);
#define VALID_VARNAME \
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
@@ -119,7 +119,7 @@ virNWFilterVarAccessType virNWFilterVarAccessGetType(
unsigned int virNWFilterVarAccessGetIterId(const virNWFilterVarAccess *vap);
unsigned int virNWFilterVarAccessGetIndex(const virNWFilterVarAccess *vap);
bool virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *vap,
- virHashTablePtr hash);
+ GHashTable *hash);
typedef struct _virNWFilterVarCombIterEntry virNWFilterVarCombIterEntry;
typedef virNWFilterVarCombIterEntry *virNWFilterVarCombIterEntryPtr;
@@ -135,12 +135,12 @@ struct _virNWFilterVarCombIterEntry {
typedef struct _virNWFilterVarCombIter virNWFilterVarCombIter;
typedef virNWFilterVarCombIter *virNWFilterVarCombIterPtr;
struct _virNWFilterVarCombIter {
- virHashTablePtr hashTable;
+ GHashTable *hashTable;
size_t nIter;
virNWFilterVarCombIterEntry iter[0];
};
virNWFilterVarCombIterPtr virNWFilterVarCombIterCreate(
- virHashTablePtr hash,
+ GHashTable *hash,
virNWFilterVarAccessPtr *vars,
size_t nVars);
diff --git a/src/conf/snapshot_conf.c b/src/conf/snapshot_conf.c
index 31cce15d53..8ef9708c72 100644
--- a/src/conf/snapshot_conf.c
+++ b/src/conf/snapshot_conf.c
@@ -640,7 +640,7 @@ virDomainSnapshotAlignDisks(virDomainSnapshotDefPtr snapdef,
bool require_match)
{
virDomainDefPtr domdef = snapdef->parent.dom;
- g_autoptr(virHashTable) map = virHashNew(NULL);
+ g_autoptr(GHashTable) map = virHashNew(NULL);
g_autofree virDomainSnapshotDiskDefPtr olddisks = NULL;
size_t i;
diff --git a/src/conf/virchrdev.c b/src/conf/virchrdev.c
index f35ae6a93e..d356a1babf 100644
--- a/src/conf/virchrdev.c
+++ b/src/conf/virchrdev.c
@@ -45,7 +45,7 @@ VIR_LOG_INIT("conf.chrdev");
* open in a given domain */
struct _virChrdevs {
virMutex lock;
- virHashTablePtr hash;
+ GHashTable *hash;
};
typedef struct _virChrdevStreamInfo virChrdevStreamInfo;
diff --git a/src/conf/virdomainmomentobjlist.c b/src/conf/virdomainmomentobjlist.c
index 5665819874..999f4a4152 100644
--- a/src/conf/virdomainmomentobjlist.c
+++ b/src/conf/virdomainmomentobjlist.c
@@ -42,7 +42,7 @@ VIR_LOG_INIT("conf.virdomainmomentobjlist");
struct _virDomainMomentObjList {
/* name string -> virDomainMomentObj mapping
* for O(1), lockless lookup-by-name */
- virHashTable *objs;
+ GHashTable *objs;
virDomainMomentObj metaroot; /* Special parent of all root moments */
virDomainMomentObjPtr current; /* The current moment, if any */
diff --git a/src/conf/virdomainobjlist.c b/src/conf/virdomainobjlist.c
index 6767fb308e..2521cd56c2 100644
--- a/src/conf/virdomainobjlist.c
+++ b/src/conf/virdomainobjlist.c
@@ -47,11 +47,11 @@ struct _virDomainObjList {
/* uuid string -> virDomainObj mapping
* for O(1), lockless lookup-by-uuid */
- virHashTable *objs;
+ GHashTable *objs;
/* name -> virDomainObj mapping for O(1),
* lockless lookup-by-name */
- virHashTable *objsName;
+ GHashTable *objsName;
};
diff --git a/src/conf/virinterfaceobj.c b/src/conf/virinterfaceobj.c
index faf047dc5f..00180cd36e 100644
--- a/src/conf/virinterfaceobj.c
+++ b/src/conf/virinterfaceobj.c
@@ -45,7 +45,7 @@ struct _virInterfaceObjList {
/* name string -> virInterfaceObj mapping
* for O(1), lockless lookup-by-name */
- virHashTable *objsName;
+ GHashTable *objsName;
};
/* virInterfaceObj manipulation */
diff --git a/src/conf/virnetworkobj.c b/src/conf/virnetworkobj.c
index f5e35dbca4..1b29d7cc64 100644
--- a/src/conf/virnetworkobj.c
+++ b/src/conf/virnetworkobj.c
@@ -59,13 +59,13 @@ struct _virNetworkObj {
/* Immutable pointer, self locking APIs */
virMacMapPtr macmap;
- virHashTablePtr ports; /* uuid -> virNetworkPortDefPtr */
+ GHashTable *ports; /* uuid -> virNetworkPortDefPtr */
};
struct _virNetworkObjList {
virObjectRWLockable parent;
- virHashTablePtr objs;
+ GHashTable *objs;
};
static virClassPtr virNetworkObjClass;
diff --git a/src/conf/virnodedeviceobj.c b/src/conf/virnodedeviceobj.c
index ad3726ba51..037a938e88 100644
--- a/src/conf/virnodedeviceobj.c
+++ b/src/conf/virnodedeviceobj.c
@@ -46,7 +46,7 @@ struct _virNodeDeviceObjList {
/* name string -> virNodeDeviceObj mapping
* for O(1), lockless lookup-by-name */
- virHashTable *objs;
+ GHashTable *objs;
};
diff --git a/src/conf/virnwfilterbindingdef.h b/src/conf/virnwfilterbindingdef.h
index 2b83d5bd21..ef4f9d7e7e 100644
--- a/src/conf/virnwfilterbindingdef.h
+++ b/src/conf/virnwfilterbindingdef.h
@@ -37,7 +37,7 @@ struct _virNWFilterBindingDef {
char *linkdevname;
virMacAddr mac;
char *filter;
- virHashTablePtr filterparams;
+ GHashTable *filterparams;
};
diff --git a/src/conf/virnwfilterbindingobjlist.c b/src/conf/virnwfilterbindingobjlist.c
index e1b7f0622e..7472c95bd4 100644
--- a/src/conf/virnwfilterbindingobjlist.c
+++ b/src/conf/virnwfilterbindingobjlist.c
@@ -40,7 +40,7 @@ struct _virNWFilterBindingObjList {
/* port dev name -> virNWFilterBindingObj mapping
* for O(1), lockless lookup-by-port dev */
- virHashTable *objs;
+ GHashTable *objs;
};
diff --git a/src/conf/virsecretobj.c b/src/conf/virsecretobj.c
index fda3702415..a1b750fb05 100644
--- a/src/conf/virsecretobj.c
+++ b/src/conf/virsecretobj.c
@@ -55,7 +55,7 @@ struct _virSecretObjList {
/* uuid string -> virSecretObj mapping
* for O(1), lockless lookup-by-uuid */
- virHashTable *objs;
+ GHashTable *objs;
};
struct virSecretSearchData {
diff --git a/src/conf/virstorageobj.c b/src/conf/virstorageobj.c
index d7a9003783..9fe8b3f28e 100644
--- a/src/conf/virstorageobj.c
+++ b/src/conf/virstorageobj.c
@@ -69,15 +69,15 @@ struct _virStorageVolObjList {
/* key string -> virStorageVolObj mapping
* for (1), lockless lookup-by-key */
- virHashTable *objsKey;
+ GHashTable *objsKey;
/* name string -> virStorageVolObj mapping
* for (1), lockless lookup-by-name */
- virHashTable *objsName;
+ GHashTable *objsName;
/* path string -> virStorageVolObj mapping
* for (1), lockless lookup-by-path */
- virHashTable *objsPath;
+ GHashTable *objsPath;
};
struct _virStoragePoolObj {
@@ -101,11 +101,11 @@ struct _virStoragePoolObjList {
/* uuid string -> virStoragePoolObj mapping
* for (1), lockless lookup-by-uuid */
- virHashTable *objs;
+ GHashTable *objs;
/* name string -> virStoragePoolObj mapping
* for (1), lockless lookup-by-name */
- virHashTable *objsName;
+ GHashTable *objsName;
};
diff --git a/src/hyperv/hyperv_driver.c b/src/hyperv/hyperv_driver.c
index 007210f824..4e24cd37aa 100644
--- a/src/hyperv/hyperv_driver.c
+++ b/src/hyperv/hyperv_driver.c
@@ -1300,7 +1300,7 @@ hypervDomainSetAutostart(virDomainPtr domain, int autostart)
Msvm_VirtualSystemSettingData *vssd = NULL;
g_autoptr(hypervInvokeParamsList) params = NULL;
g_auto(virBuffer) eprQuery = VIR_BUFFER_INITIALIZER;
- g_autoptr(virHashTable) autostartParam = NULL;
+ g_autoptr(GHashTable) autostartParam = NULL;
const char *methodName = NULL;
hypervWmiClassInfoListPtr embeddedParamClass = NULL;
const char *enabledValue = NULL, *disabledValue = NULL;
@@ -1806,7 +1806,7 @@ hypervDomainSetMemoryFlags(virDomainPtr domain, unsigned long
memory,
Msvm_VirtualSystemSettingData *vssd = NULL;
Msvm_MemorySettingData *memsd = NULL;
g_auto(virBuffer) eprQuery = VIR_BUFFER_INITIALIZER;
- g_autoptr(virHashTable) memResource = NULL;
+ g_autoptr(GHashTable) memResource = NULL;
virCheckFlags(0, -1);
diff --git a/src/hyperv/hyperv_wmi.c b/src/hyperv/hyperv_wmi.c
index 7a66e4810e..509a66da74 100644
--- a/src/hyperv/hyperv_wmi.c
+++ b/src/hyperv/hyperv_wmi.c
@@ -312,18 +312,18 @@ hypervAddEprParam(hypervInvokeParamsListPtr params, const char
*name,
* @priv: hypervPrivate object associated with the connection
* @info: WmiInfo of the object type to serialize
*
- * Instantiates a virHashTable pre-filled with all the properties pre-added
+ * Instantiates a GHashTable pre-filled with all the properties pre-added
* a key/value pairs set to NULL. The user then sets only those properties that
* they wish to serialize, and passes the table via hypervAddEmbeddedParam.
*
- * Returns a pointer to the virHashTable on success, otherwise NULL.
+ * Returns a pointer to the GHashTable on success, otherwise NULL.
*/
-virHashTablePtr
+GHashTable *
hypervCreateEmbeddedParam(hypervPrivate *priv, hypervWmiClassInfoListPtr info)
{
size_t i;
size_t count;
- g_autoptr(virHashTable) table = NULL;
+ g_autoptr(GHashTable) table = NULL;
XmlSerializerInfo *typeinfo = NULL;
hypervWmiClassInfoPtr classInfo = NULL;
@@ -366,7 +366,7 @@ hypervCreateEmbeddedParam(hypervPrivate *priv,
hypervWmiClassInfoListPtr info)
* -1 otherwise.
*/
int
-hypervSetEmbeddedProperty(virHashTablePtr table,
+hypervSetEmbeddedProperty(GHashTable *table,
const char *name,
const char *value)
{
@@ -382,7 +382,7 @@ hypervSetEmbeddedProperty(virHashTablePtr table,
* @table: pointer to table of properties to add
* @info: WmiInfo of the object to serialize
*
- * Add a virHashTable containing object properties as an embedded param to
+ * Add a GHashTable containing object properties as an embedded param to
* an invocation list.
*
* Upon successfull return the @table is consumed and the pointer is cleared out.
@@ -393,7 +393,7 @@ int
hypervAddEmbeddedParam(hypervInvokeParamsListPtr params,
hypervPrivate *priv,
const char *name,
- virHashTablePtr *table,
+ GHashTable **table,
hypervWmiClassInfoListPtr info)
{
hypervParamPtr p = NULL;
@@ -424,7 +424,7 @@ hypervAddEmbeddedParam(hypervInvokeParamsListPtr params,
* Free the embedded param hash table.
*/
void
-hypervFreeEmbeddedParam(virHashTablePtr p)
+hypervFreeEmbeddedParam(GHashTable *p)
{
virHashFree(p);
}
diff --git a/src/hyperv/hyperv_wmi.h b/src/hyperv/hyperv_wmi.h
index 5c5597e27b..08b6e2c4af 100644
--- a/src/hyperv/hyperv_wmi.h
+++ b/src/hyperv/hyperv_wmi.h
@@ -102,7 +102,7 @@ typedef struct _hypervEprParam hypervEprParam;
struct _hypervEmbeddedParam {
const char *name;
- virHashTablePtr table;
+ GHashTable *table;
hypervWmiClassInfoPtr info; /* info of the object this param represents */
};
typedef struct _hypervEmbeddedParam hypervEmbeddedParam;
@@ -146,20 +146,20 @@ int hypervAddEprParam(hypervInvokeParamsListPtr params, const char
*name,
hypervPrivate *priv, virBufferPtr query,
hypervWmiClassInfoListPtr eprInfo);
-virHashTablePtr hypervCreateEmbeddedParam(hypervPrivate *priv,
- hypervWmiClassInfoListPtr info);
+GHashTable *hypervCreateEmbeddedParam(hypervPrivate *priv,
+ hypervWmiClassInfoListPtr info);
-int hypervSetEmbeddedProperty(virHashTablePtr table,
+int hypervSetEmbeddedProperty(GHashTable *table,
const char *name,
const char *value);
int hypervAddEmbeddedParam(hypervInvokeParamsListPtr params,
hypervPrivate *priv,
const char *name,
- virHashTablePtr *table,
+ GHashTable **table,
hypervWmiClassInfoListPtr info);
-void hypervFreeEmbeddedParam(virHashTablePtr p);
+void hypervFreeEmbeddedParam(GHashTable *p);
int hypervInvokeMethod(hypervPrivate *priv,
hypervInvokeParamsListPtr *paramsPtr,
diff --git a/src/hypervisor/virclosecallbacks.c b/src/hypervisor/virclosecallbacks.c
index d87fe84505..2641f45a22 100644
--- a/src/hypervisor/virclosecallbacks.c
+++ b/src/hypervisor/virclosecallbacks.c
@@ -40,7 +40,7 @@ struct _virCloseCallbacks {
virObjectLockable parent;
/* UUID string to qemuDriverCloseDef mapping */
- virHashTablePtr list;
+ GHashTable *list;
};
diff --git a/src/libxl/libxl_logger.c b/src/libxl/libxl_logger.c
index d0ce899fe8..93a9c76b25 100644
--- a/src/libxl/libxl_logger.c
+++ b/src/libxl/libxl_logger.c
@@ -42,7 +42,7 @@ struct xentoollog_logger_libvirt {
const char *logDir;
/* map storing the opened fds: "domid" -> FILE* */
- virHashTablePtr files;
+ GHashTable *files;
FILE *defaultLogFile;
};
diff --git a/src/locking/lock_daemon.c b/src/locking/lock_daemon.c
index 021792cc69..57c7fb088f 100644
--- a/src/locking/lock_daemon.c
+++ b/src/locking/lock_daemon.c
@@ -59,7 +59,7 @@ VIR_LOG_INIT("locking.lock_daemon");
struct _virLockDaemon {
GMutex lock;
virNetDaemonPtr dmn;
- virHashTablePtr lockspaces;
+ GHashTable *lockspaces;
virLockSpacePtr defaultLockspace;
};
diff --git a/src/nwfilter/nwfilter_dhcpsnoop.c b/src/nwfilter/nwfilter_dhcpsnoop.c
index c425af497c..e64eb2c7ee 100644
--- a/src/nwfilter/nwfilter_dhcpsnoop.c
+++ b/src/nwfilter/nwfilter_dhcpsnoop.c
@@ -78,10 +78,10 @@ struct virNWFilterSnoopState {
int wLeases; /* number of written leases */
int nThreads; /* number of running threads */
/* thread management */
- virHashTablePtr snoopReqs;
- virHashTablePtr ifnameToKey;
+ GHashTable * snoopReqs;
+ GHashTable * ifnameToKey;
virMutex snoopLock; /* protects SnoopReqs and IfNameToKey */
- virHashTablePtr active;
+ GHashTable * active;
virMutex activeLock; /* protects Active */
};
diff --git a/src/nwfilter/nwfilter_ebiptables_driver.c
b/src/nwfilter/nwfilter_ebiptables_driver.c
index 8dfc870ab7..813ab604ae 100644
--- a/src/nwfilter/nwfilter_ebiptables_driver.c
+++ b/src/nwfilter/nwfilter_ebiptables_driver.c
@@ -3285,7 +3285,7 @@ ebtablesSubChainInstSort(const void *a, const void *b)
static int
-ebtablesGetSubChainInsts(virHashTablePtr chains,
+ebtablesGetSubChainInsts(GHashTable *chains,
bool incoming,
ebtablesSubChainInstPtr **insts,
size_t *ninsts)
@@ -3328,8 +3328,8 @@ ebiptablesApplyNewRules(const char *ifname,
{
size_t i, j;
g_autoptr(virFirewall) fw = virFirewallNew();
- g_autoptr(virHashTable) chains_in_set = virHashNew(NULL);
- g_autoptr(virHashTable) chains_out_set = virHashNew(NULL);
+ g_autoptr(GHashTable) chains_in_set = virHashNew(NULL);
+ g_autoptr(GHashTable) chains_out_set = virHashNew(NULL);
bool haveEbtables = false;
bool haveIptables = false;
bool haveIp6tables = false;
diff --git a/src/nwfilter/nwfilter_gentech_driver.c
b/src/nwfilter/nwfilter_gentech_driver.c
index ca6455c70d..4ada797033 100644
--- a/src/nwfilter/nwfilter_gentech_driver.c
+++ b/src/nwfilter/nwfilter_gentech_driver.c
@@ -127,7 +127,7 @@ virNWFilterRuleInstFree(virNWFilterRuleInstPtr inst)
/**
- * Convert a virHashTable into a string of comma-separated
+ * Convert a GHashTable into a string of comma-separated
* variable names.
*/
struct printString
@@ -166,7 +166,7 @@ printString(void *payload G_GNUC_UNUSED, const char *name, void
*data)
* Returns a string of comma separated variable names
*/
static char *
-virNWFilterPrintVars(virHashTablePtr vars,
+virNWFilterPrintVars(GHashTable *vars,
const char *separator,
bool reportMAC,
bool reportIP)
@@ -195,11 +195,11 @@ virNWFilterPrintVars(virHashTablePtr vars,
* Creates a new hash table with contents of var1 and var2 added where
* contents of var2 will overwrite those of var1.
*/
-static virHashTablePtr
-virNWFilterCreateVarsFrom(virHashTablePtr vars1,
- virHashTablePtr vars2)
+static GHashTable *
+virNWFilterCreateVarsFrom(GHashTable *vars1,
+ GHashTable *vars2)
{
- virHashTablePtr res = virHashNew(virNWFilterVarValueHashFree);
+ GHashTable *res = virHashNew(virNWFilterVarValueHashFree);
if (!res)
return NULL;
@@ -248,7 +248,7 @@ virNWFilterInstReset(virNWFilterInstPtr inst)
static int
virNWFilterDefToInst(virNWFilterDriverStatePtr driver,
virNWFilterDefPtr def,
- virHashTablePtr vars,
+ GHashTable *vars,
enum instCase useNewFilter,
bool *foundNewFilter,
virNWFilterInstPtr inst);
@@ -256,7 +256,7 @@ virNWFilterDefToInst(virNWFilterDriverStatePtr driver,
static int
virNWFilterRuleDefToRuleInst(virNWFilterDefPtr def,
virNWFilterRuleDefPtr rule,
- virHashTablePtr vars,
+ GHashTable *vars,
virNWFilterInstPtr inst)
{
virNWFilterRuleInstPtr ruleinst;
@@ -288,13 +288,13 @@ virNWFilterRuleDefToRuleInst(virNWFilterDefPtr def,
static int
virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver,
virNWFilterIncludeDefPtr inc,
- virHashTablePtr vars,
+ GHashTable *vars,
enum instCase useNewFilter,
bool *foundNewFilter,
virNWFilterInstPtr inst)
{
virNWFilterObjPtr obj;
- virHashTablePtr tmpvars = NULL;
+ GHashTable *tmpvars = NULL;
virNWFilterDefPtr childdef;
virNWFilterDefPtr newChilddef;
int ret = -1;
@@ -369,7 +369,7 @@ virNWFilterIncludeDefToRuleInst(virNWFilterDriverStatePtr driver,
static int
virNWFilterDefToInst(virNWFilterDriverStatePtr driver,
virNWFilterDefPtr def,
- virHashTablePtr vars,
+ GHashTable *vars,
enum instCase useNewFilter,
bool *foundNewFilter,
virNWFilterInstPtr inst)
@@ -404,8 +404,8 @@ virNWFilterDefToInst(virNWFilterDriverStatePtr driver,
static int
virNWFilterDetermineMissingVarsRec(virNWFilterDefPtr filter,
- virHashTablePtr vars,
- virHashTablePtr missing_vars,
+ GHashTable *vars,
+ GHashTable *missing_vars,
int useNewFilter,
virNWFilterDriverStatePtr driver)
{
@@ -441,7 +441,7 @@ virNWFilterDetermineMissingVarsRec(virNWFilterDefPtr filter,
}
}
} else if (inc) {
- g_autoptr(virHashTable) tmpvars = NULL;
+ g_autoptr(GHashTable) tmpvars = NULL;
VIR_DEBUG("Following filter %s", inc->filterref);
if (!(obj = virNWFilterObjListFindInstantiateFilter(driver->nwfilters,
@@ -516,7 +516,7 @@ virNWFilterDoInstantiate(virNWFilterTechDriverPtr techdriver,
const char *learning;
bool reportIP = false;
- virHashTablePtr missing_vars = virHashNew(virNWFilterVarValueHashFree);
+ GHashTable *missing_vars = virHashNew(virNWFilterVarValueHashFree);
memset(&inst, 0, sizeof(inst));
@@ -639,7 +639,7 @@ virNWFilterDoInstantiate(virNWFilterTechDriverPtr techdriver,
static int
-virNWFilterVarHashmapAddStdValue(virHashTablePtr table,
+virNWFilterVarHashmapAddStdValue(GHashTable *table,
const char *var,
const char *value)
{
@@ -940,7 +940,7 @@ enum {
static int
virNWFilterBuildOne(virNWFilterDriverStatePtr driver,
virNWFilterBindingDefPtr binding,
- virHashTablePtr skipInterfaces,
+ GHashTable *skipInterfaces,
int step)
{
bool skipIface;
@@ -982,7 +982,7 @@ virNWFilterBuildOne(virNWFilterDriverStatePtr driver,
struct virNWFilterBuildData {
virNWFilterDriverStatePtr driver;
- virHashTablePtr skipInterfaces;
+ GHashTable *skipInterfaces;
int step;
};
diff --git a/src/nwfilter/nwfilter_gentech_driver.h
b/src/nwfilter/nwfilter_gentech_driver.h
index cf0560a10a..b1cf8e6e41 100644
--- a/src/nwfilter/nwfilter_gentech_driver.h
+++ b/src/nwfilter/nwfilter_gentech_driver.h
@@ -49,7 +49,7 @@ int virNWFilterInstantiateFilterLate(virNWFilterDriverStatePtr driver,
int virNWFilterTeardownFilter(virNWFilterBindingDefPtr binding);
-virHashTablePtr virNWFilterCreateVarHashmap(const char *macaddr,
+GHashTable *virNWFilterCreateVarHashmap(const char *macaddr,
const virNWFilterVarValue *value);
int virNWFilterBuildAll(virNWFilterDriverStatePtr driver,
diff --git a/src/nwfilter/nwfilter_learnipaddr.c b/src/nwfilter/nwfilter_learnipaddr.c
index 6dc535a4fe..ba5eea5ee5 100644
--- a/src/nwfilter/nwfilter_learnipaddr.c
+++ b/src/nwfilter/nwfilter_learnipaddr.c
@@ -112,10 +112,10 @@ struct ether_vlan_header
static virMutex pendingLearnReqLock = VIR_MUTEX_INITIALIZER;
-static virHashTablePtr pendingLearnReq;
+static GHashTable *pendingLearnReq;
static virMutex ifaceMapLock = VIR_MUTEX_INITIALIZER;
-static virHashTablePtr ifaceLockMap;
+static GHashTable *ifaceLockMap;
typedef struct _virNWFilterIfaceLock virNWFilterIfaceLock;
typedef virNWFilterIfaceLock *virNWFilterIfaceLockPtr;
diff --git a/src/nwfilter/nwfilter_tech_driver.h b/src/nwfilter/nwfilter_tech_driver.h
index 9e1e9332f9..784d397a90 100644
--- a/src/nwfilter/nwfilter_tech_driver.h
+++ b/src/nwfilter/nwfilter_tech_driver.h
@@ -36,7 +36,7 @@ struct _virNWFilterRuleInst {
virNWFilterChainPriority chainPriority;
virNWFilterRuleDefPtr def;
virNWFilterRulePriority priority;
- virHashTablePtr vars;
+ GHashTable *vars;
};
diff --git a/src/qemu/qemu_agent.c b/src/qemu/qemu_agent.c
index 4c61c5cdc6..7fbb4a9431 100644
--- a/src/qemu/qemu_agent.c
+++ b/src/qemu/qemu_agent.c
@@ -2128,7 +2128,7 @@ qemuAgentGetInterfaceOneAddress(virDomainIPAddressPtr ip_addr,
static int
qemuAgentGetInterfaceAddresses(virDomainInterfacePtr **ifaces_ret,
size_t *ifaces_count,
- virHashTablePtr ifaces_store,
+ GHashTable *ifaces_store,
virJSONValuePtr iface_obj)
{
virJSONValuePtr ip_addr_arr = NULL;
@@ -2205,7 +2205,7 @@ static int
qemuAgentGetAllInterfaceAddresses(virDomainInterfacePtr **ifaces_ret,
virJSONValuePtr ret_array)
{
- g_autoptr(virHashTable) ifaces_store = NULL;
+ g_autoptr(GHashTable) ifaces_store = NULL;
size_t ifaces_count = 0;
size_t i;
diff --git a/src/qemu/qemu_backup.c b/src/qemu/qemu_backup.c
index 5376d9485d..eb0682e193 100644
--- a/src/qemu/qemu_backup.c
+++ b/src/qemu/qemu_backup.c
@@ -180,7 +180,7 @@ qemuBackupDiskPrepareOneBitmapsChain(virStorageSourcePtr
backingChain,
const char *targetbitmap,
const char *incremental,
virJSONValuePtr actions,
- virHashTablePtr blockNamedNodeData)
+ GHashTable *blockNamedNodeData)
{
g_autoptr(virJSONValue) tmpactions = NULL;
@@ -201,7 +201,7 @@ qemuBackupDiskPrepareOneBitmapsChain(virStorageSourcePtr
backingChain,
static int
qemuBackupDiskPrepareOneBitmaps(struct qemuBackupDiskData *dd,
virJSONValuePtr actions,
- virHashTablePtr blockNamedNodeData)
+ GHashTable *blockNamedNodeData)
{
if (!qemuBlockBitmapChainIsValid(dd->domdisk->src,
dd->backupdisk->incremental,
@@ -238,7 +238,7 @@ qemuBackupDiskPrepareDataOne(virDomainObjPtr vm,
struct qemuBackupDiskData *dd,
virJSONValuePtr actions,
bool pull,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
virQEMUDriverConfigPtr cfg)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
@@ -344,7 +344,7 @@ qemuBackupDiskPrepareDataOnePull(virJSONValuePtr actions,
static ssize_t
qemuBackupDiskPrepareData(virDomainObjPtr vm,
virDomainBackupDefPtr def,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
virJSONValuePtr actions,
virQEMUDriverConfigPtr cfg,
struct qemuBackupDiskData **rdd)
@@ -390,7 +390,7 @@ qemuBackupDiskPrepareData(virDomainObjPtr vm,
static int
qemuBackupDiskPrepareOneStorage(virDomainObjPtr vm,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
struct qemuBackupDiskData *dd,
bool reuse_external)
{
@@ -458,7 +458,7 @@ static int
qemuBackupDiskPrepareStorage(virDomainObjPtr vm,
struct qemuBackupDiskData *disks,
size_t ndisks,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
bool reuse_external)
{
size_t i;
@@ -706,7 +706,7 @@ qemuBackupBegin(virDomainObjPtr vm,
g_autofree char *tlsSecretAlias = NULL;
struct qemuBackupDiskData *dd = NULL;
ssize_t ndd = 0;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
bool job_started = false;
bool nbd_running = false;
bool reuse = (flags & VIR_DOMAIN_BACKUP_BEGIN_REUSE_EXTERNAL);
diff --git a/src/qemu/qemu_backup.h b/src/qemu/qemu_backup.h
index 075fde709b..39e4bcec09 100644
--- a/src/qemu/qemu_backup.h
+++ b/src/qemu/qemu_backup.h
@@ -59,4 +59,4 @@ qemuBackupDiskPrepareOneBitmapsChain(virStorageSourcePtr backingChain,
const char *targetbitmap,
const char *incremental,
virJSONValuePtr actions,
- virHashTablePtr blockNamedNodeData);
+ GHashTable *blockNamedNodeData);
diff --git a/src/qemu/qemu_block.c b/src/qemu/qemu_block.c
index eb5f625b98..4640e339c0 100644
--- a/src/qemu/qemu_block.c
+++ b/src/qemu/qemu_block.c
@@ -56,7 +56,7 @@ qemuBlockNamedNodesArrayToHash(size_t pos G_GNUC_UNUSED,
virJSONValuePtr item,
void *opaque)
{
- virHashTablePtr table = opaque;
+ GHashTable *table = opaque;
const char *name;
if (!(name = virJSONValueObjectGetString(item, "node-name")))
@@ -120,14 +120,14 @@ qemuBlockDriverMatch(const char *drvname,
struct qemuBlockNodeNameGetBackingChainData {
- virHashTablePtr nodenamestable;
- virHashTablePtr disks;
+ GHashTable *nodenamestable;
+ GHashTable *disks;
};
static int
qemuBlockNodeNameGetBackingChainBacking(virJSONValuePtr next,
- virHashTablePtr nodenamestable,
+ GHashTable *nodenamestable,
qemuBlockNodeNameBackingChainDataPtr
*nodenamedata)
{
g_autoptr(qemuBlockNodeNameBackingChainData) data = NULL;
@@ -224,13 +224,13 @@ qemuBlockNodeNameGetBackingChainDisk(size_t pos G_GNUC_UNUSED,
*
* Returns a hash table on success and NULL on failure.
*/
-virHashTablePtr
+GHashTable *
qemuBlockNodeNameGetBackingChain(virJSONValuePtr namednodes,
virJSONValuePtr blockstats)
{
struct qemuBlockNodeNameGetBackingChainData data;
- g_autoptr(virHashTable) namednodestable = NULL;
- g_autoptr(virHashTable) disks = NULL;
+ g_autoptr(GHashTable) namednodestable = NULL;
+ g_autoptr(GHashTable) disks = NULL;
memset(&data, 0, sizeof(data));
@@ -273,7 +273,7 @@ qemuBlockDiskClearDetectedNodes(virDomainDiskDefPtr disk)
static int
qemuBlockDiskDetectNodes(virDomainDiskDefPtr disk,
- virHashTablePtr disktable)
+ GHashTable *disktable)
{
qemuBlockNodeNameBackingChainDataPtr entry = NULL;
virStorageSourcePtr src = disk->src;
@@ -324,7 +324,7 @@ qemuBlockNodeNamesDetect(virQEMUDriverPtr driver,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- g_autoptr(virHashTable) disktable = NULL;
+ g_autoptr(GHashTable) disktable = NULL;
g_autoptr(virJSONValue) data = NULL;
g_autoptr(virJSONValue) blockstats = NULL;
virDomainDiskDefPtr disk;
@@ -363,12 +363,12 @@ qemuBlockNodeNamesDetect(virQEMUDriverPtr driver,
* Returns a hash table organized by the node name of the JSON value objects of
* data for given qemu block nodes.
*
- * Returns a filled virHashTablePtr on success NULL on error.
+ * Returns a filled GHashTable *on success NULL on error.
*/
-virHashTablePtr
+GHashTable *
qemuBlockGetNodeData(virJSONValuePtr data)
{
- g_autoptr(virHashTable) nodedata = NULL;
+ g_autoptr(GHashTable) nodedata = NULL;
if (!(nodedata = virHashNew(virJSONValueHashFree)))
return NULL;
@@ -2770,7 +2770,7 @@ qemuBlockStorageSourceCreate(virDomainObjPtr vm,
* to the detected sizes from @templ.
*/
int
-qemuBlockStorageSourceCreateDetectSize(virHashTablePtr blockNamedNodeData,
+qemuBlockStorageSourceCreateDetectSize(GHashTable *blockNamedNodeData,
virStorageSourcePtr src,
virStorageSourcePtr templ)
{
@@ -2834,7 +2834,7 @@ qemuBlockRemoveImageMetadata(virQEMUDriverPtr driver,
* Looks up a bitmap named @bitmap of the @src image.
*/
qemuBlockNamedNodeDataBitmapPtr
-qemuBlockNamedNodeDataGetBitmapByName(virHashTablePtr blockNamedNodeData,
+qemuBlockNamedNodeDataGetBitmapByName(GHashTable *blockNamedNodeData,
virStorageSourcePtr src,
const char *bitmap)
{
@@ -2857,13 +2857,13 @@ qemuBlockNamedNodeDataGetBitmapByName(virHashTablePtr
blockNamedNodeData,
}
-virHashTablePtr
+GHashTable *
qemuBlockGetNamedNodeData(virDomainObjPtr vm,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
virQEMUDriverPtr driver = priv->driver;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
bool supports_flat = virQEMUCapsGet(priv->qemuCaps,
QEMU_CAPS_QMP_QUERY_NAMED_BLOCK_NODES_FLAT);
@@ -2892,7 +2892,7 @@ qemuBlockGetNamedNodeData(virDomainObjPtr vm,
static GSList *
qemuBlockGetBitmapMergeActionsGetBitmaps(virStorageSourcePtr topsrc,
const char *bitmapname,
- virHashTablePtr blockNamedNodeData)
+ GHashTable *blockNamedNodeData)
{
g_autoptr(GSList) ret = NULL;
qemuBlockNamedNodeDataPtr entry;
@@ -2972,7 +2972,7 @@ qemuBlockGetBitmapMergeActions(virStorageSourcePtr topsrc,
const char *dstbitmapname,
virStorageSourcePtr writebitmapsrc,
virJSONValuePtr *actions,
- virHashTablePtr blockNamedNodeData)
+ GHashTable *blockNamedNodeData)
{
g_autoptr(virJSONValue) act = virJSONValueNewArray();
virStorageSourcePtr n;
@@ -3066,7 +3066,7 @@ qemuBlockGetBitmapMergeActions(virStorageSourcePtr topsrc,
bool
qemuBlockBitmapChainIsValid(virStorageSourcePtr src,
const char *bitmapname,
- virHashTablePtr blockNamedNodeData)
+ GHashTable *blockNamedNodeData)
{
virStorageSourcePtr n;
bool found = false;
@@ -3119,7 +3119,7 @@ qemuBlockBitmapChainIsValid(virStorageSourcePtr src,
int
qemuBlockBitmapsHandleBlockcopy(virStorageSourcePtr src,
virStorageSourcePtr mirror,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
bool shallow,
virJSONValuePtr *actions)
{
@@ -3153,7 +3153,7 @@ int
qemuBlockBitmapsHandleCommitFinish(virStorageSourcePtr topsrc,
virStorageSourcePtr basesrc,
bool active,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
virJSONValuePtr *actions)
{
virStorageSourcePtr writebitmapsrc = NULL;
diff --git a/src/qemu/qemu_block.h b/src/qemu/qemu_block.h
index c725654155..8f2a05f46a 100644
--- a/src/qemu/qemu_block.h
+++ b/src/qemu/qemu_block.h
@@ -41,7 +41,7 @@ struct qemuBlockNodeNameBackingChainData {
char *drvstorage;
};
-virHashTablePtr
+GHashTable *
qemuBlockNodeNameGetBackingChain(virJSONValuePtr namednodesdata,
virJSONValuePtr blockstats);
@@ -50,7 +50,7 @@ qemuBlockNodeNamesDetect(virQEMUDriverPtr driver,
virDomainObjPtr vm,
qemuDomainAsyncJob asyncJob);
-virHashTablePtr
+GHashTable *
qemuBlockGetNodeData(virJSONValuePtr data);
bool
@@ -209,7 +209,7 @@ qemuBlockStorageSourceCreate(virDomainObjPtr vm,
qemuDomainAsyncJob asyncJob);
int
-qemuBlockStorageSourceCreateDetectSize(virHashTablePtr blockNamedNodeData,
+qemuBlockStorageSourceCreateDetectSize(GHashTable *blockNamedNodeData,
virStorageSourcePtr src,
virStorageSourcePtr templ);
@@ -220,11 +220,11 @@ qemuBlockRemoveImageMetadata(virQEMUDriverPtr driver,
virStorageSourcePtr src);
qemuBlockNamedNodeDataBitmapPtr
-qemuBlockNamedNodeDataGetBitmapByName(virHashTablePtr blockNamedNodeData,
+qemuBlockNamedNodeDataGetBitmapByName(GHashTable *blockNamedNodeData,
virStorageSourcePtr src,
const char *bitmap);
-virHashTablePtr
+GHashTable *
qemuBlockGetNamedNodeData(virDomainObjPtr vm,
qemuDomainAsyncJob asyncJob);
@@ -236,17 +236,17 @@ qemuBlockGetBitmapMergeActions(virStorageSourcePtr topsrc,
const char *dstbitmapname,
virStorageSourcePtr writebitmapsrc,
virJSONValuePtr *actions,
- virHashTablePtr blockNamedNodeData);
+ GHashTable *blockNamedNodeData);
bool
qemuBlockBitmapChainIsValid(virStorageSourcePtr src,
const char *bitmapname,
- virHashTablePtr blockNamedNodeData);
+ GHashTable *blockNamedNodeData);
int
qemuBlockBitmapsHandleBlockcopy(virStorageSourcePtr src,
virStorageSourcePtr mirror,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
bool shallow,
virJSONValuePtr *actions);
@@ -254,7 +254,7 @@ int
qemuBlockBitmapsHandleCommitFinish(virStorageSourcePtr topsrc,
virStorageSourcePtr basesrc,
bool active,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
virJSONValuePtr *actions);
int
diff --git a/src/qemu/qemu_blockjob.c b/src/qemu/qemu_blockjob.c
index ed4a32e964..2a5a5e66f4 100644
--- a/src/qemu/qemu_blockjob.c
+++ b/src/qemu/qemu_blockjob.c
@@ -942,7 +942,7 @@ qemuBlockJobProcessEventCompletedPullBitmaps(virDomainObjPtr vm,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
g_autoptr(virJSONValue) actions = NULL;
if (!(blockNamedNodeData = qemuBlockGetNamedNodeData(vm, asyncJob)))
@@ -1097,7 +1097,7 @@ qemuBlockJobProcessEventCompletedCommitBitmaps(virDomainObjPtr vm,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
g_autoptr(virJSONValue) actions = NULL;
bool active = job->type == QEMU_BLOCKJOB_TYPE_ACTIVE_COMMIT;
@@ -1326,7 +1326,7 @@ qemuBlockJobProcessEventCompletedCopyBitmaps(virDomainObjPtr vm,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
g_autoptr(virJSONValue) actions = NULL;
bool shallow = job->jobflags & VIR_DOMAIN_BLOCK_COPY_SHALLOW;
diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index a67fb785b5..6958f6ece2 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -652,7 +652,7 @@ typedef virQEMUDomainCapsCache *virQEMUDomainCapsCachePtr;
struct _virQEMUDomainCapsCache {
virObjectLockable parent;
- virHashTablePtr cache;
+ GHashTable *cache;
};
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virQEMUDomainCapsCache, virObjectUnref);
@@ -2686,7 +2686,7 @@ virQEMUCapsProbeQMPDeviceProperties(virQEMUCapsPtr qemuCaps,
for (i = 0; i < G_N_ELEMENTS(virQEMUCapsDeviceProps); i++) {
virQEMUCapsDeviceTypeProps *device = virQEMUCapsDeviceProps + i;
- g_autoptr(virHashTable) qemuprops = NULL;
+ g_autoptr(GHashTable) qemuprops = NULL;
size_t j;
if (device->capsCondition >= 0 &&
@@ -3065,7 +3065,7 @@ virQEMUCapsProbeQMPHostCPU(virQEMUCapsPtr qemuCaps,
const char *model = virtType == VIR_DOMAIN_VIRT_KVM ? "host" :
"max";
qemuMonitorCPUModelInfoPtr modelInfo = NULL;
qemuMonitorCPUModelInfoPtr nonMigratable = NULL;
- virHashTablePtr hash = NULL;
+ GHashTable *hash = NULL;
virCPUDefPtr cpu;
qemuMonitorCPUModelExpansionType type;
bool fail_no_props = true;
@@ -5258,7 +5258,7 @@ virQEMUCapsProbeQMPSchemaCapabilities(virQEMUCapsPtr qemuCaps,
{
struct virQEMUCapsStringFlags *entry;
virJSONValuePtr schemareply;
- virHashTablePtr schema = NULL;
+ GHashTable *schema = NULL;
size_t i;
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_QMP_SCHEMA))
diff --git a/src/qemu/qemu_checkpoint.c b/src/qemu/qemu_checkpoint.c
index fb76c211f8..050d78140a 100644
--- a/src/qemu/qemu_checkpoint.c
+++ b/src/qemu/qemu_checkpoint.c
@@ -107,7 +107,7 @@ qemuCheckpointWriteMetadata(virDomainObjPtr vm,
int
qemuCheckpointDiscardDiskBitmaps(virStorageSourcePtr src,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
const char *delbitmap,
virJSONValuePtr actions,
const char *diskdst,
@@ -152,7 +152,7 @@ qemuCheckpointDiscardBitmaps(virDomainObjPtr vm,
{
qemuDomainObjPrivatePtr priv = vm->privateData;
virQEMUDriverPtr driver = priv->driver;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
int rc = -1;
g_autoptr(virJSONValue) actions = NULL;
size_t i;
@@ -579,7 +579,7 @@ qemuCheckpointGetXMLDescUpdateSize(virDomainObjPtr vm,
{
qemuDomainObjPrivatePtr priv = vm->privateData;
virQEMUDriverPtr driver = priv->driver;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
g_autofree struct qemuCheckpointDiskMap *diskmap = NULL;
g_autoptr(virJSONValue) recoveractions = NULL;
g_autoptr(virJSONValue) mergeactions = virJSONValueNewArray();
diff --git a/src/qemu/qemu_checkpoint.h b/src/qemu/qemu_checkpoint.h
index 0d267a188c..4bb09bff05 100644
--- a/src/qemu/qemu_checkpoint.h
+++ b/src/qemu/qemu_checkpoint.h
@@ -74,7 +74,7 @@ qemuCheckpointRollbackMetadata(virDomainObjPtr vm,
int
qemuCheckpointDiscardDiskBitmaps(virStorageSourcePtr src,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
const char *delbitmap,
virJSONValuePtr actions,
const char *diskdst,
diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c
index ead9d1ee99..66a62855e8 100644
--- a/src/qemu/qemu_conf.c
+++ b/src/qemu/qemu_conf.c
@@ -1479,7 +1479,7 @@ qemuGetSharedDeviceKey(const char *device_path)
* being used and in the future the hostdev information.
*/
static int
-qemuCheckUnprivSGIO(virHashTablePtr sharedDevices,
+qemuCheckUnprivSGIO(GHashTable *sharedDevices,
const char *device_path,
int sgio)
{
@@ -1527,7 +1527,7 @@ qemuCheckUnprivSGIO(virHashTablePtr sharedDevices,
* Returns 0 if no conflicts, otherwise returns -1.
*/
static int
-qemuCheckSharedDisk(virHashTablePtr sharedDevices,
+qemuCheckSharedDisk(GHashTable *sharedDevices,
virDomainDiskDefPtr disk)
{
int ret;
diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h
index 1d7afa8738..da03a184c1 100644
--- a/src/qemu/qemu_conf.h
+++ b/src/qemu/qemu_conf.h
@@ -296,7 +296,7 @@ struct _virQEMUDriver {
virHostdevManagerPtr hostdevMgr;
/* Immutable pointer. Unsafe APIs. XXX */
- virHashTablePtr sharedDevices;
+ GHashTable *sharedDevices;
/* Immutable pointer, immutable object */
virPortAllocatorRangePtr remotePorts;
diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index e770940aca..02b5e7422c 100644
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -7830,7 +7830,7 @@ qemuDomainUpdateMemoryDeviceInfo(virQEMUDriverPtr driver,
int asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- virHashTablePtr meminfo = NULL;
+ GHashTable *meminfo = NULL;
int rc;
size_t i;
diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h
index fc69678f9b..ca041e207b 100644
--- a/src/qemu/qemu_domain.h
+++ b/src/qemu/qemu_domain.h
@@ -244,7 +244,7 @@ struct _qemuDomainObjPrivate {
bool memPrealloc;
/* running block jobs */
- virHashTablePtr blockjobs;
+ GHashTable *blockjobs;
bool disableSlirp;
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index cb56fbbfcf..5f0bb69dd5 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -9937,7 +9937,7 @@ qemuDomainBlocksStatsGather(virQEMUDriverPtr driver,
qemuDomainObjPrivatePtr priv = vm->privateData;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
virDomainDiskDefPtr disk = NULL;
- virHashTablePtr blockstats = NULL;
+ GHashTable *blockstats = NULL;
qemuBlockStatsPtr stats;
size_t i;
int nstats;
@@ -14980,7 +14980,7 @@ qemuDomainBlockCopyCommon(virDomainObjPtr vm,
g_autoptr(qemuBlockStorageSourceChainData) crdata = NULL;
virStorageSourcePtr n;
virStorageSourcePtr mirrorBacking = NULL;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
int rc = 0;
/* Preliminaries: find the disk we are editing, sanity checks */
@@ -16543,7 +16543,7 @@ qemuDomainGetDiskErrors(virDomainPtr dom,
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
qemuDomainObjPrivatePtr priv;
- virHashTablePtr table = NULL;
+ GHashTable *table = NULL;
bool blockdev = false;
int ret = -1;
size_t i;
@@ -18227,8 +18227,8 @@ qemuDomainGetStatsOneBlockFallback(virQEMUDriverPtr driver,
static void
qemuDomainGetStatsOneBlockRefreshNamed(virStorageSourcePtr src,
const char *alias,
- virHashTablePtr stats,
- virHashTablePtr nodedata)
+ GHashTable *stats,
+ GHashTable *nodedata)
{
qemuBlockStatsPtr entry;
@@ -18257,7 +18257,7 @@ qemuDomainGetStatsOneBlock(virQEMUDriverPtr driver,
const char *entryname,
virStorageSourcePtr src,
size_t block_idx,
- virHashTablePtr stats)
+ GHashTable *stats)
{
qemuBlockStats *entry;
@@ -18301,7 +18301,7 @@ qemuDomainGetStatsOneBlock(virQEMUDriverPtr driver,
static int
qemuDomainGetStatsBlockExportBackendStorage(const char *entryname,
- virHashTablePtr stats,
+ GHashTable *stats,
size_t recordnr,
virTypedParamListPtr params)
{
@@ -18321,7 +18321,7 @@ qemuDomainGetStatsBlockExportBackendStorage(const char
*entryname,
static int
qemuDomainGetStatsBlockExportFrontend(const char *frontendname,
- virHashTablePtr stats,
+ GHashTable *stats,
size_t idx,
virTypedParamListPtr par)
{
@@ -18370,8 +18370,8 @@ qemuDomainGetStatsBlockExportHeader(virDomainDiskDefPtr disk,
static int
qemuDomainGetStatsBlockExportDisk(virDomainDiskDefPtr disk,
- virHashTablePtr stats,
- virHashTablePtr nodestats,
+ GHashTable *stats,
+ GHashTable *nodestats,
virTypedParamListPtr params,
size_t *recordnr,
bool visitBacking,
@@ -18461,8 +18461,8 @@ qemuDomainGetStatsBlock(virQEMUDriverPtr driver,
size_t i;
int ret = -1;
int rc;
- virHashTablePtr stats = NULL;
- virHashTablePtr nodestats = NULL;
+ GHashTable *stats = NULL;
+ GHashTable *nodestats = NULL;
virJSONValuePtr nodedata = NULL;
qemuDomainObjPrivatePtr priv = dom->privateData;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
diff --git a/src/qemu/qemu_interop_config.c b/src/qemu/qemu_interop_config.c
index c8b81c59a8..c5a5a9c6ec 100644
--- a/src/qemu/qemu_interop_config.c
+++ b/src/qemu/qemu_interop_config.c
@@ -35,7 +35,7 @@
VIR_LOG_INIT("qemu.qemu_configs");
static int
-qemuBuildFileList(virHashTablePtr files, const char *dir)
+qemuBuildFileList(GHashTable *files, const char *dir)
{
g_autoptr(DIR) dirp = NULL;
struct dirent *ent = NULL;
@@ -87,7 +87,7 @@ qemuInteropFetchConfigs(const char *name,
char ***configs,
bool privileged)
{
- g_autoptr(virHashTable) files = NULL;
+ g_autoptr(GHashTable) files = NULL;
g_autofree char *homeConfig = NULL;
g_autofree char *xdgConfig = NULL;
g_autofree char *sysLocation = virFileBuildPath(QEMU_SYSTEM_LOCATION, name, NULL);
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 6f764b0c73..0cf0788f1f 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -5796,7 +5796,7 @@ qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver,
size_t i;
qemuDomainObjPrivatePtr priv = vm->privateData;
bool nbd = false;
- virHashTablePtr blockinfo = NULL;
+ GHashTable *blockinfo = NULL;
qemuDomainMirrorStatsPtr stats = &jobInfo->mirrorStats;
for (i = 0; i < vm->def->ndisks; i++) {
diff --git a/src/qemu/qemu_migration_cookie.c b/src/qemu/qemu_migration_cookie.c
index 39445ef8de..47674d29d7 100644
--- a/src/qemu/qemu_migration_cookie.c
+++ b/src/qemu/qemu_migration_cookie.c
@@ -435,7 +435,7 @@ qemuMigrationCookieAddNBD(qemuMigrationCookiePtr mig,
virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- g_autoptr(virHashTable) stats = virHashNew(g_free);
+ g_autoptr(GHashTable) stats = virHashNew(g_free);
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
size_t i;
int rc;
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 5481bd99a0..f2ed165b22 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -2098,11 +2098,11 @@ qemuDomainDiskInfoFree(void *value)
}
-virHashTablePtr
+GHashTable *
qemuMonitorGetBlockInfo(qemuMonitorPtr mon)
{
int ret;
- virHashTablePtr table;
+ GHashTable *table;
QEMU_CHECK_MONITOR_NULL(mon);
@@ -2149,7 +2149,7 @@ qemuMonitorQueryBlockstats(qemuMonitorPtr mon)
*/
int
qemuMonitorGetAllBlockStatsInfo(qemuMonitorPtr mon,
- virHashTablePtr *ret_stats,
+ GHashTable **ret_stats,
bool backingChain)
{
int ret = -1;
@@ -2178,7 +2178,7 @@ qemuMonitorGetAllBlockStatsInfo(qemuMonitorPtr mon,
/* Updates "stats" to fill virtual and physical size of the image */
int
qemuMonitorBlockStatsUpdateCapacity(qemuMonitorPtr mon,
- virHashTablePtr stats,
+ GHashTable *stats,
bool backingChain)
{
VIR_DEBUG("stats=%p, backing=%d", stats, backingChain);
@@ -2191,7 +2191,7 @@ qemuMonitorBlockStatsUpdateCapacity(qemuMonitorPtr mon,
int
qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
- virHashTablePtr stats)
+ GHashTable *stats)
{
VIR_DEBUG("stats=%p", stats);
@@ -2210,7 +2210,7 @@ qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
* storage nodes and returns them in a hash table of qemuBlockNamedNodeDataPtrs
* filled with the data. The hash table keys are node names.
*/
-virHashTablePtr
+GHashTable *
qemuMonitorBlockGetNamedNodeData(qemuMonitorPtr mon,
bool supports_flat)
{
@@ -2889,10 +2889,10 @@ qemuMonitorChardevInfoFree(void *data)
int
qemuMonitorGetChardevInfo(qemuMonitorPtr mon,
- virHashTablePtr *retinfo)
+ GHashTable **retinfo)
{
int ret;
- virHashTablePtr info = NULL;
+ GHashTable *info = NULL;
VIR_DEBUG("retinfo=%p", retinfo);
@@ -3412,7 +3412,7 @@ qemuMonitorBlockJobSetSpeed(qemuMonitorPtr mon,
}
-virHashTablePtr
+GHashTable *
qemuMonitorGetAllBlockJobInfo(qemuMonitorPtr mon,
bool rawjobname)
{
@@ -3431,7 +3431,7 @@ qemuMonitorGetBlockJobInfo(qemuMonitorPtr mon,
const char *alias,
qemuMonitorBlockJobInfoPtr info)
{
- virHashTablePtr all;
+ GHashTable *all;
qemuMonitorBlockJobInfoPtr data;
int ret = 0;
@@ -3898,7 +3898,7 @@ qemuMonitorGetObjectTypes(qemuMonitorPtr mon,
}
-virHashTablePtr
+GHashTable *
qemuMonitorGetDeviceProps(qemuMonitorPtr mon,
const char *device)
{
@@ -4299,7 +4299,7 @@ qemuMonitorSetIOThread(qemuMonitorPtr mon,
*/
int
qemuMonitorGetMemoryDeviceInfo(qemuMonitorPtr mon,
- virHashTablePtr *info)
+ GHashTable **info)
{
int ret;
@@ -4604,10 +4604,10 @@ qemuMonitorGetSEVMeasurement(qemuMonitorPtr mon)
int
qemuMonitorGetPRManagerInfo(qemuMonitorPtr mon,
- virHashTablePtr *retinfo)
+ GHashTable **retinfo)
{
int ret = -1;
- virHashTablePtr info = NULL;
+ GHashTable *info = NULL;
*retinfo = NULL;
diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h
index 54fbb41ef7..d301568e40 100644
--- a/src/qemu/qemu_monitor.h
+++ b/src/qemu/qemu_monitor.h
@@ -673,7 +673,7 @@ int qemuMonitorSetMemoryStatsPeriod(qemuMonitorPtr mon,
int period);
int qemuMonitorBlockIOStatusToError(const char *status);
-virHashTablePtr qemuMonitorGetBlockInfo(qemuMonitorPtr mon);
+GHashTable *qemuMonitorGetBlockInfo(qemuMonitorPtr mon);
virJSONValuePtr qemuMonitorQueryBlockstats(qemuMonitorPtr mon);
@@ -701,17 +701,17 @@ struct _qemuBlockStats {
};
int qemuMonitorGetAllBlockStatsInfo(qemuMonitorPtr mon,
- virHashTablePtr *ret_stats,
+ GHashTable **ret_stats,
bool backingChain)
ATTRIBUTE_NONNULL(2);
int qemuMonitorBlockStatsUpdateCapacity(qemuMonitorPtr mon,
- virHashTablePtr stats,
+ GHashTable *stats,
bool backingChain)
ATTRIBUTE_NONNULL(2);
int qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
- virHashTablePtr stats)
+ GHashTable *stats)
ATTRIBUTE_NONNULL(2);
typedef struct _qemuBlockNamedNodeDataBitmap qemuBlockNamedNodeDataBitmap;
@@ -740,7 +740,7 @@ struct _qemuBlockNamedNodeData {
unsigned long long clusterSize;
};
-virHashTablePtr
+GHashTable *
qemuMonitorBlockGetNamedNodeData(qemuMonitorPtr mon,
bool supports_flat);
@@ -990,7 +990,7 @@ struct _qemuMonitorChardevInfo {
};
void qemuMonitorChardevInfoFree(void *data);
int qemuMonitorGetChardevInfo(qemuMonitorPtr mon,
- virHashTablePtr *retinfo);
+ GHashTable **retinfo);
int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon,
const char *bus,
@@ -1126,7 +1126,7 @@ struct _qemuMonitorBlockJobInfo {
int ready; /* -1 if unknown, 0 if not ready, 1 if ready */
};
-virHashTablePtr qemuMonitorGetAllBlockJobInfo(qemuMonitorPtr mon,
+GHashTable *qemuMonitorGetAllBlockJobInfo(qemuMonitorPtr mon,
bool rawjobname);
int qemuMonitorGetBlockJobInfo(qemuMonitorPtr mon,
const char *device,
@@ -1295,7 +1295,7 @@ int qemuMonitorGetKVMState(qemuMonitorPtr mon,
int qemuMonitorGetObjectTypes(qemuMonitorPtr mon,
char ***types);
-virHashTablePtr qemuMonitorGetDeviceProps(qemuMonitorPtr mon,
+GHashTable *qemuMonitorGetDeviceProps(qemuMonitorPtr mon,
const char *device);
int qemuMonitorGetObjectProps(qemuMonitorPtr mon,
const char *object,
@@ -1389,7 +1389,7 @@ struct _qemuMonitorMemoryDeviceInfo {
};
int qemuMonitorGetMemoryDeviceInfo(qemuMonitorPtr mon,
- virHashTablePtr *info)
+ GHashTable **info)
ATTRIBUTE_NONNULL(2);
int qemuMonitorMigrateIncoming(qemuMonitorPtr mon,
@@ -1451,7 +1451,7 @@ struct _qemuMonitorPRManagerInfo {
};
int qemuMonitorGetPRManagerInfo(qemuMonitorPtr mon,
- virHashTablePtr *retinfo);
+ GHashTable **retinfo);
typedef struct _qemuMonitorCurrentMachineInfo qemuMonitorCurrentMachineInfo;
typedef qemuMonitorCurrentMachineInfo *qemuMonitorCurrentMachineInfoPtr;
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index 843a555952..723bdb4426 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -2475,7 +2475,7 @@ qemuMonitorJSONGetBlockDevDevice(virJSONValuePtr dev)
static int
-qemuMonitorJSONBlockInfoAdd(virHashTablePtr table,
+qemuMonitorJSONBlockInfoAdd(GHashTable *table,
struct qemuDomainDiskInfo *info,
const char *entryname)
{
@@ -2505,7 +2505,7 @@ qemuMonitorJSONBlockInfoAdd(virHashTablePtr table,
int qemuMonitorJSONGetBlockInfo(qemuMonitorPtr mon,
- virHashTablePtr table)
+ GHashTable *table)
{
int ret = -1;
size_t i;
@@ -2633,7 +2633,7 @@ qemuMonitorJSONBlockStatsCollectData(virJSONValuePtr dev,
static int
qemuMonitorJSONAddOneBlockStatsInfo(qemuBlockStatsPtr bstats,
const char *name,
- virHashTablePtr stats)
+ GHashTable *stats)
{
qemuBlockStatsPtr copy = NULL;
@@ -2655,7 +2655,7 @@ static int
qemuMonitorJSONGetOneBlockStatsInfo(virJSONValuePtr dev,
const char *dev_name,
int depth,
- virHashTablePtr hash,
+ GHashTable *hash,
bool backingChain)
{
g_autofree qemuBlockStatsPtr bstats = NULL;
@@ -2730,7 +2730,7 @@ qemuMonitorJSONQueryBlockstats(qemuMonitorPtr mon)
int
qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mon,
- virHashTablePtr hash,
+ GHashTable *hash,
bool backingChain)
{
int nstats = 0;
@@ -2779,7 +2779,7 @@ qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mon,
static int
qemuMonitorJSONBlockStatsUpdateCapacityData(virJSONValuePtr image,
const char *name,
- virHashTablePtr stats,
+ GHashTable *stats,
qemuBlockStatsPtr *entry)
{
qemuBlockStatsPtr bstats;
@@ -2814,7 +2814,7 @@ static int
qemuMonitorJSONBlockStatsUpdateCapacityOne(virJSONValuePtr image,
const char *dev_name,
int depth,
- virHashTablePtr stats,
+ GHashTable *stats,
bool backingChain)
{
int ret = -1;
@@ -2843,7 +2843,7 @@ qemuMonitorJSONBlockStatsUpdateCapacityOne(virJSONValuePtr image,
int
qemuMonitorJSONBlockStatsUpdateCapacity(qemuMonitorPtr mon,
- virHashTablePtr stats,
+ GHashTable *stats,
bool backingChain)
{
int ret = -1;
@@ -2889,7 +2889,7 @@ qemuMonitorJSONBlockStatsUpdateCapacityBlockdevWorker(size_t pos
G_GNUC_UNUSED,
virJSONValuePtr val,
void *opaque)
{
- virHashTablePtr stats = opaque;
+ GHashTable *stats = opaque;
virJSONValuePtr image;
const char *nodename;
qemuBlockStatsPtr entry;
@@ -2914,7 +2914,7 @@ qemuMonitorJSONBlockStatsUpdateCapacityBlockdevWorker(size_t pos
G_GNUC_UNUSED,
int
qemuMonitorJSONBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
- virHashTablePtr stats)
+ GHashTable *stats)
{
virJSONValuePtr nodes;
int ret = -1;
@@ -3018,7 +3018,7 @@ qemuMonitorJSONBlockGetNamedNodeDataWorker(size_t pos
G_GNUC_UNUSED,
virJSONValuePtr val,
void *opaque)
{
- virHashTablePtr nodes = opaque;
+ GHashTable *nodes = opaque;
virJSONValuePtr img;
virJSONValuePtr bitmaps;
const char *nodename;
@@ -3057,10 +3057,10 @@ qemuMonitorJSONBlockGetNamedNodeDataWorker(size_t pos
G_GNUC_UNUSED,
}
-virHashTablePtr
+GHashTable *
qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValuePtr nodes)
{
- g_autoptr(virHashTable) ret = NULL;
+ g_autoptr(GHashTable) ret = NULL;
ret = virHashNew((virHashDataFree) qemuMonitorJSONBlockNamedNodeDataFree);
@@ -3073,7 +3073,7 @@ qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValuePtr nodes)
}
-virHashTablePtr
+GHashTable *
qemuMonitorJSONBlockGetNamedNodeData(qemuMonitorPtr mon,
bool supports_flat)
{
@@ -4462,7 +4462,7 @@ qemuMonitorJSONQueryRxFilter(qemuMonitorPtr mon, const char *alias,
*/
static int
qemuMonitorJSONExtractChardevInfo(virJSONValuePtr reply,
- virHashTablePtr info)
+ GHashTable *info)
{
virJSONValuePtr data;
int ret = -1;
@@ -4530,7 +4530,7 @@ qemuMonitorJSONExtractChardevInfo(virJSONValuePtr reply,
int
qemuMonitorJSONGetChardevInfo(qemuMonitorPtr mon,
- virHashTablePtr info)
+ GHashTable *info)
{
int ret = -1;
@@ -5082,7 +5082,7 @@ int qemuMonitorJSONScreendump(qemuMonitorPtr mon,
static int
-qemuMonitorJSONParseBlockJobInfo(virHashTablePtr blockJobs,
+qemuMonitorJSONParseBlockJobInfo(GHashTable *blockJobs,
virJSONValuePtr entry,
bool rawjobname)
{
@@ -5150,7 +5150,7 @@ qemuMonitorJSONParseBlockJobInfo(virHashTablePtr blockJobs,
return 0;
}
-virHashTablePtr
+GHashTable *
qemuMonitorJSONGetAllBlockJobInfo(qemuMonitorPtr mon,
bool rawjobname)
{
@@ -5159,7 +5159,7 @@ qemuMonitorJSONGetAllBlockJobInfo(qemuMonitorPtr mon,
virJSONValuePtr data;
size_t nr_results;
size_t i;
- virHashTablePtr blockJobs = NULL;
+ GHashTable *blockJobs = NULL;
cmd = qemuMonitorJSONMakeCommand("query-block-jobs", NULL);
if (!cmd)
@@ -6949,7 +6949,7 @@ qemuMonitorJSONGetDevicePropsWorker(size_t pos G_GNUC_UNUSED,
void *opaque)
{
const char *name = virJSONValueObjectGetString(item, "name");
- virHashTablePtr devices = opaque;
+ GHashTable *devices = opaque;
if (!name) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@@ -6964,11 +6964,11 @@ qemuMonitorJSONGetDevicePropsWorker(size_t pos G_GNUC_UNUSED,
}
-virHashTablePtr
+GHashTable *
qemuMonitorJSONGetDeviceProps(qemuMonitorPtr mon,
const char *device)
{
- g_autoptr(virHashTable) props = virHashNew(virJSONValueHashFree);
+ g_autoptr(GHashTable) props = virHashNew(virJSONValueHashFree);
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
@@ -8379,7 +8379,7 @@ qemuMonitorJSONSetIOThread(qemuMonitorPtr mon,
int
qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitorPtr mon,
- virHashTablePtr info)
+ GHashTable *info)
{
int ret = -1;
virJSONValuePtr cmd;
@@ -9263,7 +9263,7 @@ qemuMonitorJSONGetSEVMeasurement(qemuMonitorPtr mon)
*/
static int
qemuMonitorJSONExtractPRManagerInfo(virJSONValuePtr reply,
- virHashTablePtr info)
+ GHashTable *info)
{
qemuMonitorPRManagerInfoPtr entry = NULL;
virJSONValuePtr data;
@@ -9307,7 +9307,7 @@ qemuMonitorJSONExtractPRManagerInfo(virJSONValuePtr reply,
int
qemuMonitorJSONGetPRManagerInfo(qemuMonitorPtr mon,
- virHashTablePtr info)
+ GHashTable *info)
{
int ret = -1;
virJSONValuePtr cmd;
diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h
index 38e23ef3c5..b588722d90 100644
--- a/src/qemu/qemu_monitor_json.h
+++ b/src/qemu/qemu_monitor_json.h
@@ -75,22 +75,22 @@ int qemuMonitorJSONSetMemoryStatsPeriod(qemuMonitorPtr mon,
char *balloonpath,
int period);
int qemuMonitorJSONGetBlockInfo(qemuMonitorPtr mon,
- virHashTablePtr table);
+ GHashTable *table);
virJSONValuePtr qemuMonitorJSONQueryBlockstats(qemuMonitorPtr mon);
int qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mon,
- virHashTablePtr hash,
+ GHashTable *hash,
bool backingChain);
int qemuMonitorJSONBlockStatsUpdateCapacity(qemuMonitorPtr mon,
- virHashTablePtr stats,
+ GHashTable *stats,
bool backingChain);
int qemuMonitorJSONBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon,
- virHashTablePtr stats);
+ GHashTable *stats);
-virHashTablePtr
+GHashTable *
qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValuePtr nodes);
-virHashTablePtr
+GHashTable *
qemuMonitorJSONBlockGetNamedNodeData(qemuMonitorPtr mon,
bool supports_flat);
@@ -231,7 +231,7 @@ int qemuMonitorJSONQueryRxFilter(qemuMonitorPtr mon, const char
*alias,
virNetDevRxFilterPtr *filter);
int qemuMonitorJSONGetChardevInfo(qemuMonitorPtr mon,
- virHashTablePtr info);
+ GHashTable *info);
int qemuMonitorJSONAttachPCIDiskController(qemuMonitorPtr mon,
const char *bus,
@@ -341,7 +341,7 @@ int qemuMonitorJSONBlockJobSetSpeed(qemuMonitorPtr mon,
unsigned long long speed)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-virHashTablePtr qemuMonitorJSONGetAllBlockJobInfo(qemuMonitorPtr mon,
+GHashTable *qemuMonitorJSONGetAllBlockJobInfo(qemuMonitorPtr mon,
bool rawjobname)
ATTRIBUTE_NONNULL(1);
@@ -499,7 +499,7 @@ int qemuMonitorJSONSetObjectProperty(qemuMonitorPtr mon,
qemuMonitorJSONObjectPropertyPtr prop)
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
-virHashTablePtr qemuMonitorJSONGetDeviceProps(qemuMonitorPtr mon,
+GHashTable *qemuMonitorJSONGetDeviceProps(qemuMonitorPtr mon,
const char *device)
ATTRIBUTE_NONNULL(2);
int qemuMonitorJSONGetObjectProps(qemuMonitorPtr mon,
@@ -564,7 +564,7 @@ int qemuMonitorJSONSetIOThread(qemuMonitorPtr mon,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitorPtr mon,
- virHashTablePtr info)
+ GHashTable *info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int qemuMonitorJSONFindLinkPath(qemuMonitorPtr mon,
@@ -645,7 +645,7 @@ int qemuMonitorJSONBlockdevMediumInsert(qemuMonitorPtr mon,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
int qemuMonitorJSONGetPRManagerInfo(qemuMonitorPtr mon,
- virHashTablePtr info)
+ GHashTable *info)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index cd0f57da97..0a36b49c85 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -2170,7 +2170,7 @@ qemuProcessMonitorReportLogError(qemuMonitorPtr mon G_GNUC_UNUSED,
static int
qemuProcessLookupPTYs(virDomainChrDefPtr *devices,
int count,
- virHashTablePtr info)
+ GHashTable *info)
{
size_t i;
@@ -2209,7 +2209,7 @@ qemuProcessLookupPTYs(virDomainChrDefPtr *devices,
static int
qemuProcessFindCharDevicePTYsMonitor(virDomainObjPtr vm,
- virHashTablePtr info)
+ GHashTable *info)
{
size_t i = 0;
@@ -2249,7 +2249,7 @@ qemuProcessFindCharDevicePTYsMonitor(virDomainObjPtr vm,
static void
qemuProcessRefreshChannelVirtioState(virQEMUDriverPtr driver,
virDomainObjPtr vm,
- virHashTablePtr info,
+ GHashTable *info,
int booted)
{
size_t i;
@@ -2291,7 +2291,7 @@ qemuRefreshVirtioChannelState(virQEMUDriverPtr driver,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- virHashTablePtr info = NULL;
+ GHashTable *info = NULL;
int ret = -1;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
@@ -2315,7 +2315,7 @@ qemuRefreshVirtioChannelState(virQEMUDriverPtr driver,
static int
qemuProcessRefreshPRManagerState(virDomainObjPtr vm,
- virHashTablePtr info)
+ GHashTable *info)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
qemuMonitorPRManagerInfoPtr prManagerInfo;
@@ -2343,7 +2343,7 @@ qemuRefreshPRManagerState(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- virHashTablePtr info = NULL;
+ GHashTable *info = NULL;
int ret = -1;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_PR_MANAGER_HELPER) ||
@@ -2438,7 +2438,7 @@ qemuProcessWaitForMonitor(virQEMUDriverPtr driver,
qemuDomainLogContextPtr logCtxt)
{
int ret = -1;
- virHashTablePtr info = NULL;
+ GHashTable *info = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
bool retry = true;
@@ -7966,7 +7966,7 @@ qemuProcessRefreshDisks(virQEMUDriverPtr driver,
{
qemuDomainObjPrivatePtr priv = vm->privateData;
bool blockdev = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV);
- virHashTablePtr table = NULL;
+ GHashTable *table = NULL;
int ret = -1;
size_t i;
@@ -8194,7 +8194,7 @@ static int
qemuProcessRefreshLegacyBlockjobs(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
- virHashTablePtr blockJobs = NULL;
+ GHashTable *blockJobs = NULL;
int ret = -1;
qemuDomainObjEnterMonitor(driver, vm);
diff --git a/src/qemu/qemu_qapi.c b/src/qemu/qemu_qapi.c
index 5e5fff3019..3f2c52f69d 100644
--- a/src/qemu/qemu_qapi.c
+++ b/src/qemu/qemu_qapi.c
@@ -69,7 +69,7 @@ virQEMUQAPISchemaObjectGet(const char *field,
struct virQEMUQAPISchemaTraverseContext {
const char *prevquery;
- virHashTablePtr schema;
+ GHashTable *schema;
char **queries;
virJSONValuePtr returnType;
size_t depth;
@@ -92,7 +92,7 @@ virQEMUQAPISchemaTraverseContextValidateDepth(struct
virQEMUQAPISchemaTraverseCo
static void
virQEMUQAPISchemaTraverseContextInit(struct virQEMUQAPISchemaTraverseContext *ctxt,
char **queries,
- virHashTablePtr schema)
+ GHashTable *schema)
{
memset(ctxt, 0, sizeof(*ctxt));
ctxt->schema = schema;
@@ -429,7 +429,7 @@ virQEMUQAPISchemaTraverse(const char *baseName,
*/
int
virQEMUQAPISchemaPathGet(const char *query,
- virHashTablePtr schema,
+ GHashTable *schema,
virJSONValuePtr *entry)
{
VIR_AUTOSTRINGLIST elems = NULL;
@@ -478,7 +478,7 @@ virQEMUQAPISchemaPathGet(const char *query,
bool
virQEMUQAPISchemaPathExists(const char *query,
- virHashTablePtr schema)
+ GHashTable *schema)
{
return virQEMUQAPISchemaPathGet(query, schema, NULL) == 1;
}
@@ -489,7 +489,7 @@ virQEMUQAPISchemaEntryProcess(size_t pos G_GNUC_UNUSED,
void *opaque)
{
const char *name;
- virHashTablePtr schema = opaque;
+ GHashTable *schema = opaque;
if (!(name = virJSONValueObjectGetString(item, "name"))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@@ -511,10 +511,10 @@ virQEMUQAPISchemaEntryProcess(size_t pos G_GNUC_UNUSED,
* Converts the schema into the hash-table used by the functions working with
* the schema. @schemareply is consumed and freed.
*/
-virHashTablePtr
+GHashTable *
virQEMUQAPISchemaConvert(virJSONValuePtr schemareply)
{
- g_autoptr(virHashTable) schema = NULL;
+ g_autoptr(GHashTable) schema = NULL;
g_autoptr(virJSONValue) schemajson = schemareply;
if (!(schema = virHashNew(virJSONValueHashFree)))
diff --git a/src/qemu/qemu_qapi.h b/src/qemu/qemu_qapi.h
index 33af025424..3cb30c8162 100644
--- a/src/qemu/qemu_qapi.h
+++ b/src/qemu/qemu_qapi.h
@@ -25,12 +25,12 @@
int
virQEMUQAPISchemaPathGet(const char *query,
- virHashTablePtr schema,
+ GHashTable *schema,
virJSONValuePtr *entry);
bool
virQEMUQAPISchemaPathExists(const char *query,
- virHashTablePtr schema);
+ GHashTable *schema);
-virHashTablePtr
+GHashTable *
virQEMUQAPISchemaConvert(virJSONValuePtr schemareply);
diff --git a/src/qemu/qemu_snapshot.c b/src/qemu/qemu_snapshot.c
index a6241ab5d4..8e3540bbc1 100644
--- a/src/qemu/qemu_snapshot.c
+++ b/src/qemu/qemu_snapshot.c
@@ -901,7 +901,7 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuSnapshotDiskContext,
qemuSnapshotDiskContextCl
static int
qemuSnapshotDiskBitmapsPropagate(qemuSnapshotDiskDataPtr dd,
virJSONValuePtr actions,
- virHashTablePtr blockNamedNodeData)
+ GHashTable *blockNamedNodeData)
{
qemuBlockNamedNodeDataPtr entry;
size_t i;
@@ -932,7 +932,7 @@ qemuSnapshotDiskPrepareOneBlockdev(virQEMUDriverPtr driver,
qemuSnapshotDiskDataPtr dd,
virQEMUDriverConfigPtr cfg,
bool reuse,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
@@ -983,7 +983,7 @@ qemuSnapshotDiskPrepareOne(virDomainObjPtr vm,
virDomainDiskDefPtr disk,
virDomainSnapshotDiskDefPtr snapdisk,
qemuSnapshotDiskDataPtr dd,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
bool reuse,
bool updateConfig,
qemuDomainAsyncJob asyncJob,
@@ -1099,7 +1099,7 @@ qemuSnapshotDiskPrepareActiveExternal(virDomainObjPtr vm,
virDomainMomentObjPtr snap,
virQEMUDriverConfigPtr cfg,
bool reuse,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
qemuDomainAsyncJob asyncJob)
{
g_autoptr(qemuSnapshotDiskContext) snapctxt = NULL;
@@ -1130,7 +1130,7 @@ qemuSnapshotDiskPrepareActiveExternal(virDomainObjPtr vm,
static qemuSnapshotDiskContextPtr
qemuSnapshotDiskPrepareDisksTransient(virDomainObjPtr vm,
virQEMUDriverConfigPtr cfg,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
qemuDomainAsyncJob asyncJob)
{
g_autoptr(qemuSnapshotDiskContext) snapctxt = NULL;
@@ -1279,7 +1279,7 @@ qemuSnapshotDiskCreate(qemuSnapshotDiskContextPtr snapctxt,
static int
qemuSnapshotCreateActiveExternalDisks(virDomainObjPtr vm,
virDomainMomentObjPtr snap,
- virHashTablePtr blockNamedNodeData,
+ GHashTable *blockNamedNodeData,
unsigned int flags,
virQEMUDriverConfigPtr cfg,
qemuDomainAsyncJob asyncJob)
@@ -1320,7 +1320,7 @@ qemuSnapshotCreateDisksTransient(virDomainObjPtr vm,
virQEMUDriverPtr driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(qemuSnapshotDiskContext) snapctxt = NULL;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV)) {
if (!(blockNamedNodeData = qemuBlockGetNamedNodeData(vm, asyncJob)))
@@ -1362,7 +1362,7 @@ qemuSnapshotCreateActiveExternal(virQEMUDriverPtr driver,
int compressed;
g_autoptr(virCommand) compressor = NULL;
virQEMUSaveDataPtr data = NULL;
- g_autoptr(virHashTable) blockNamedNodeData = NULL;
+ g_autoptr(GHashTable) blockNamedNodeData = NULL;
/* If quiesce was requested, then issue a freeze command, and a
* counterpart thaw command when it is actually sent to agent.
diff --git a/src/rpc/virnetdaemon.c b/src/rpc/virnetdaemon.c
index 525cbb3ce6..5f0f078fac 100644
--- a/src/rpc/virnetdaemon.c
+++ b/src/rpc/virnetdaemon.c
@@ -66,7 +66,7 @@ struct _virNetDaemon {
int sigwatch;
#endif /* !WIN32 */
- virHashTablePtr servers;
+ GHashTable *servers;
virJSONValuePtr srvObject;
virNetDaemonShutdownCallback shutdownPrepareCb;
diff --git a/src/security/security_selinux.c b/src/security/security_selinux.c
index 6681ce194b..c0e76b2222 100644
--- a/src/security/security_selinux.c
+++ b/src/security/security_selinux.c
@@ -58,7 +58,7 @@ struct _virSecuritySELinuxData {
char *alt_domain_context;
char *file_context;
char *content_context;
- virHashTablePtr mcs;
+ GHashTable *mcs;
bool skipAllLabel;
struct selabel_handle *label_handle;
};
diff --git a/src/util/virfilecache.c b/src/util/virfilecache.c
index cfb1d1d247..a761a01b25 100644
--- a/src/util/virfilecache.c
+++ b/src/util/virfilecache.c
@@ -47,7 +47,7 @@ VIR_LOG_INIT("util.filecache");
struct _virFileCache {
virObjectLockable parent;
- virHashTablePtr table;
+ GHashTable *table;
char *dir;
char *suffix;
diff --git a/src/util/virhash.c b/src/util/virhash.c
index 6d03d4035f..a7d119f8bc 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -33,7 +33,7 @@ VIR_LOG_INIT("util.hash");
struct _virHashAtomic {
virObjectLockable parent;
- virHashTablePtr hash;
+ GHashTable *hash;
};
static virClassPtr virHashAtomicClass;
@@ -78,11 +78,11 @@ virHashTableStringKey(const void *vkey)
* virHashNew:
* @dataFree: callback to free data
*
- * Create a new virHashTablePtr.
+ * Create a new GHashTable *.
*
* Returns the newly created object.
*/
-virHashTablePtr
+GHashTable *
virHashNew(virHashDataFree dataFree)
{
ignore_value(virHashTableSeedInitialize());
@@ -127,7 +127,7 @@ virHashAtomicDispose(void *obj)
* deallocated with function provided at creation time.
*/
void
-virHashFree(virHashTablePtr table)
+virHashFree(GHashTable *table)
{
if (table == NULL)
return;
@@ -148,7 +148,7 @@ virHashFree(virHashTablePtr table)
* Returns 0 the addition succeeded and -1 in case of error.
*/
int
-virHashAddEntry(virHashTablePtr table, const char *name, void *userdata)
+virHashAddEntry(GHashTable *table, const char *name, void *userdata)
{
if (!table || !name)
return -1;
@@ -177,7 +177,7 @@ virHashAddEntry(virHashTablePtr table, const char *name, void
*userdata)
* Returns 0 the addition succeeded and -1 in case of error.
*/
int
-virHashUpdateEntry(virHashTablePtr table, const char *name,
+virHashUpdateEntry(GHashTable *table, const char *name,
void *userdata)
{
if (!table || !name)
@@ -213,7 +213,7 @@ virHashAtomicUpdate(virHashAtomicPtr table,
* Returns a pointer to the userdata
*/
void *
-virHashLookup(virHashTablePtr table,
+virHashLookup(GHashTable *table,
const char *name)
{
if (!table || !name)
@@ -233,7 +233,7 @@ virHashLookup(virHashTablePtr table,
* Returns true if the entry exists and false otherwise
*/
bool
-virHashHasEntry(virHashTablePtr table,
+virHashHasEntry(GHashTable *table,
const char *name)
{
if (!table || !name)
@@ -253,7 +253,7 @@ virHashHasEntry(virHashTablePtr table,
*
* Returns a pointer to the userdata
*/
-void *virHashSteal(virHashTablePtr table, const char *name)
+void *virHashSteal(GHashTable *table, const char *name)
{
g_autofree void *orig_name = NULL;
void *val = NULL;
@@ -294,7 +294,7 @@ virHashAtomicSteal(virHashAtomicPtr table,
* -1 in case of error
*/
ssize_t
-virHashSize(virHashTablePtr table)
+virHashSize(GHashTable *table)
{
if (table == NULL)
return -1;
@@ -315,7 +315,7 @@ virHashSize(virHashTablePtr table)
* Returns 0 if the removal succeeded and -1 in case of error or not found.
*/
int
-virHashRemoveEntry(virHashTablePtr table,
+virHashRemoveEntry(GHashTable *table,
const char *name)
{
if (!table || !name)
@@ -356,7 +356,7 @@ virHashRemoveEntry(virHashTablePtr table,
* Returns 0 on success or -1 on failure.
*/
int
-virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque)
+virHashForEach(GHashTable *table, virHashIterator iter, void *opaque)
{
GHashTableIter htitr;
void *key;
@@ -377,7 +377,7 @@ virHashForEach(virHashTablePtr table, virHashIterator iter, void
*opaque)
int
-virHashForEachSafe(virHashTablePtr table,
+virHashForEachSafe(GHashTable *table,
virHashIterator iter,
void *opaque)
{
@@ -397,7 +397,7 @@ virHashForEachSafe(virHashTablePtr table,
int
-virHashForEachSorted(virHashTablePtr table,
+virHashForEachSorted(GHashTable *table,
virHashIterator iter,
void *opaque)
{
@@ -448,7 +448,7 @@ virHashSearcherWrapFunc(gpointer key,
* Returns number of items removed on success, -1 on failure
*/
ssize_t
-virHashRemoveSet(virHashTablePtr table,
+virHashRemoveSet(GHashTable *table,
virHashSearcher iter,
const void *opaque)
{
@@ -468,7 +468,7 @@ virHashRemoveSet(virHashTablePtr table,
* deallocated with the function provided at creation time.
*/
void
-virHashRemoveAll(virHashTablePtr table)
+virHashRemoveAll(GHashTable *table)
{
if (!table)
return;
@@ -489,7 +489,7 @@ virHashRemoveAll(virHashTablePtr table)
* The elements are processed in a undefined order. Caller is
* responsible for freeing the @name.
*/
-void *virHashSearch(virHashTablePtr table,
+void *virHashSearch(GHashTable *table,
virHashSearcher iter,
const void *opaque,
char **name)
@@ -522,7 +522,7 @@ virHashGetItemsKeySorter(const void *va,
virHashKeyValuePairPtr
-virHashGetItems(virHashTablePtr table,
+virHashGetItems(GHashTable *table,
size_t *nitems,
bool sortKeys)
{
@@ -560,7 +560,7 @@ virHashGetItems(virHashTablePtr table,
struct virHashEqualData
{
bool equal;
- virHashTablePtr table2;
+ GHashTable *table2;
virHashValueComparator compar;
};
@@ -581,8 +581,8 @@ static int virHashEqualSearcher(const void *payload, const char
*name,
return 0;
}
-bool virHashEqual(virHashTablePtr table1,
- virHashTablePtr table2,
+bool virHashEqual(GHashTable *table1,
+ GHashTable *table2,
virHashValueComparator compar)
{
struct virHashEqualData data = {
diff --git a/src/util/virhash.h b/src/util/virhash.h
index 70f74dbc5f..8b4e844eb4 100644
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -9,12 +9,6 @@
#pragma once
-/*
- * The hash table.
- */
-typedef GHashTable virHashTable;
-typedef virHashTable *virHashTablePtr;
-
typedef struct _virHashAtomic virHashAtomic;
typedef virHashAtomic *virHashAtomicPtr;
@@ -57,17 +51,17 @@ typedef int (*virHashSearcher) (const void *payload, const char
*name,
/*
* Constructor and destructor.
*/
-virHashTablePtr virHashNew(virHashDataFree dataFree);
+GHashTable *virHashNew(virHashDataFree dataFree);
virHashAtomicPtr virHashAtomicNew(virHashDataFree dataFree);
-void virHashFree(virHashTablePtr table);
-ssize_t virHashSize(virHashTablePtr table);
+void virHashFree(GHashTable *table);
+ssize_t virHashSize(GHashTable *table);
/*
* Add a new entry to the hash table.
*/
-int virHashAddEntry(virHashTablePtr table,
+int virHashAddEntry(GHashTable *table,
const char *name, void *userdata);
-int virHashUpdateEntry(virHashTablePtr table,
+int virHashUpdateEntry(GHashTable *table,
const char *name,
void *userdata);
int virHashAtomicUpdate(virHashAtomicPtr table,
@@ -77,24 +71,24 @@ int virHashAtomicUpdate(virHashAtomicPtr table,
/*
* Remove an entry from the hash table.
*/
-int virHashRemoveEntry(virHashTablePtr table,
+int virHashRemoveEntry(GHashTable *table,
const char *name);
/*
* Remove all entries from the hash table.
*/
-void virHashRemoveAll(virHashTablePtr table);
+void virHashRemoveAll(GHashTable *table);
/*
* Retrieve the userdata.
*/
-void *virHashLookup(virHashTablePtr table, const char *name);
-bool virHashHasEntry(virHashTablePtr table, const char *name);
+void *virHashLookup(GHashTable *table, const char *name);
+bool virHashHasEntry(GHashTable *table, const char *name);
/*
* Retrieve & remove the userdata.
*/
-void *virHashSteal(virHashTablePtr table, const char *name);
+void *virHashSteal(GHashTable *table, const char *name);
void *virHashAtomicSteal(virHashAtomicPtr table,
const char *name);
@@ -116,7 +110,7 @@ struct _virHashKeyValuePair {
const void *key;
const void *value;
};
-virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table,
+virHashKeyValuePairPtr virHashGetItems(GHashTable *table,
size_t *nitems,
bool sortedKeys);
@@ -127,19 +121,17 @@ virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table,
* of two keys.
*/
typedef int (*virHashValueComparator)(const void *value1, const void *value2);
-bool virHashEqual(virHashTablePtr table1,
- virHashTablePtr table2,
+bool virHashEqual(GHashTable *table1,
+ GHashTable *table2,
virHashValueComparator compar);
/*
* Iterators
*/
-int virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque);
-int virHashForEachSafe(virHashTablePtr table, virHashIterator iter, void *opaque);
-int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void *opaque);
-ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void
*opaque);
-void *virHashSearch(virHashTablePtr table, virHashSearcher iter,
+int virHashForEach(GHashTable *table, virHashIterator iter, void *opaque);
+int virHashForEachSafe(GHashTable *table, virHashIterator iter, void *opaque);
+int virHashForEachSorted(GHashTable *table, virHashIterator iter, void *opaque);
+ssize_t virHashRemoveSet(GHashTable *table, virHashSearcher iter, const void *opaque);
+void *virHashSearch(GHashTable *table, virHashSearcher iter,
const void *opaque, char **name);
-
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, g_hash_table_unref);
diff --git a/src/util/viriptables.c b/src/util/viriptables.c
index beab42be26..9cfbc9f2aa 100644
--- a/src/util/viriptables.c
+++ b/src/util/viriptables.c
@@ -70,8 +70,8 @@ iptablesPrivateChainCreate(virFirewallPtr fw,
void *opaque)
{
iptablesGlobalChainData *data = opaque;
- virHashTablePtr chains = NULL;
- virHashTablePtr links = NULL;
+ GHashTable *chains = NULL;
+ GHashTable *links = NULL;
const char *const *tmp;
int ret = -1;
size_t i;
diff --git a/src/util/virlockspace.c b/src/util/virlockspace.c
index d39f2c026f..b90e13f506 100644
--- a/src/util/virlockspace.c
+++ b/src/util/virlockspace.c
@@ -58,7 +58,7 @@ struct _virLockSpace {
char *dir;
virMutex lock;
- virHashTablePtr resources;
+ GHashTable *resources;
};
diff --git a/src/util/virmacmap.c b/src/util/virmacmap.c
index fe71b06dd7..f9047d0fb1 100644
--- a/src/util/virmacmap.c
+++ b/src/util/virmacmap.c
@@ -43,7 +43,7 @@ VIR_LOG_INIT("util.virmacmap");
struct virMacMap {
virObjectLockable parent;
- virHashTablePtr macs;
+ GHashTable *macs;
};
diff --git a/src/util/virstoragefile.c b/src/util/virstoragefile.c
index 33db43cd92..35e6dcf5de 100644
--- a/src/util/virstoragefile.c
+++ b/src/util/virstoragefile.c
@@ -4291,7 +4291,7 @@ virStorageFileCanonicalizePath(const char *path,
virStorageFileSimplifyPathReadlinkCallback cb,
void *cbdata)
{
- virHashTablePtr cycle = NULL;
+ GHashTable *cycle = NULL;
bool beginSlash = false;
bool beginDoubleSlash = false;
char **components = NULL;
@@ -5160,7 +5160,7 @@ virStorageFileGetMetadataRecurseReadHeader(virStorageSourcePtr src,
gid_t gid,
char **buf,
size_t *headerLen,
- virHashTablePtr cycle)
+ GHashTable *cycle)
{
int ret = -1;
const char *uniqueName;
@@ -5205,7 +5205,7 @@ virStorageFileGetMetadataRecurse(virStorageSourcePtr src,
virStorageSourcePtr parent,
uid_t uid, gid_t gid,
bool report_broken,
- virHashTablePtr cycle,
+ GHashTable *cycle,
unsigned int depth)
{
virStorageFileFormat orig_format = src->format;
@@ -5309,7 +5309,7 @@ virStorageFileGetMetadata(virStorageSourcePtr src,
uid_t uid, gid_t gid,
bool report_broken)
{
- virHashTablePtr cycle = NULL;
+ GHashTable *cycle = NULL;
virStorageType actualType = virStorageSourceGetActualType(src);
int ret = -1;
diff --git a/src/util/virsystemd.c b/src/util/virsystemd.c
index 09f80a1619..de8763033d 100644
--- a/src/util/virsystemd.c
+++ b/src/util/virsystemd.c
@@ -45,7 +45,7 @@ VIR_LOG_INIT("util.systemd");
#endif
struct _virSystemdActivation {
- virHashTablePtr fds;
+ GHashTable *fds;
};
typedef struct _virSystemdActivationEntry virSystemdActivationEntry;
diff --git a/tests/nwfilterxml2firewalltest.c b/tests/nwfilterxml2firewalltest.c
index 30f3dab97e..f3fbacce59 100644
--- a/tests/nwfilterxml2firewalltest.c
+++ b/tests/nwfilterxml2firewalltest.c
@@ -145,11 +145,11 @@ static const char *commonRules[] = {
};
-static virHashTablePtr
-virNWFilterCreateVarsFrom(virHashTablePtr vars1,
- virHashTablePtr vars2)
+static GHashTable *
+virNWFilterCreateVarsFrom(GHashTable *vars1,
+ GHashTable *vars2)
{
- virHashTablePtr res = virHashNew(virNWFilterVarValueHashFree);
+ GHashTable *res = virHashNew(virNWFilterVarValueHashFree);
if (!res)
return NULL;
@@ -197,13 +197,13 @@ virNWFilterInstReset(virNWFilterInstPtr inst)
static int
virNWFilterDefToInst(const char *xml,
- virHashTablePtr vars,
+ GHashTable *vars,
virNWFilterInstPtr inst);
static int
virNWFilterRuleDefToRuleInst(virNWFilterDefPtr def,
virNWFilterRuleDefPtr rule,
- virHashTablePtr vars,
+ GHashTable *vars,
virNWFilterInstPtr inst)
{
virNWFilterRuleInstPtr ruleinst;
@@ -235,10 +235,10 @@ virNWFilterRuleDefToRuleInst(virNWFilterDefPtr def,
static int
virNWFilterIncludeDefToRuleInst(virNWFilterIncludeDefPtr inc,
- virHashTablePtr vars,
+ GHashTable *vars,
virNWFilterInstPtr inst)
{
- virHashTablePtr tmpvars = NULL;
+ GHashTable *tmpvars = NULL;
int ret = -1;
char *xml;
@@ -266,7 +266,7 @@ virNWFilterIncludeDefToRuleInst(virNWFilterIncludeDefPtr inc,
static int
virNWFilterDefToInst(const char *xml,
- virHashTablePtr vars,
+ GHashTable *vars,
virNWFilterInstPtr inst)
{
size_t i;
@@ -322,7 +322,7 @@ static void testRemoveCommonRules(char *rules)
}
-static int testSetOneParameter(virHashTablePtr vars,
+static int testSetOneParameter(GHashTable *vars,
const char *name,
const char *value)
{
@@ -344,7 +344,7 @@ static int testSetOneParameter(virHashTablePtr vars,
return 0;
}
-static int testSetDefaultParameters(virHashTablePtr vars)
+static int testSetDefaultParameters(GHashTable *vars)
{
if (testSetOneParameter(vars, "IPSETNAME", "tck_test") < 0 ||
testSetOneParameter(vars, "A", "1.1.1.1") ||
@@ -368,7 +368,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
{
char *actualargv = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virHashTablePtr vars = virHashNew(virNWFilterVarValueHashFree);
+ GHashTable *vars = virHashNew(virNWFilterVarValueHashFree);
virNWFilterInst inst;
int ret = -1;
diff --git a/tests/qemublocktest.c b/tests/qemublocktest.c
index 70dce54d0e..294915c59c 100644
--- a/tests/qemublocktest.c
+++ b/tests/qemublocktest.c
@@ -43,7 +43,7 @@ struct testBackingXMLjsonXMLdata {
int type;
const char *xml;
bool legacy;
- virHashTablePtr schema;
+ GHashTable *schema;
virJSONValuePtr schemaroot;
};
@@ -133,7 +133,7 @@ static const char *testJSONtoJSONPath = abs_srcdir
"/qemublocktestdata/jsontojso
struct testJSONtoJSONData {
const char *name;
- virHashTablePtr schema;
+ GHashTable *schema;
virJSONValuePtr schemaroot;
};
@@ -192,7 +192,7 @@ struct testQemuDiskXMLToJSONImageData {
struct testQemuDiskXMLToJSONData {
virQEMUDriverPtr driver;
- virHashTablePtr schema;
+ GHashTable *schema;
virJSONValuePtr schemaroot;
const char *name;
bool fail;
@@ -459,7 +459,7 @@ testQemuDiskXMLToPropsValidateFileSrcOnly(const void *opaque)
struct testQemuImageCreateData {
const char *name;
const char *backingname;
- virHashTablePtr schema;
+ GHashTable *schema;
virJSONValuePtr schemaroot;
virQEMUDriverPtr driver;
virQEMUCapsPtr qemuCaps;
@@ -586,7 +586,7 @@ testQemuImageCreate(const void *opaque)
static const char *bitmapDetectPrefix = "qemublocktestdata/bitmap/";
static void
-testQemuDetectBitmapsWorker(virHashTablePtr nodedata,
+testQemuDetectBitmapsWorker(GHashTable *nodedata,
const char *nodename,
virBufferPtr buf)
{
@@ -617,7 +617,7 @@ testQemuDetectBitmaps(const void *opaque)
{
const char *name = opaque;
g_autoptr(virJSONValue) nodedatajson = NULL;
- g_autoptr(virHashTable) nodedata = NULL;
+ g_autoptr(GHashTable) nodedata = NULL;
g_autofree char *actual = NULL;
g_autofree char *expectpath = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
@@ -729,7 +729,7 @@ testQemuBackupIncrementalBitmapCalculate(const void *opaque)
{
const struct testQemuBackupIncrementalBitmapCalculateData *data = opaque;
g_autoptr(virJSONValue) nodedatajson = NULL;
- g_autoptr(virHashTable) nodedata = NULL;
+ g_autoptr(GHashTable) nodedata = NULL;
g_autoptr(virJSONValue) actions = virJSONValueNewArray();
g_autofree char *expectpath = NULL;
g_autoptr(virStorageSource) target = NULL;
@@ -784,7 +784,7 @@ testQemuCheckpointDelete(const void *opaque)
g_autofree char *expectpath = NULL;
g_autoptr(virJSONValue) actions = NULL;
g_autoptr(virJSONValue) nodedatajson = NULL;
- g_autoptr(virHashTable) nodedata = NULL;
+ g_autoptr(GHashTable) nodedata = NULL;
g_autoptr(GSList) reopenimages = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
@@ -834,7 +834,7 @@ testQemuBlockBitmapValidate(const void *opaque)
{
const struct testQemuBlockBitmapValidateData *data = opaque;
g_autoptr(virJSONValue) nodedatajson = NULL;
- g_autoptr(virHashTable) nodedata = NULL;
+ g_autoptr(GHashTable) nodedata = NULL;
bool actual;
if (!(nodedatajson = virTestLoadFileJSON(bitmapDetectPrefix, data->name,
@@ -875,7 +875,7 @@ testQemuBlockBitmapBlockcopy(const void *opaque)
g_autofree char *expectpath = NULL;
g_autoptr(virJSONValue) actions = NULL;
g_autoptr(virJSONValue) nodedatajson = NULL;
- g_autoptr(virHashTable) nodedata = NULL;
+ g_autoptr(GHashTable) nodedata = NULL;
g_autoptr(virStorageSource) fakemirror = virStorageSourceNew();
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
@@ -927,7 +927,7 @@ testQemuBlockBitmapBlockcommit(const void *opaque)
g_autofree char *expectpath = NULL;
g_autoptr(virJSONValue) actionsMerge = NULL;
g_autoptr(virJSONValue) nodedatajson = NULL;
- g_autoptr(virHashTable) nodedata = NULL;
+ g_autoptr(GHashTable) nodedata = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
bool active = data->top == data->chain;
@@ -975,7 +975,7 @@ mymain(void)
struct testQemuBlockBitmapBlockcommitData blockbitmapblockcommitdata;
char *capslatest_x86_64 = NULL;
g_autoptr(virQEMUCaps) caps_x86_64 = NULL;
- g_autoptr(virHashTable) qmp_schema_x86_64 = NULL;
+ g_autoptr(GHashTable) qmp_schema_x86_64 = NULL;
virJSONValuePtr qmp_schemaroot_x86_64_blockdev_add = NULL;
g_autoptr(virStorageSource) bitmapSourceChain = NULL;
diff --git a/tests/qemuhotplugtest.c b/tests/qemuhotplugtest.c
index f0f17022b8..776fb019f3 100644
--- a/tests/qemuhotplugtest.c
+++ b/tests/qemuhotplugtest.c
@@ -410,7 +410,7 @@ static struct testQemuHotplugCpuData *
testQemuHotplugCpuPrepare(const char *test,
bool modern,
bool fail,
- virHashTablePtr qmpschema)
+ GHashTable *qmpschema)
{
qemuDomainObjPrivatePtr priv = NULL;
virCapsPtr caps = NULL;
@@ -510,7 +510,7 @@ struct testQemuHotplugCpuParams {
bool state;
bool modern;
bool fail;
- virHashTablePtr schema;
+ GHashTable *schema;
};
@@ -594,7 +594,7 @@ testQemuHotplugCpuIndividual(const void *opaque)
static int
mymain(void)
{
- g_autoptr(virHashTable) qmpschema = NULL;
+ g_autoptr(GHashTable) qmpschema = NULL;
int ret = 0;
struct qemuHotplugTestData data = {0};
struct testQemuHotplugCpuParams cpudata;
diff --git a/tests/qemumigparamstest.c b/tests/qemumigparamstest.c
index c4fd575401..bfa60358c0 100644
--- a/tests/qemumigparamstest.c
+++ b/tests/qemumigparamstest.c
@@ -38,7 +38,7 @@ typedef struct _qemuMigParamsData qemuMigParamsData;
struct _qemuMigParamsData {
virDomainXMLOptionPtr xmlopt;
const char *name;
- virHashTablePtr qmpschema;
+ GHashTable *qmpschema;
};
@@ -191,7 +191,7 @@ qemuMigParamsTestJSON(const void *opaque)
static int
mymain(void)
{
- g_autoptr(virHashTable) qmpschema = NULL;
+ g_autoptr(GHashTable) qmpschema = NULL;
virQEMUDriver driver;
int ret = 0;
diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c
index cd52a0019a..25ebf06eb0 100644
--- a/tests/qemumonitorjsontest.c
+++ b/tests/qemumonitorjsontest.c
@@ -45,7 +45,7 @@ struct _testQemuMonitorJSONSimpleFuncData {
int (* func) (qemuMonitorPtr mon);
virDomainXMLOptionPtr xmlopt;
const char *reply;
- virHashTablePtr schema;
+ GHashTable *schema;
bool allowDeprecated;
bool allowRemoved;
};
@@ -53,7 +53,7 @@ struct _testQemuMonitorJSONSimpleFuncData {
typedef struct _testGenericData testGenericData;
struct _testGenericData {
virDomainXMLOptionPtr xmlopt;
- virHashTablePtr schema;
+ GHashTable *schema;
};
const char *queryBlockReply =
@@ -771,7 +771,7 @@ testQemuMonitorJSONAttachChardev(const void *opaque)
static int
qemuMonitorJSONTestAttachOneChardev(virDomainXMLOptionPtr xmlopt,
- virHashTablePtr schema,
+ GHashTable *schema,
const char *label,
virDomainChrSourceDefPtr chr,
const char *expectargs,
@@ -818,7 +818,7 @@ qemuMonitorJSONTestAttachOneChardev(virDomainXMLOptionPtr xmlopt,
static int
qemuMonitorJSONTestAttachChardev(virDomainXMLOptionPtr xmlopt,
- virHashTablePtr schema)
+ GHashTable *schema)
{
virDomainChrSourceDef chr;
int ret = 0;
@@ -1642,7 +1642,8 @@ testQemuMonitorJSONqemuMonitorJSONGetBlockInfo(const void *opaque)
const testGenericData *data = opaque;
virDomainXMLOptionPtr xmlopt = data->xmlopt;
int ret = -1;
- virHashTablePtr blockDevices = NULL, expectedBlockDevices = NULL;
+ GHashTable *blockDevices = NULL;
+ GHashTable *expectedBlockDevices = NULL;
struct qemuDomainDiskInfo *info;
g_autoptr(qemuMonitorTest) test = NULL;
@@ -1716,7 +1717,7 @@ testQemuMonitorJSONqemuMonitorJSONGetAllBlockStatsInfo(const void
*opaque)
{
const testGenericData *data = opaque;
virDomainXMLOptionPtr xmlopt = data->xmlopt;
- virHashTablePtr blockstats = NULL;
+ GHashTable *blockstats = NULL;
qemuBlockStatsPtr stats;
int ret = -1;
g_autoptr(qemuMonitorTest) test = NULL;
@@ -2008,7 +2009,8 @@ testQemuMonitorJSONqemuMonitorJSONGetChardevInfo(const void
*opaque)
const testGenericData *data = opaque;
virDomainXMLOptionPtr xmlopt = data->xmlopt;
int ret = -1;
- virHashTablePtr info = NULL, expectedInfo = NULL;
+ GHashTable *info = NULL;
+ GHashTable *expectedInfo = NULL;
qemuMonitorChardevInfo info0 = { NULL, VIR_DOMAIN_CHR_DEVICE_STATE_DEFAULT };
qemuMonitorChardevInfo info1 = { (char *) "/dev/pts/21",
VIR_DOMAIN_CHR_DEVICE_STATE_CONNECTED };
qemuMonitorChardevInfo info2 = { (char *) "/dev/pts/20",
VIR_DOMAIN_CHR_DEVICE_STATE_DEFAULT };
@@ -2404,7 +2406,7 @@ testQemuMonitorJSONqemuMonitorJSONGetDumpGuestMemoryCapability(const
void *opaqu
struct testCPUData {
const char *name;
virDomainXMLOptionPtr xmlopt;
- virHashTablePtr schema;
+ GHashTable *schema;
};
@@ -2588,7 +2590,7 @@ struct testCPUInfoData {
size_t maxvcpus;
virDomainXMLOptionPtr xmlopt;
bool fast;
- virHashTablePtr schema;
+ GHashTable *schema;
};
@@ -2773,7 +2775,7 @@ testBlockNodeNameDetect(const void *opaque)
char *actual = NULL;
virJSONValuePtr namedNodesJson = NULL;
virJSONValuePtr blockstatsJson = NULL;
- virHashTablePtr nodedata = NULL;
+ GHashTable *nodedata = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int ret = -1;
@@ -2815,7 +2817,7 @@ testBlockNodeNameDetect(const void *opaque)
struct testQAPISchemaData {
- virHashTablePtr schema;
+ GHashTable *schema;
const char *name;
const char *query;
const char *json;
@@ -2895,7 +2897,7 @@ testQAPISchemaValidate(const void *opaque)
static int
testQAPISchemaObjectDeviceAdd(const void *opaque)
{
- virHashTablePtr schema = (virHashTablePtr) opaque;
+ GHashTable *schema = (GHashTable *) opaque;
virJSONValuePtr entry;
if (virQEMUQAPISchemaPathGet("device_add/arg-type", schema, &entry)
< 0) {
diff --git a/tests/qemumonitortestutils.c b/tests/qemumonitortestutils.c
index 2fc26577a7..c4f7082655 100644
--- a/tests/qemumonitortestutils.c
+++ b/tests/qemumonitortestutils.c
@@ -84,7 +84,7 @@ struct _qemuMonitorTest {
qemuMonitorTestItemPtr *items;
virDomainObjPtr vm;
- virHashTablePtr qapischema;
+ GHashTable *qapischema;
};
@@ -1141,7 +1141,7 @@ qemuMonitorTestNew(virDomainXMLOptionPtr xmlopt,
virDomainObjPtr vm,
virQEMUDriverPtr driver,
const char *greeting,
- virHashTablePtr schema)
+ GHashTable *schema)
{
qemuMonitorTestPtr test = NULL;
virDomainChrSourceDef src;
@@ -1341,7 +1341,7 @@ qemuMonitorTestPtr
qemuMonitorTestNewFromFileFull(const char *fileName,
virQEMUDriverPtr driver,
virDomainObjPtr vm,
- virHashTablePtr qmpschema)
+ GHashTable *qmpschema)
{
qemuMonitorTestPtr ret = NULL;
g_autofree char *jsonstr = NULL;
diff --git a/tests/qemumonitortestutils.h b/tests/qemumonitortestutils.h
index 1073ef4100..ec40f29e75 100644
--- a/tests/qemumonitortestutils.h
+++ b/tests/qemumonitortestutils.h
@@ -86,7 +86,7 @@ qemuMonitorTestPtr qemuMonitorTestNew(virDomainXMLOptionPtr xmlopt,
virDomainObjPtr vm,
virQEMUDriverPtr driver,
const char *greeting,
- virHashTablePtr schema);
+ GHashTable *schema);
qemuMonitorTestPtr qemuMonitorTestNewFromFile(const char *fileName,
virDomainXMLOptionPtr xmlopt,
@@ -94,7 +94,7 @@ qemuMonitorTestPtr qemuMonitorTestNewFromFile(const char *fileName,
qemuMonitorTestPtr qemuMonitorTestNewFromFileFull(const char *fileName,
virQEMUDriverPtr driver,
virDomainObjPtr vm,
- virHashTablePtr qmpschema);
+ GHashTable *qmpschema);
qemuMonitorTestPtr qemuMonitorTestNewAgent(virDomainXMLOptionPtr xmlopt);
diff --git a/tests/qemusecuritymock.c b/tests/qemusecuritymock.c
index 543a5f7f3f..5203853809 100644
--- a/tests/qemusecuritymock.c
+++ b/tests/qemusecuritymock.c
@@ -63,13 +63,13 @@ virMutex m = VIR_MUTEX_INITIALIZER;
* "$path:$name" and value is just XATTR "$value". We don't need
* to list XATTRs a path has, therefore we don't need something
* more clever. */
-virHashTablePtr xattr_paths = NULL;
+GHashTable *xattr_paths = NULL;
/* The UID:GID is stored in a hash table. Again, for simplicity,
* the path is the key and the value is an uint32_t , where
* the lower half is UID and the higher is GID. */
-virHashTablePtr chown_paths = NULL;
+GHashTable *chown_paths = NULL;
static void
diff --git a/tests/qemuxml2argvtest.c b/tests/qemuxml2argvtest.c
index ef8a871a19..69316ee23a 100644
--- a/tests/qemuxml2argvtest.c
+++ b/tests/qemuxml2argvtest.c
@@ -521,7 +521,7 @@ testCompareXMLToArgvValidateSchema(virQEMUDriverPtr drv,
g_autoptr(virDomainObj) vm = NULL;
size_t nargs = 0;
size_t i;
- g_autoptr(virHashTable) schema = NULL;
+ g_autoptr(GHashTable) schema = NULL;
g_autoptr(virCommand) cmd = NULL;
unsigned int parseFlags = info->parseFlags;
@@ -767,7 +767,7 @@ mymain(void)
{
int ret = 0;
g_autofree char *fakerootdir = NULL;
- g_autoptr(virHashTable) capslatest = NULL;
+ g_autoptr(GHashTable) capslatest = NULL;
fakerootdir = g_strdup(FAKEROOTDIRTEMPLATE);
diff --git a/tests/qemuxml2xmltest.c b/tests/qemuxml2xmltest.c
index 3e56d0fc50..3e52d82e5f 100644
--- a/tests/qemuxml2xmltest.c
+++ b/tests/qemuxml2xmltest.c
@@ -133,7 +133,7 @@ mymain(void)
int ret = 0;
g_autofree char *fakerootdir = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- g_autoptr(virHashTable) capslatest = NULL;
+ g_autoptr(GHashTable) capslatest = NULL;
g_autoptr(virConnect) conn = NULL;
capslatest = testQemuGetLatestCaps();
diff --git a/tests/testutilsqemu.c b/tests/testutilsqemu.c
index c6848c12a2..23a9777fd8 100644
--- a/tests/testutilsqemu.c
+++ b/tests/testutilsqemu.c
@@ -558,7 +558,7 @@ testQemuGetLatestCapsForArch(const char *arch,
}
-virHashTablePtr
+GHashTable *
testQemuGetLatestCaps(void)
{
const char *archs[] = {
@@ -568,7 +568,7 @@ testQemuGetLatestCaps(void)
"s390x",
"x86_64",
};
- virHashTablePtr capslatest;
+ GHashTable *capslatest;
size_t i;
if (!(capslatest = virHashNew(g_free)))
@@ -664,7 +664,7 @@ testQemuCapsIterate(const char *suffix,
int
testQemuInfoSetArgs(struct testQemuInfo *info,
- virHashTablePtr capslatest, ...)
+ GHashTable *capslatest, ...)
{
va_list argptr;
testQemuInfoArgName argname;
diff --git a/tests/testutilsqemu.h b/tests/testutilsqemu.h
index 79af1be50d..0c6f0ea378 100644
--- a/tests/testutilsqemu.h
+++ b/tests/testutilsqemu.h
@@ -96,7 +96,7 @@ int testQemuCapsSetGIC(virQEMUCapsPtr qemuCaps,
char *testQemuGetLatestCapsForArch(const char *arch,
const char *suffix);
-virHashTablePtr testQemuGetLatestCaps(void);
+GHashTable *testQemuGetLatestCaps(void);
typedef int (*testQemuCapsIterateCallback)(const char *inputDir,
const char *prefix,
@@ -109,7 +109,7 @@ int testQemuCapsIterate(const char *suffix,
void *opaque);
int testQemuInfoSetArgs(struct testQemuInfo *info,
- virHashTablePtr capslatest, ...);
+ GHashTable *capslatest, ...);
void testQemuInfoClear(struct testQemuInfo *info);
#endif
diff --git a/tests/testutilsqemuschema.c b/tests/testutilsqemuschema.c
index 21a58cb4c6..101687e657 100644
--- a/tests/testutilsqemuschema.c
+++ b/tests/testutilsqemuschema.c
@@ -22,7 +22,7 @@
#include "qemu/qemu_qapi.h"
struct testQEMUSchemaValidateCtxt {
- virHashTablePtr schema;
+ GHashTable *schema;
virBufferPtr debug;
bool allowDeprecated;
};
@@ -533,7 +533,7 @@ testQEMUSchemaValidateRecurse(virJSONValuePtr obj,
int
testQEMUSchemaValidate(virJSONValuePtr obj,
virJSONValuePtr root,
- virHashTablePtr schema,
+ GHashTable *schema,
bool allowDeprecated,
virBufferPtr debug)
{
@@ -568,7 +568,7 @@ testQEMUSchemaValidate(virJSONValuePtr obj,
int
testQEMUSchemaValidateCommand(const char *command,
virJSONValuePtr arguments,
- virHashTablePtr schema,
+ GHashTable *schema,
bool allowDeprecated,
bool allowRemoved,
virBufferPtr debug)
@@ -783,7 +783,7 @@ testQEMUSchemaGetLatest(const char *arch)
}
-virHashTablePtr
+GHashTable *
testQEMUSchemaLoadLatest(const char *arch)
{
virJSONValuePtr schema;
@@ -795,7 +795,7 @@ testQEMUSchemaLoadLatest(const char *arch)
}
-virHashTablePtr
+GHashTable *
testQEMUSchemaLoad(const char *filename)
{
virJSONValuePtr schema;
diff --git a/tests/testutilsqemuschema.h b/tests/testutilsqemuschema.h
index 1649ad78b5..6790e96e5e 100644
--- a/tests/testutilsqemuschema.h
+++ b/tests/testutilsqemuschema.h
@@ -25,14 +25,14 @@
int
testQEMUSchemaValidate(virJSONValuePtr obj,
virJSONValuePtr root,
- virHashTablePtr schema,
+ GHashTable *schema,
bool allowDeprecated,
virBufferPtr debug);
int
testQEMUSchemaValidateCommand(const char *command,
virJSONValuePtr arguments,
- virHashTablePtr schema,
+ GHashTable *schema,
bool allowDeprecated,
bool allowRemoved,
virBufferPtr debug);
@@ -45,8 +45,8 @@ testQEMUSchemaEntryMatchTemplate(virJSONValuePtr schemaentry,
virJSONValuePtr
testQEMUSchemaGetLatest(const char* arch);
-virHashTablePtr
+GHashTable *
testQEMUSchemaLoadLatest(const char *arch);
-virHashTablePtr
+GHashTable *
testQEMUSchemaLoad(const char *filename);
diff --git a/tests/virhashtest.c b/tests/virhashtest.c
index 4e1d41395f..41d0e3ffb1 100644
--- a/tests/virhashtest.c
+++ b/tests/virhashtest.c
@@ -14,10 +14,10 @@
VIR_LOG_INIT("tests.hashtest");
-static virHashTablePtr
+static GHashTable *
testHashInit(void)
{
- virHashTablePtr hash;
+ GHashTable *hash;
ssize_t i;
if (!(hash = virHashNew(NULL)))
@@ -55,7 +55,7 @@ testHashCheckForEachCount(void *payload G_GNUC_UNUSED,
}
static int
-testHashCheckCount(virHashTablePtr hash, size_t count)
+testHashCheckCount(GHashTable *hash, size_t count)
{
size_t iter_count = 0;
@@ -85,7 +85,7 @@ struct testInfo {
static int
testHashGrow(const void *data G_GNUC_UNUSED)
{
- virHashTablePtr hash;
+ GHashTable *hash;
int ret = -1;
if (!(hash = testHashInit()))
@@ -106,7 +106,7 @@ static int
testHashUpdate(const void *data G_GNUC_UNUSED)
{
int count = G_N_ELEMENTS(uuids) + G_N_ELEMENTS(uuids_new);
- virHashTablePtr hash;
+ GHashTable *hash;
size_t i;
int ret = -1;
@@ -144,7 +144,7 @@ static int
testHashRemove(const void *data G_GNUC_UNUSED)
{
int count = G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset);
- virHashTablePtr hash;
+ GHashTable *hash;
size_t i;
int ret = -1;
@@ -178,7 +178,7 @@ testHashRemoveForEachSome(void *payload G_GNUC_UNUSED,
const char *name,
void *data)
{
- virHashTablePtr hash = data;
+ GHashTable *hash = data;
size_t i;
for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
@@ -201,7 +201,7 @@ testHashRemoveForEachAll(void *payload G_GNUC_UNUSED,
const char *name,
void *data)
{
- virHashTablePtr hash = data;
+ GHashTable *hash = data;
virHashRemoveEntry(hash, name);
return 0;
@@ -212,7 +212,7 @@ static int
testHashRemoveForEach(const void *data)
{
const struct testInfo *info = data;
- virHashTablePtr hash;
+ GHashTable *hash;
int ret = -1;
if (!(hash = testHashInit()))
@@ -238,7 +238,7 @@ static int
testHashSteal(const void *data G_GNUC_UNUSED)
{
int count = G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset);
- virHashTablePtr hash;
+ GHashTable *hash;
size_t i;
int ret = -1;
@@ -291,7 +291,7 @@ testHashRemoveSetIter(const void *payload G_GNUC_UNUSED,
static int
testHashRemoveSet(const void *data G_GNUC_UNUSED)
{
- virHashTablePtr hash;
+ GHashTable *hash;
int count = 0;
int rcount;
int ret = -1;
@@ -335,7 +335,7 @@ testHashSearchIter(const void *payload G_GNUC_UNUSED,
static int
testHashSearch(const void *data G_GNUC_UNUSED)
{
- virHashTablePtr hash;
+ GHashTable *hash;
void *entry;
int ret = -1;
@@ -364,7 +364,7 @@ testHashSearch(const void *data G_GNUC_UNUSED)
static int
testHashGetItems(const void *data G_GNUC_UNUSED)
{
- virHashTablePtr hash;
+ GHashTable *hash;
virHashKeyValuePairPtr array = NULL;
int ret = -1;
char keya[] = "a";
@@ -419,7 +419,8 @@ testHashEqualCompValue(const void *value1, const void *value2)
static int
testHashEqual(const void *data G_GNUC_UNUSED)
{
- virHashTablePtr hash1, hash2 = NULL;
+ GHashTable *hash1;
+ GHashTable *hash2 = NULL;
int ret = -1;
char keya[] = "a";
char keyb[] = "b";
@@ -480,7 +481,7 @@ testHashEqual(const void *data G_GNUC_UNUSED)
static int
testHashDuplicate(const void *data G_GNUC_UNUSED)
{
- g_autoptr(virHashTable) hash = NULL;
+ g_autoptr(GHashTable) hash = NULL;
if (!(hash = virHashNew(NULL)))
return -1;
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 11/12] util: hash: Add deprecation notices for functions which have g_hash_table replacements
For functions which have reasonable replacement, let's encourage usage
of g_hash_table_ alternatives.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
src/util/virhash.c | 31 ++++++++++++++++++++++++++++++-
1 file changed, 30 insertions(+), 1 deletion(-)
diff --git a/src/util/virhash.c b/src/util/virhash.c
index a7d119f8bc..5d5b6389b5 100644
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -78,7 +78,7 @@ virHashTableStringKey(const void *vkey)
* virHashNew:
* @dataFree: callback to free data
*
- * Create a new GHashTable *.
+ * Create a new GHashTable * for use with string-based keys.
*
* Returns the newly created object.
*/
@@ -125,6 +125,8 @@ virHashAtomicDispose(void *obj)
*
* Free the hash @table and its contents. The userdata is
* deallocated with function provided at creation time.
+ *
+ * Deprecated: consider using g_hash_table_unref instead
*/
void
virHashFree(GHashTable *table)
@@ -145,6 +147,10 @@ virHashFree(GHashTable *table)
* Add the @userdata to the hash @table. This can later be retrieved
* by using @name. Duplicate entries generate errors.
*
+ * Deprecated: Consider using g_hash_table_insert insert. Note that
+ * g_hash_table_instead doesn't fail if entry exists. Also note that
+ * g_hash_table_insert doesn't copy the key.
+ *
* Returns 0 the addition succeeded and -1 in case of error.
*/
int
@@ -174,6 +180,9 @@ virHashAddEntry(GHashTable *table, const char *name, void *userdata)
* by using @name. Existing entry for this tuple
* will be removed and freed with @f if found.
*
+ * Deprecated: consider using g_hash_table_insert insert. Note that
+ * g_hash_table_insert doesn't copy the key.
+ *
* Returns 0 the addition succeeded and -1 in case of error.
*/
int
@@ -210,6 +219,8 @@ virHashAtomicUpdate(virHashAtomicPtr table,
*
* Find the userdata specified by @name
*
+ * Deprecated: consider using g_hash_table_lookup instead
+ *
* Returns a pointer to the userdata
*/
void *
@@ -230,6 +241,8 @@ virHashLookup(GHashTable *table,
*
* Find whether entry specified by @name exists.
*
+ * Deprecated: consider using g_hash_table_contains instead
+ *
* Returns true if the entry exists and false otherwise
*/
bool
@@ -251,6 +264,9 @@ virHashHasEntry(GHashTable *table,
* Find the userdata specified by @name
* and remove it from the hash without freeing it.
*
+ * Deprecated: consider using g_hash_table_steal_extended once we upgrade to
+ * glib 2.58
+ *
* Returns a pointer to the userdata
*/
void *virHashSteal(GHashTable *table, const char *name)
@@ -290,6 +306,8 @@ virHashAtomicSteal(virHashAtomicPtr table,
*
* Query the number of elements installed in the hash @table.
*
+ * Deprecated: consider using g_hash_table_size instead
+ *
* Returns the number of elements in the hash table or
* -1 in case of error
*/
@@ -312,6 +330,8 @@ virHashSize(GHashTable *table)
* it from the hash @table. Existing userdata for this tuple will be removed
* and freed with @f.
*
+ * Deprecated: consider using g_hash_table_remove
+ *
* Returns 0 if the removal succeeded and -1 in case of error or not found.
*/
int
@@ -353,6 +373,9 @@ virHashRemoveEntry(GHashTable *table,
* If @iter fails and returns a negative value, the evaluation is stopped and -1
* is returned.
*
+ * Deprecated: Consider using g_hash_table_foreach as replacement for
+ * virHashForEach, rewrite your code if it would require virHashForEachSafe.
+ *
* Returns 0 on success or -1 on failure.
*/
int
@@ -445,6 +468,8 @@ virHashSearcherWrapFunc(gpointer key,
* will be removed from the hash table & its payload passed to the
* data freer callback registered at creation.
*
+ * Deprecated: consider using g_hash_table_foreach_remove instead
+ *
* Returns number of items removed on success, -1 on failure
*/
ssize_t
@@ -466,6 +491,8 @@ virHashRemoveSet(GHashTable *table,
*
* Free the hash @table's contents. The userdata is
* deallocated with the function provided at creation time.
+ *
+ * Deprecated: consider using g_hash_table_remove_all instead
*/
void
virHashRemoveAll(GHashTable *table)
@@ -488,6 +515,8 @@ virHashRemoveAll(GHashTable *table)
* returns non-zero will be returned by this function.
* The elements are processed in a undefined order. Caller is
* responsible for freeing the @name.
+ *
+ * Deprecated: consider using g_hash_table_find instead
*/
void *virHashSearch(GHashTable *table,
virHashSearcher iter,
--
2.26.2
11:05 a.m.
New subject: [PATCH v2 12/12] tests: Remove 'virhashtest'
There's no much sense to test the remnants of the functions which just
NULL-check prior to handing off to g_hash_table* functions.
Signed-off-by: Peter Krempa <pkrempa(a)redhat.com>
---
tests/meson.build | 1 -
tests/virhashdata.h | 284 -----------------------
tests/virhashtest.c | 539 --------------------------------------------
3 files changed, 824 deletions(-)
delete mode 100644 tests/virhashdata.h
delete mode 100644 tests/virhashtest.c
diff --git a/tests/meson.build b/tests/meson.build
index 6984780066..8decdfa20c 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -310,7 +310,6 @@ tests += [
{ 'name': 'virfilecachetest' },
{ 'name': 'virfiletest' },
{ 'name': 'virfirewalltest' },
- { 'name': 'virhashtest' },
{ 'name': 'virhostcputest', 'link_whole': [
test_file_wrapper_lib ] },
{ 'name': 'virhostdevtest' },
{ 'name': 'viriscsitest' },
diff --git a/tests/virhashdata.h b/tests/virhashdata.h
deleted file mode 100644
index 1b457f2857..0000000000
--- a/tests/virhashdata.h
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see
- * <http://www.gnu.org/licenses/>;.
- */
-
-#pragma once
-
-const char *uuids[] = {
-/* [ 2] */ "a9b02f96-e430-4f7c-a7ff-a647d080447a",
-/* [ 4] */ "202e32ca-f82c-4f13-9266-28dc8d002074",
-/* [ 5] */ "e0233ed8-22da-4a1e-a1a2-2d0343635173",
- "4ce4f92a-e116-4c38-81ca-acebbdcab410",
-/* [ 6] */ "4121c24d-bfc3-45f9-85c6-899679b5cc60",
- "e641740a-85dd-4414-bdbf-37dbaee39e26",
-/* [ 9] */ "a0c94fa8-7d41-4100-8907-9b9209e7954a",
-/* [ 10] */ "d3c7d973-046d-4c49-90bb-7a353aaea8a2",
- "ad15e406-8258-49ad-a47e-cbb955b34220",
-/* [ 11] */ "0979803b-6bcc-4305-917c-079dcc0f1cb4",
-/* [ 12] */ "0311fc3f-e5b1-48f5-ab9e-e577fbfc6b82",
-/* [ 14] */ "512aa755-3c48-456b-9545-3cc6f729444f",
-/* [ 16] */ "43b7e89e-c5cb-44c6-9bdb-7f070d6e5cf7",
-/* [ 17] */ "3e4fd85d-57d8-4d1d-867e-71ba3b898dc3",
-/* [ 18] */ "8433c800-1cda-4bf1-8a3d-879f657e0068",
-/* [ 20] */ "fb55ed30-a8fe-44ab-aa25-4d609c487975",
-/* [ 21] */ "b7fa38f1-f329-430d-8450-57d75175f578",
-/* [ 22] */ "bbbff7ba-73d8-42a0-ace3-dbf39906223a",
-/* [ 23] */ "1ef274ef-2c99-488f-ba25-21da0285d7fe",
-/* [ 26] */ "24e30027-16cf-4848-a4be-6dffae973757",
-/* [ 28] */ "fd056c9c-9f39-43b8-90be-aaff3909a56c",
-/* [ 29] */ "2c53a1dc-3b62-4369-a583-71cad3d1fa98",
- "063b19c7-1c96-4cc8-ac18-bc007f073a13",
-/* [ 32] */ "f210da80-6e0a-4185-a96e-7bd32a779e72",
-/* [ 33] */ "dd557d13-0f6d-460a-8002-9392ce483e50",
-/* [ 34] */ "d16f07e4-f5be-4744-b70a-dc6e26666c44",
-/* [ 35] */ "dafe133f-d48c-4a30-b156-f073725401f5",
-/* [ 36] */ "96dfe074-7236-4898-aad2-81963c23adda",
- "c971ea2e-9410-4b3c-9027-d678a0d9db8d",
-/* [ 38] */ "7b417156-b90a-4450-9c77-e1e94e1c980c",
-/* [ 39] */ "a7334316-6572-47d5-9330-9a3e70c30c6d",
-/* [ 40] */ "1e33c931-ef3a-497f-9374-6d9dddf04893",
- "ebc4d160-4418-41cd-bd2f-0ef2741ffafb",
-/* [ 41] */ "6e13dd0b-67f8-447c-8445-9b8476a2e556",
-/* [ 42] */ "6123a5df-4b0b-421e-8dcb-4ecb3b33113d",
-/* [ 44] */ "75fc3921-558b-4093-82ba-e9807551de84",
-/* [ 45] */ "3308bc39-5d59-4ae8-8e45-bc1607a5d5d3",
- "ad064af6-e55a-4de9-95b8-6a0afc77ad81",
-/* [ 46] */ "f17494ba-2353-4af0-b1ba-13680858edcc",
- "64ab4e78-1b6e-4b88-b47f-2def46c79a86",
- "f99b0d59-ecff-4cc6-a9d3-20159536edc8",
-/* [ 48] */ "a697613f-349b-41f8-80c5-f416ee462ca2",
-/* [ 52] */ "e9af1e6f-016d-43f3-8890-a33d924b4368",
- "4e5c715a-4f37-4260-ae33-a86bc97f2a69",
-/* [ 54] */ "ae82cd8a-d67a-4fc7-9323-06511cbe9f4d",
- "32d7a14c-4138-459e-aa19-5263d4a6b410",
-/* [ 56] */ "9aba27ea-37e4-485c-983c-42de92c2d2ea",
-/* [ 59] */ "45826b95-3120-417b-a5ff-5480e342f25e",
- "834a24b7-5c77-4287-9266-82c2f2c9e9fc",
-/* [ 62] */ "d4d09671-8132-4809-badf-efbef39c9dac",
-/* [ 66] */ "b0bd3bd8-1271-4755-84e7-e89fabb929b2",
-/* [ 69] */ "86e2a115-3e5b-480e-9109-12ac4b525761",
-/* [ 70] */ "2896d83a-ede2-4a01-8047-25a0db868b27",
-/* [ 71] */ "1f290a52-51ad-4ea6-ae11-b90c50ba8ea6",
-/* [ 72] */ "511b890f-d9f5-4fb4-90d4-39e93719c4bf",
-/* [ 74] */ "51bf1c00-6c0a-4ca4-8acc-1ab9c6bc44ce",
-/* [ 75] */ "e1bfa30f-bc0b-4a24-99ae-bed7f3f21a7b",
- "acda5fa0-58de-4e1e-aa65-2124d1e29c54",
-/* [ 76] */ "5f476c28-8f26-48e0-98de-85745fe2f304",
-/* [ 79] */ "4a1f1b60-4c53-4525-b687-f0175b6e19bc",
-/* [ 80] */ "608bcc5e-5ccc-4967-a58f-4d61665685bc",
- "b7028f70-6d4d-4d0a-8c78-ec61fd6e38fc",
-/* [ 81] */ "03cc8179-3b0e-4c9f-a665-9ca416ee0e9b",
-/* [ 83] */ "2f32ba02-7a07-46e0-b859-a7b82a5de8e0",
-/* [ 85] */ "490b8a1b-4d7a-4d14-81c3-af6c4824632f",
-/* [ 88] */ "48e8c968-c1b7-4b3b-a24a-abb94604758b",
-/* [ 89] */ "242fd86e-d804-4b7e-9a92-b8227becdb91",
-/* [ 90] */ "13315204-76aa-4ae6-9f27-44434facea60",
-/* [ 91] */ "548544c8-1737-4efe-8661-4783e4b6ef12",
-/* [ 92] */ "3e6f26ce-ddb3-485c-86ca-b455fcfb802a",
-/* [ 93] */ "a6b1df31-2f3f-4314-87f9-fd794aad8d5a",
- "bce3d144-820d-489b-8506-f04fdea2ee48",
-/* [ 95] */ "e400060d-4de7-4c12-9533-a9aa4296c44c",
-/* [ 96] */ "9a0a6b84-7263-46d3-a45e-ad9e7b61a109",
- "a9734665-e800-4c99-96ec-dd0426e20b00",
-/* [ 97] */ "d3efc444-1758-4733-9cfb-50412ba7cf79",
- "999edbf0-b194-43aa-87ed-afc2ae0fe30b",
-/* [ 98] */ "e866d6bf-2e7c-4f97-8178-1ca758020d2c",
-/* [ 99] */ "87b97bc3-62d1-465d-94a8-7ae22efd8103",
-/* [100] */ "050d33f5-e7b1-42e8-a253-292b2769069a",
- "1b5fff42-37dc-4770-9a41-6df2fe4b7858",
- "d6a4b1a3-6c19-46e1-90b9-2de3ef471eb3",
-/* [101] */ "51e8e981-dd6a-4e85-a6b4-ed60d38a72ac",
-/* [102] */ "7f62af6b-3954-4a7a-9b32-721d770da3d8",
- "8016379a-9905-43cb-a6bd-98fc83296982",
- "e003782c-fcec-449a-a0e4-cda41893e78f",
-/* [103] */ "954d5d6a-98b6-45ad-a95c-85721664b1ea",
-/* [105] */ "ccd3680a-d8ac-4f68-ac08-a7b59f31af10",
-/* [106] */ "cded8a5d-874c-4400-86a4-eb483cfe0265",
-/* [109] */ "356df5ef-c744-4696-a697-91f4634c8559",
-/* [110] */ "faee6c44-f212-4c8a-8e8c-bea91fb26532",
-/* [113] */ "84377685-45f9-4c89-ad4f-5776f6ffcff4",
-/* [116] */ "b69c50ec-2bd3-4162-bca3-eec4398f2d12",
- "fb5e4a60-efdb-4884-bb9e-ac911b1b5100",
- "d59a5c99-5ce5-46bf-8a80-cdf916f71576",
-/* [117] */ "c09322ef-0b70-4ea0-922b-95832bb5469c",
-/* [118] */ "47e88680-4f46-4096-9f77-1bd4e271acd5",
-/* [119] */ "570d5f36-31e6-412b-84dd-e5aabb73dd5b",
- "56cf0509-741a-4a5c-a82c-51060f009b9a",
-/* [122] */ "c257b495-e53c-4be5-8b05-491057531120",
- "654139f2-cef5-48df-a6b2-6ca6e9abb1de",
-/* [123] */ "8be1d21c-cd35-4c7c-8fee-4b5046c7a62b",
- "830f0d57-9f21-40e8-bb86-cbf41de23fd6",
- "57044958-1b8a-4c02-ab75-2298c6e44263",
- "d526cd6c-4a99-4d5f-abfb-fc9419edd9d0",
-/* [124] */ "36492c15-ce5a-4f9b-b75a-97937981f9b4",
- "66a984a9-cd04-4683-b241-2b296da662bc",
- "0b3404eb-022b-4ef1-a78d-a2b12230b258",
-/* [125] */ "f8d7efcf-1138-422b-a844-feffa7478be8",
-/* [130] */ "4f8ca175-6efa-476e-ab58-11efe9211415",
-/* [131] */ "87fcc2e2-0b65-4eaa-8bea-74de85abf3fe",
- "ea0d108f-8a39-414a-88c6-fcabce029af7",
- "b1f17225-efb3-4b8a-aae3-a2ca53eeb99e",
- "45dcb41d-0628-485f-9f14-3296410555a5",
-/* [133] */ "a2b16b3f-93df-4d5a-a226-5f340bf2b0a3",
-/* [140] */ "373025da-238a-467f-8164-b5675cfe6422",
-/* [141] */ "8969aa50-6d2b-4659-ade1-b4a2169e0ed1",
-/* [142] */ "ba092226-be95-4ec2-8c35-215db61448e6",
-/* [143] */ "4213fb5a-6d28-4296-85a6-bb149a0468b7",
-/* [144] */ "05bd2d12-1062-46c3-9ac2-362617175b04",
-/* [145] */ "97cff77b-9f8d-40e9-8c41-601dc280a413",
- "4d05b973-b30b-4416-bdd8-e3773b30cb6e",
- "95382996-dfce-483d-8ff8-1d05c6c65bb5",
-/* [146] */ "04213584-d98a-4e82-a884-1238a7568c48",
-/* [148] */ "68bad966-22ec-4e87-9c6c-c1dd000959c4",
- "f1b44f04-2028-4855-ad6c-9538ef6e44a2",
-/* [149] */ "8748c9ae-624d-4fb1-a3d3-5073716c882c",
-/* [150] */ "e0eb4d5b-d251-41c9-9215-0e2830413fe4",
- "426795e5-a6e2-4b42-a81d-41cddb79f9b6",
- "a16297c6-e9f4-49c4-b244-4e2ae2803ce3",
-/* [151] */ "ea07d3ec-4f35-41db-afd2-4bc2b3273e0f",
- "f013f77d-8bd8-4a8e-82e9-82512071ac0f",
-/* [152] */ "754038bd-c382-4605-b53d-600f165aac10",
-/* [156] */ "06575e79-74dd-46c1-a752-de53b8bf8987",
-/* [158] */ "00a14b42-e60e-4214-9de1-9ff187a67e6e",
-/* [159] */ "93d02eb8-325b-42cc-b1b6-435eeb6e0449",
-/* [163] */ "f9e5528e-52ec-4164-8b4d-0b25a4715ce6",
-/* [166] */ "f1a3af6e-b8c3-4836-95da-3c4b740dab80",
-/* [169] */ "81af0cbf-b3c5-49b9-ae04-bf93e493943f",
-/* [170] */ "ab7bd5e5-68cc-4a04-9773-e668bf1d5e55",
-/* [172] */ "55ff86fa-2fc0-46c1-a222-3b9bfef434be",
-/* [174] */ "ed7dda66-4ec3-438b-8444-5f998528c7c1",
-/* [175] */ "3929d8b1-f6f7-44f6-8366-8ccc6d6c8dae",
-/* [178] */ "455a7a4c-1602-453b-9729-03c040ba1ed7",
- "6e68d708-26c3-45db-ae71-52c0ef0e3879",
-/* [179] */ "c6be4f40-aad8-4be5-bc50-e8bb9217e988",
-/* [181] */ "550e511b-3105-485f-8856-593761339f08",
-/* [182] */ "dea7c93f-a9e5-4622-9da5-0959f2561e33",
-/* [183] */ "705c2f9b-08d2-4502-b53e-0b01db35acd3",
- "819c7473-898f-439b-935d-fe4a96f64150",
-/* [185] */ "8c1fc53f-7867-4399-8c6c-a6e4b128a9f8",
-/* [187] */ "a1bf2aed-639d-4e1b-9aa3-6b7be8a49c59",
-/* [188] */ "4e92f93d-4667-414e-a7bf-b42d33bc409e",
- "4013ec51-05a8-479b-9d5a-8f1149039e34",
- "796ec0f2-b9f9-4a9e-ac8e-1ce726eef88c",
-/* [189] */ "7328ee55-9cd2-4f37-ac3c-630287a65f7c",
- "225d01da-9bbd-4cb1-b892-fd8a4a604c76",
-/* [190] */ "97fd798d-94a7-4089-aaf6-50919d105c4c",
- "cb792c37-7cd2-4649-ab92-180fef7b9911",
-/* [191] */ "7edcabaa-70f7-447d-9bb8-95537cd48b0d",
-/* [192] */ "df3348bf-5eda-480a-9a3b-c26eb9df3d80",
-/* [193] */ "854b565d-0ea7-40b3-ba41-054e2d4e1869",
- "079d9a35-331e-489d-b153-493ca28fe95c",
-/* [194] */ "589778f4-cca0-4969-a27c-ccd29b2d35f0",
-/* [195] */ "e0505dd6-3f2c-4ac1-8d93-41fb021af558",
-/* [196] */ "ab8be1c6-18f4-4ecb-a115-8d839dba1bd0",
-/* [197] */ "7dab18d4-4fc6-451f-9558-0b719bb2ecec",
-/* [200] */ "f9c10e12-877a-4750-a697-d39691443c54",
- "a5be8e6c-7d4c-48aa-b457-22168cf56ddf",
- "72160964-cd58-4a01-bdbf-7f5151975ffe",
-/* [202] */ "84d91759-4a70-4bc3-808d-24a8fc4c0816",
- "fad2acc3-ebda-490c-9698-06cd6690b924",
- "17191452-f402-47a0-b3e9-ae3e5688a534",
-/* [203] */ "f328382f-2706-4a0b-aac8-b9ffed687997",
- "5cbd8451-cc3e-4dc4-bd3b-0033d8c869ff",
-/* [204] */ "704436e1-e9b3-4269-813a-a1c6a425cb4d",
-/* [206] */ "80748ed5-3d42-4d95-ba21-30b071ac17ad",
- "bb3f3be2-2ab7-48fb-b71b-45041b732887",
-/* [207] */ "ae45b5a6-ea00-4e0c-948a-ebf3c84dfd01",
- "10363e09-d2e0-40a5-afce-0fdf852222d7",
-/* [209] */ "777174f9-d80c-46f9-9fe8-5d59c93abd64",
- "5c75455b-4317-4285-818f-3ffc165b05f9",
- "dc708225-bcb0-447b-99ca-4291d717a600",
-/* [210] */ "1dc43c46-ff0a-4527-9b01-34dde0abf4b8",
- "559813cd-ba6f-446f-af56-224170d39cce",
- "3c1c7283-78e1-4082-a191-d2eeed51d7fd",
-/* [212] */ "1cda8175-d221-452a-8aad-e96d2da674ed",
-/* [213] */ "751bcb18-2235-4bb9-b320-36551c3e8810",
-/* [214] */ "fe3a9c52-6058-4203-9fa0-6c657852026c",
-/* [215] */ "29fb462f-6975-41b0-b6fa-c2556a658a68",
-/* [216] */ "c0f80985-d1cc-4ea6-839e-02e52b33623f",
- "404e1b0c-5e34-4419-818e-6707b8f90248",
- "34d224fc-9803-4da5-a08e-4b49e5d24592",
-/* [217] */ "2977ad89-0ec8-4f60-8228-1b82a65a7c7c",
- "b954246e-29cf-4792-ae60-b841e5710111",
-/* [218] */ "b54ede2a-70af-4a63-9d17-410ba5ee6c0c",
-/* [219] */ "b2baf136-de10-48ca-ae6b-0f802acbf09c",
-/* [220] */ "e55df82c-2128-43bf-a681-e626a2c4d1c3",
- "67338b47-c2f1-4f73-956c-4b54e427e6e4",
-/* [221] */ "450cca9c-38f6-4eb8-b537-190fc3fff99d",
-/* [222] */ "6b4ccebf-e741-4a54-97a4-20ac92c18107",
-/* [225] */ "3a7ea080-fb0b-4ef3-b005-5b9e2aa931a2",
- "78d7fc2b-883d-48b1-9896-bf660ca0fe5a",
- "f12574f2-452c-4363-90a1-eeaa353936d6",
-/* [226] */ "1ae1d3f8-974e-47a7-8f26-a105766fc24d",
-/* [227] */ "9f2506cf-4aea-4c47-8897-f6b83ba814fb",
-/* [228] */ "125dba5c-b19a-4218-928f-553788c02637",
-/* [229] */ "5c7eb444-84c1-4a3b-8385-ccf4c6632dc3",
-/* [232] */ "5c2dfc36-cf78-4718-acf4-c2823c95054a",
- "b6442198-b321-4f0d-9fdb-c12115831875",
- "0cf5fc99-c43f-4a36-837a-b3bad7902cb8",
-/* [233] */ "b3631261-7322-405d-bb14-245bf29e729c",
- "2cc98dd0-5ae1-4a01-b2fd-7e1074bc9110",
- "3c6a9e1c-0425-4af3-aef8-d4e336fe4397",
-/* [235] */ "2f52aab9-c383-4ac6-b1e1-c317198a3105",
- "b06bf0b1-0b05-42ed-b79e-4770671c90e2",
-/* [237] */ "3ab39f7f-4613-4da6-a216-c2d6acc441bb",
- "ae20cf3c-38b8-483c-baea-6fb0994dc30c",
- "cd204d90-2414-4b9e-9d4f-fed09c9a816f",
-/* [240] */ "ed2cc723-db4b-43aa-ab02-0e3161087499",
-/* [241] */ "9cc96bd6-0ca0-466a-b897-e11eb7540b07",
-/* [244] */ "8d45a51f-a945-4de1-b89c-2b39d1a5b90e",
-/* [245] */ "6cd02e53-40ac-4269-91c9-4e1088af91f1",
-/* [246] */ "8ada85bc-9bdf-4507-8334-849635ea0a01",
- "8a7d5deb-615f-4cd3-8977-b5fab8ec4d05",
-/* [247] */ "dc2173b0-48fe-4555-b190-8052be1120eb",
- "040e434d-68d8-41a9-b3a1-1bee239914c1",
- "d1a564b2-c7f3-4b76-8712-3b8f5aae6ded",
- "0e614f33-c1da-4cfe-b6d5-65ecd2d066f2",
-/* [250] */ "334fdaba-f373-42ff-8546-219c1463a7c5",
- "d4ff408e-8d43-46ff-94a4-bcfa6c994776",
-/* [253] */ "d1abd887-d5de-46b0-88d6-f71f31a61305",
-/* [254] */ "1d76af65-64d6-4211-b1b5-f5b799595e4d",
-/* [255] */ "b3ad4257-29b0-4c44-b7a7-95f1d102769c",
-};
-
-const char *uuids_subset[] = {
- "64ab4e78-1b6e-4b88-b47f-2def46c79a86",
- "acda5fa0-58de-4e1e-aa65-2124d1e29c54",
- "830f0d57-9f21-40e8-bb86-cbf41de23fd6",
- "57044958-1b8a-4c02-ab75-2298c6e44263",
- "ae20cf3c-38b8-483c-baea-6fb0994dc30c",
- "040e434d-68d8-41a9-b3a1-1bee239914c1",
- "d1a564b2-c7f3-4b76-8712-3b8f5aae6ded",
- "8ada85bc-9bdf-4507-8334-849635ea0a01",
- "97cff77b-9f8d-40e9-8c41-601dc280a413",
- "4d05b973-b30b-4416-bdd8-e3773b30cb6e",
- "95382996-dfce-483d-8ff8-1d05c6c65bb5",
-};
-
-const char *uuids_new[] = {
- "a103cc42-d0e5-40fb-8f7f-3c1bee93e327",
- "01e13dc5-e65b-4988-a0cc-0d2f1f1e10fe",
- "71f3678a-a8c6-4176-a26e-c34779067135",
- "4f054508-22d5-49e1-9962-7508225c8b16",
- "e572116b-5b7b-45fd-bbe9-296029ce16b5",
- "695c8cfe-9830-4d9a-be67-50a124cefb76",
- "ea244996-645b-4a19-ad4a-48f3022b8e94",
- "0fd98758-9cc4-4779-b403-95ae3500f138",
- "b86772b4-0728-46ae-99e8-027799697838",
- "1c0cd559-81cd-4c27-8e24-6aef6f5af7f1",
- "2a37fe4a-8825-4fd6-9284-e1606967548a",
- "5920cc9d-62a3-4772-9e73-eb97f0bc483c",
- "53c215dd-bdba-4fdc-887a-86ab6f860df4",
-};
diff --git a/tests/virhashtest.c b/tests/virhashtest.c
deleted file mode 100644
index 41d0e3ffb1..0000000000
--- a/tests/virhashtest.c
+++ /dev/null
@@ -1,539 +0,0 @@
-#include <config.h>
-
-#include <time.h>
-
-#include "internal.h"
-#include "virhash.h"
-#include "virhashdata.h"
-#include "testutils.h"
-#include "viralloc.h"
-#include "virlog.h"
-#include "virstring.h"
-
-#define VIR_FROM_THIS VIR_FROM_NONE
-
-VIR_LOG_INIT("tests.hashtest");
-
-static GHashTable *
-testHashInit(void)
-{
- GHashTable *hash;
- ssize_t i;
-
- if (!(hash = virHashNew(NULL)))
- return NULL;
-
- /* entries are added in reverse order so that they will be linked in
- * collision list in the same order as in the uuids array
- */
- for (i = G_N_ELEMENTS(uuids) - 1; i >= 0; i--) {
- if (virHashAddEntry(hash, uuids[i], (void *) uuids[i]) < 0) {
- virHashFree(hash);
- return NULL;
- }
- }
-
- for (i = 0; i < G_N_ELEMENTS(uuids); i++) {
- if (!virHashLookup(hash, uuids[i])) {
- VIR_TEST_VERBOSE("\nentry \"%s\" could not be found",
uuids[i]);
- virHashFree(hash);
- return NULL;
- }
- }
-
- return hash;
-}
-
-static int
-testHashCheckForEachCount(void *payload G_GNUC_UNUSED,
- const char *name G_GNUC_UNUSED,
- void *data G_GNUC_UNUSED)
-{
- size_t *count = data;
- *count += 1;
- return 0;
-}
-
-static int
-testHashCheckCount(GHashTable *hash, size_t count)
-{
- size_t iter_count = 0;
-
- if (virHashSize(hash) != count) {
- VIR_TEST_VERBOSE("\nhash contains %zd instead of %zu elements",
- virHashSize(hash), count);
- return -1;
- }
-
- virHashForEach(hash, testHashCheckForEachCount, &iter_count);
- if (count != iter_count) {
- VIR_TEST_VERBOSE("\nhash claims to have %zu elements but iteration"
- "finds %zu", count, iter_count);
- return -1;
- }
-
- return 0;
-}
-
-
-struct testInfo {
- void *data;
- size_t count;
-};
-
-
-static int
-testHashGrow(const void *data G_GNUC_UNUSED)
-{
- GHashTable *hash;
- int ret = -1;
-
- if (!(hash = testHashInit()))
- return -1;
-
- if (testHashCheckCount(hash, G_N_ELEMENTS(uuids)) < 0)
- goto cleanup;
-
- ret = 0;
-
- cleanup:
- virHashFree(hash);
- return ret;
-}
-
-
-static int
-testHashUpdate(const void *data G_GNUC_UNUSED)
-{
- int count = G_N_ELEMENTS(uuids) + G_N_ELEMENTS(uuids_new);
- GHashTable *hash;
- size_t i;
- int ret = -1;
-
- if (!(hash = testHashInit()))
- return -1;
-
- for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
- if (virHashUpdateEntry(hash, uuids_subset[i], (void *) 1) < 0) {
- VIR_TEST_VERBOSE("\nentry \"%s\" could not be updated",
- uuids_subset[i]);
- goto cleanup;
- }
- }
-
- for (i = 0; i < G_N_ELEMENTS(uuids_new); i++) {
- if (virHashUpdateEntry(hash, uuids_new[i], (void *) 1) < 0) {
- VIR_TEST_VERBOSE("\nnew entry \"%s\" could not be
updated",
- uuids_new[i]);
- goto cleanup;
- }
- }
-
- if (testHashCheckCount(hash, count) < 0)
- goto cleanup;
-
- ret = 0;
-
- cleanup:
- virHashFree(hash);
- return ret;
-}
-
-
-static int
-testHashRemove(const void *data G_GNUC_UNUSED)
-{
- int count = G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset);
- GHashTable *hash;
- size_t i;
- int ret = -1;
-
- if (!(hash = testHashInit()))
- return -1;
-
- for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
- if (virHashRemoveEntry(hash, uuids_subset[i]) < 0) {
- VIR_TEST_VERBOSE("\nentry \"%s\" could not be removed",
- uuids_subset[i]);
- goto cleanup;
- }
- }
-
- if (testHashCheckCount(hash, count) < 0)
- goto cleanup;
-
- ret = 0;
-
- cleanup:
- virHashFree(hash);
- return ret;
-}
-
-
-const int testHashCountRemoveForEachSome =
- G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset);
-
-static int
-testHashRemoveForEachSome(void *payload G_GNUC_UNUSED,
- const char *name,
- void *data)
-{
- GHashTable *hash = data;
- size_t i;
-
- for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
- if (STREQ(uuids_subset[i], name)) {
- if (virHashRemoveEntry(hash, name) < 0) {
- VIR_TEST_VERBOSE("\nentry \"%s\" could not be
removed",
- uuids_subset[i]);
- }
- break;
- }
- }
- return 0;
-}
-
-
-const int testHashCountRemoveForEachAll = 0;
-
-static int
-testHashRemoveForEachAll(void *payload G_GNUC_UNUSED,
- const char *name,
- void *data)
-{
- GHashTable *hash = data;
-
- virHashRemoveEntry(hash, name);
- return 0;
-}
-
-
-static int
-testHashRemoveForEach(const void *data)
-{
- const struct testInfo *info = data;
- GHashTable *hash;
- int ret = -1;
-
- if (!(hash = testHashInit()))
- return -1;
-
- if (virHashForEachSafe(hash, (virHashIterator) info->data, hash)) {
- VIR_TEST_VERBOSE("\nvirHashForEach didn't go through all
entries");
- goto cleanup;
- }
-
- if (testHashCheckCount(hash, info->count) < 0)
- goto cleanup;
-
- ret = 0;
-
- cleanup:
- virHashFree(hash);
- return ret;
-}
-
-
-static int
-testHashSteal(const void *data G_GNUC_UNUSED)
-{
- int count = G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset);
- GHashTable *hash;
- size_t i;
- int ret = -1;
-
- if (!(hash = testHashInit()))
- return -1;
-
- for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
- if (!virHashSteal(hash, uuids_subset[i])) {
- VIR_TEST_VERBOSE("\nentry \"%s\" could not be stolen",
- uuids_subset[i]);
- goto cleanup;
- }
- }
-
- if (testHashCheckCount(hash, count) < 0)
- goto cleanup;
-
- ret = 0;
-
- cleanup:
- virHashFree(hash);
- return ret;
-}
-
-
-static int
-testHashRemoveSetIter(const void *payload G_GNUC_UNUSED,
- const char *name,
- const void *data)
-{
- int *count = (int *) data;
- bool rem = false;
- size_t i;
-
- for (i = 0; i < G_N_ELEMENTS(uuids_subset); i++) {
- if (STREQ(uuids_subset[i], name)) {
- rem = true;
- break;
- }
- }
-
- if (rem || rand() % 2) {
- (*count)++;
- return 1;
- } else {
- return 0;
- }
-}
-
-static int
-testHashRemoveSet(const void *data G_GNUC_UNUSED)
-{
- GHashTable *hash;
- int count = 0;
- int rcount;
- int ret = -1;
-
- if (!(hash = testHashInit()))
- return -1;
-
- /* seed the generator so that rand() provides reproducible sequence */
- srand(9000);
-
- rcount = virHashRemoveSet(hash, testHashRemoveSetIter, &count);
-
- if (count != rcount) {
- VIR_TEST_VERBOSE("\nvirHashRemoveSet didn't remove expected number
of"
- " entries, %d != %d",
- rcount, count);
- goto cleanup;
- }
-
- if (testHashCheckCount(hash, G_N_ELEMENTS(uuids) - count) < 0)
- goto cleanup;
-
- ret = 0;
-
- cleanup:
- virHashFree(hash);
- return ret;
-}
-
-
-const int testSearchIndex = G_N_ELEMENTS(uuids_subset) / 2;
-
-static int
-testHashSearchIter(const void *payload G_GNUC_UNUSED,
- const char *name,
- const void *data G_GNUC_UNUSED)
-{
- return STREQ(uuids_subset[testSearchIndex], name);
-}
-
-static int
-testHashSearch(const void *data G_GNUC_UNUSED)
-{
- GHashTable *hash;
- void *entry;
- int ret = -1;
-
- if (!(hash = testHashInit()))
- return -1;
-
- entry = virHashSearch(hash, testHashSearchIter, NULL, NULL);
-
- if (!entry || STRNEQ(uuids_subset[testSearchIndex], entry)) {
- VIR_TEST_VERBOSE("\nvirHashSearch didn't find entry '%s'",
- uuids_subset[testSearchIndex]);
- goto cleanup;
- }
-
- if (testHashCheckCount(hash, G_N_ELEMENTS(uuids)) < 0)
- goto cleanup;
-
- ret = 0;
-
- cleanup:
- virHashFree(hash);
- return ret;
-}
-
-
-static int
-testHashGetItems(const void *data G_GNUC_UNUSED)
-{
- GHashTable *hash;
- virHashKeyValuePairPtr array = NULL;
- int ret = -1;
- char keya[] = "a";
- char keyb[] = "b";
- char keyc[] = "c";
- char value1[] = "1";
- char value2[] = "2";
- char value3[] = "3";
-
- if (!(hash = virHashNew(NULL)) ||
- virHashAddEntry(hash, keya, value3) < 0 ||
- virHashAddEntry(hash, keyc, value1) < 0 ||
- virHashAddEntry(hash, keyb, value2) < 0) {
- VIR_TEST_VERBOSE("\nfailed to create hash");
- goto cleanup;
- }
-
- if (!(array = virHashGetItems(hash, NULL, false)) ||
- array[3].key || array[3].value) {
- VIR_TEST_VERBOSE("\nfailed to get items with NULL sort");
- goto cleanup;
- }
- VIR_FREE(array);
-
- if (!(array = virHashGetItems(hash, NULL, true)) ||
- STRNEQ(array[0].key, "a") ||
- STRNEQ(array[0].value, "3") ||
- STRNEQ(array[1].key, "b") ||
- STRNEQ(array[1].value, "2") ||
- STRNEQ(array[2].key, "c") ||
- STRNEQ(array[2].value, "1") ||
- array[3].key || array[3].value) {
- VIR_TEST_VERBOSE("\nfailed to get items with key sort");
- goto cleanup;
- }
- VIR_FREE(array);
-
- ret = 0;
-
- cleanup:
- VIR_FREE(array);
- virHashFree(hash);
- return ret;
-}
-
-static int
-testHashEqualCompValue(const void *value1, const void *value2)
-{
- return g_ascii_strcasecmp(value1, value2);
-}
-
-static int
-testHashEqual(const void *data G_GNUC_UNUSED)
-{
- GHashTable *hash1;
- GHashTable *hash2 = NULL;
- int ret = -1;
- char keya[] = "a";
- char keyb[] = "b";
- char keyc[] = "c";
- char value1_l[] = "m";
- char value2_l[] = "n";
- char value3_l[] = "o";
- char value1_u[] = "M";
- char value2_u[] = "N";
- char value3_u[] = "O";
- char value4_u[] = "P";
-
- if (!(hash1 = virHashNew(NULL)) ||
- !(hash2 = virHashNew(NULL)) ||
- virHashAddEntry(hash1, keya, value1_l) < 0 ||
- virHashAddEntry(hash1, keyb, value2_l) < 0 ||
- virHashAddEntry(hash1, keyc, value3_l) < 0 ||
- virHashAddEntry(hash2, keya, value1_u) < 0 ||
- virHashAddEntry(hash2, keyb, value2_u) < 0) {
- VIR_TEST_VERBOSE("\nfailed to create hashes");
- goto cleanup;
- }
-
- if (virHashEqual(hash1, hash2, testHashEqualCompValue)) {
- VIR_TEST_VERBOSE("\nfailed equal test for different number of
elements");
- goto cleanup;
- }
-
- if (virHashAddEntry(hash2, keyc, value4_u) < 0) {
- VIR_TEST_VERBOSE("\nfailed to add element to hash2");
- goto cleanup;
- }
-
- if (virHashEqual(hash1, hash2, testHashEqualCompValue)) {
- VIR_TEST_VERBOSE("\nfailed equal test for same number of elements");
- goto cleanup;
- }
-
- if (virHashUpdateEntry(hash2, keyc, value3_u) < 0) {
- VIR_TEST_VERBOSE("\nfailed to update element in hash2");
- goto cleanup;
- }
-
- if (!virHashEqual(hash1, hash2, testHashEqualCompValue)) {
- VIR_TEST_VERBOSE("\nfailed equal test for equal hash tables");
- goto cleanup;
- }
-
- ret = 0;
-
- cleanup:
- virHashFree(hash1);
- virHashFree(hash2);
- return ret;
-}
-
-
-static int
-testHashDuplicate(const void *data G_GNUC_UNUSED)
-{
- g_autoptr(GHashTable) hash = NULL;
-
- if (!(hash = virHashNew(NULL)))
- return -1;
-
- if (virHashAddEntry(hash, "a", NULL) < 0) {
- VIR_TEST_VERBOSE("\nfailed to add key 'a' to hash");
- return -1;
- }
-
- if (virHashAddEntry(hash, "a", NULL) >= 0) {
- VIR_TEST_VERBOSE("\nadding of key 'a' should have failed");
- return -1;
- }
-
- return 0;
-}
-
-
-static int
-mymain(void)
-{
- int ret = 0;
-
-#define DO_TEST_FULL(name, cmd, data, count) \
- do { \
- struct testInfo info = { data, count }; \
- if (virTestRun(name, testHash ## cmd, &info) < 0) \
- ret = -1; \
- } while (0)
-
-#define DO_TEST_DATA(name, cmd, data) \
- DO_TEST_FULL(name "(" #data ")", \
- cmd, \
- testHash ## cmd ## data, \
- testHashCount ## cmd ## data)
-
-#define DO_TEST(name, cmd) \
- DO_TEST_FULL(name, cmd, NULL, -1)
-
- DO_TEST("Grow", Grow);
- DO_TEST("Update", Update);
- DO_TEST("Remove", Remove);
- DO_TEST_DATA("Remove in ForEach", RemoveForEach, Some);
- DO_TEST_DATA("Remove in ForEach", RemoveForEach, All);
- DO_TEST("Steal", Steal);
- DO_TEST("RemoveSet", RemoveSet);
- DO_TEST("Search", Search);
- DO_TEST("GetItems", GetItems);
- DO_TEST("Equal", Equal);
- DO_TEST("Duplicate entry", Duplicate);
-
- return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
-VIR_TEST_MAIN(mymain)
--
2.26.2
9:51 a.m.
On 11/4/20 2:05 PM, Peter Krempa wrote:
Our hash table API was surprisingly close to glibs.
v2:
- pushed ACK'd patch
- typo fix
- rebased on current master
- hashing function not replaced as our has random initialization
Peter Krempa (12):
virhashtest: testHashGetItems: Remove test case for sorting by value
util: hash: Rewrite sorting of elements in virHashGetItems
util: hash: Introduce virHashForEachSorted
Use virHashForEachSorted in tested code
tests: remove virdeterministichashmock.so
util: hash: Add delete-safe hash iterator
util: hash: Use virHashForEachSafe in places which might delete the
element
util: hash: Don't use 'const' with virHashTablePtr
util: hash: Reimplement virHashTable using GHashTable
util: hash: Retire 'virHashTable' in favor of 'GHashTable'
util: hash: Add deprecation notices for functions which have
g_hash_table replacements
tests: Remove 'virhashtest'
LGTM
Reviewed-by: Daniel Henrique Barboza <danielhb413(a)gmail.com>
src/conf/backup_conf.c | 2 +-
src/conf/domain_addr.h | 2 +-
src/conf/domain_conf.c | 12 +-
src/conf/domain_conf.h | 2 +-
src/conf/nwfilter_conf.h | 2 +-
src/conf/nwfilter_ipaddrmap.c | 2 +-
src/conf/nwfilter_params.c | 34 +-
src/conf/nwfilter_params.h | 18 +-
src/conf/snapshot_conf.c | 2 +-
src/conf/virchrdev.c | 4 +-
src/conf/virdomainmomentobjlist.c | 4 +-
src/conf/virdomainobjlist.c | 6 +-
src/conf/virinterfaceobj.c | 2 +-
src/conf/virnetworkobj.c | 8 +-
src/conf/virnodedeviceobj.c | 2 +-
src/conf/virnwfilterbindingdef.h | 2 +-
src/conf/virnwfilterbindingobjlist.c | 4 +-
src/conf/virsecretobj.c | 2 +-
src/conf/virstorageobj.c | 14 +-
src/hyperv/hyperv_driver.c | 4 +-
src/hyperv/hyperv_wmi.c | 18 +-
src/hyperv/hyperv_wmi.h | 12 +-
src/hypervisor/virclosecallbacks.c | 2 +-
src/libvirt_private.syms | 2 +
src/libxl/libxl_logger.c | 2 +-
src/locking/lock_daemon.c | 4 +-
src/nwfilter/nwfilter_dhcpsnoop.c | 6 +-
src/nwfilter/nwfilter_ebiptables_driver.c | 19 +-
src/nwfilter/nwfilter_gentech_driver.c | 36 +-
src/nwfilter/nwfilter_gentech_driver.h | 2 +-
src/nwfilter/nwfilter_learnipaddr.c | 4 +-
src/nwfilter/nwfilter_tech_driver.h | 2 +-
src/qemu/qemu_agent.c | 4 +-
src/qemu/qemu_backup.c | 14 +-
src/qemu/qemu_backup.h | 2 +-
src/qemu/qemu_block.c | 42 +-
src/qemu/qemu_block.h | 18 +-
src/qemu/qemu_blockjob.c | 6 +-
src/qemu/qemu_capabilities.c | 8 +-
src/qemu/qemu_checkpoint.c | 6 +-
src/qemu/qemu_checkpoint.h | 2 +-
src/qemu/qemu_conf.c | 4 +-
src/qemu/qemu_conf.h | 2 +-
src/qemu/qemu_domain.c | 8 +-
src/qemu/qemu_domain.h | 2 +-
src/qemu/qemu_driver.c | 24 +-
src/qemu/qemu_interop_config.c | 13 +-
src/qemu/qemu_migration.c | 2 +-
src/qemu/qemu_migration_cookie.c | 2 +-
src/qemu/qemu_monitor.c | 28 +-
src/qemu/qemu_monitor.h | 20 +-
src/qemu/qemu_monitor_json.c | 50 +-
src/qemu/qemu_monitor_json.h | 22 +-
src/qemu/qemu_process.c | 18 +-
src/qemu/qemu_qapi.c | 14 +-
src/qemu/qemu_qapi.h | 6 +-
src/qemu/qemu_snapshot.c | 16 +-
src/rpc/virnetdaemon.c | 13 +-
src/security/security_selinux.c | 2 +-
src/util/virfilecache.c | 2 +-
src/util/virhash.c | 571 ++++++++----------
src/util/virhash.h | 47 +-
src/util/viriptables.c | 4 +-
src/util/virlockspace.c | 4 +-
src/util/virmacmap.c | 4 +-
src/util/virstoragefile.c | 8 +-
src/util/virsystemd.c | 2 +-
tests/meson.build | 2 -
tests/nwfilterxml2firewalltest.c | 24 +-
tests/qemublocktest.c | 26 +-
tests/qemuhotplugtest.c | 6 +-
tests/qemumigparamstest.c | 4 +-
tests/qemumonitorjsontest.c | 30 +-
tests/qemumonitortestutils.c | 6 +-
tests/qemumonitortestutils.h | 4 +-
tests/qemusecuritymock.c | 4 +-
.../blockjob-blockdev-in.xml | 116 ++--
tests/qemuxml2argvtest.c | 4 +-
tests/qemuxml2xmltest.c | 5 +-
tests/testutilsqemu.c | 6 +-
tests/testutilsqemu.h | 4 +-
tests/testutilsqemuschema.c | 10 +-
tests/testutilsqemuschema.h | 8 +-
tests/virdeterministichashmock.c | 36 --
tests/virhashdata.h | 284 ---------
tests/virhashtest.c | 564 -----------------
tests/virmacmaptest.c | 2 +-
87 files changed, 690 insertions(+), 1682 deletions(-)
delete mode 100644 tests/virdeterministichashmock.c
delete mode 100644 tests/virhashdata.h
delete mode 100644 tests/virhashtest.c
2:53 a.m.
On Nov 4, 2020, at 12:05 PM, Peter Krempa <pkrempa(a)redhat.com>
wrote:
Our hash table API was surprisingly close to glibs.
v2:
- pushed ACK'd patch
- typo fix
- rebased on current master
- hashing function not replaced as our has random initialization
Peter Krempa (12):
virhashtest: testHashGetItems: Remove test case for sorting by value
util: hash: Rewrite sorting of elements in virHashGetItems
util: hash: Introduce virHashForEachSorted
Use virHashForEachSorted in tested code
tests: remove virdeterministichashmock.so
util: hash: Add delete-safe hash iterator
util: hash: Use virHashForEachSafe in places which might delete the
element
util: hash: Don't use 'const' with virHashTablePtr
util: hash: Reimplement virHashTable using GHashTable
util: hash: Retire 'virHashTable' in favor of 'GHashTable'
util: hash: Add deprecation notices for functions which have
g_hash_table replacements
tests: Remove 'virhashtest'
I built it locally and tested against a Hyper-V server.
Looks good to me.
Reviewed-by: Matt Coleman <matt(a)datto.com>
--
Matt
6:09 a.m.
On Wed, Nov 4, 2020 at 12:06 PM Peter Krempa <pkrempa(a)redhat.com> wrote:
Our hash table API was surprisingly close to glibs.
v2:
- pushed ACK'd patch
- typo fix
- rebased on current master
- hashing function not replaced as our has random initialization
Peter Krempa (12):
virhashtest: testHashGetItems: Remove test case for sorting by value
util: hash: Rewrite sorting of elements in virHashGetItems
util: hash: Introduce virHashForEachSorted
Use virHashForEachSorted in tested code
tests: remove virdeterministichashmock.so
util: hash: Add delete-safe hash iterator
util: hash: Use virHashForEachSafe in places which might delete the
element
util: hash: Don't use 'const' with virHashTablePtr
util: hash: Reimplement virHashTable using GHashTable
util: hash: Retire 'virHashTable' in favor of 'GHashTable'
util: hash: Add deprecation notices for functions which have
g_hash_table replacements
tests: Remove 'virhashtest'
src/conf/backup_conf.c | 2 +-
src/conf/domain_addr.h | 2 +-
src/conf/domain_conf.c | 12 +-
src/conf/domain_conf.h | 2 +-
src/conf/nwfilter_conf.h | 2 +-
src/conf/nwfilter_ipaddrmap.c | 2 +-
src/conf/nwfilter_params.c | 34 +-
src/conf/nwfilter_params.h | 18 +-
src/conf/snapshot_conf.c | 2 +-
src/conf/virchrdev.c | 4 +-
src/conf/virdomainmomentobjlist.c | 4 +-
src/conf/virdomainobjlist.c | 6 +-
src/conf/virinterfaceobj.c | 2 +-
src/conf/virnetworkobj.c | 8 +-
src/conf/virnodedeviceobj.c | 2 +-
src/conf/virnwfilterbindingdef.h | 2 +-
src/conf/virnwfilterbindingobjlist.c | 4 +-
src/conf/virsecretobj.c | 2 +-
src/conf/virstorageobj.c | 14 +-
src/hyperv/hyperv_driver.c | 4 +-
src/hyperv/hyperv_wmi.c | 18 +-
src/hyperv/hyperv_wmi.h | 12 +-
src/hypervisor/virclosecallbacks.c | 2 +-
src/libvirt_private.syms | 2 +
src/libxl/libxl_logger.c | 2 +-
src/locking/lock_daemon.c | 4 +-
src/nwfilter/nwfilter_dhcpsnoop.c | 6 +-
src/nwfilter/nwfilter_ebiptables_driver.c | 19 +-
src/nwfilter/nwfilter_gentech_driver.c | 36 +-
src/nwfilter/nwfilter_gentech_driver.h | 2 +-
src/nwfilter/nwfilter_learnipaddr.c | 4 +-
src/nwfilter/nwfilter_tech_driver.h | 2 +-
src/qemu/qemu_agent.c | 4 +-
src/qemu/qemu_backup.c | 14 +-
src/qemu/qemu_backup.h | 2 +-
src/qemu/qemu_block.c | 42 +-
src/qemu/qemu_block.h | 18 +-
src/qemu/qemu_blockjob.c | 6 +-
src/qemu/qemu_capabilities.c | 8 +-
src/qemu/qemu_checkpoint.c | 6 +-
src/qemu/qemu_checkpoint.h | 2 +-
src/qemu/qemu_conf.c | 4 +-
src/qemu/qemu_conf.h | 2 +-
src/qemu/qemu_domain.c | 8 +-
src/qemu/qemu_domain.h | 2 +-
src/qemu/qemu_driver.c | 24 +-
src/qemu/qemu_interop_config.c | 13 +-
src/qemu/qemu_migration.c | 2 +-
src/qemu/qemu_migration_cookie.c | 2 +-
src/qemu/qemu_monitor.c | 28 +-
src/qemu/qemu_monitor.h | 20 +-
src/qemu/qemu_monitor_json.c | 50 +-
src/qemu/qemu_monitor_json.h | 22 +-
src/qemu/qemu_process.c | 18 +-
src/qemu/qemu_qapi.c | 14 +-
src/qemu/qemu_qapi.h | 6 +-
src/qemu/qemu_snapshot.c | 16 +-
src/rpc/virnetdaemon.c | 13 +-
src/security/security_selinux.c | 2 +-
src/util/virfilecache.c | 2 +-
src/util/virhash.c | 571 ++++++++----------
src/util/virhash.h | 47 +-
src/util/viriptables.c | 4 +-
src/util/virlockspace.c | 4 +-
src/util/virmacmap.c | 4 +-
src/util/virstoragefile.c | 8 +-
src/util/virsystemd.c | 2 +-
tests/meson.build | 2 -
tests/nwfilterxml2firewalltest.c | 24 +-
tests/qemublocktest.c | 26 +-
tests/qemuhotplugtest.c | 6 +-
tests/qemumigparamstest.c | 4 +-
tests/qemumonitorjsontest.c | 30 +-
tests/qemumonitortestutils.c | 6 +-
tests/qemumonitortestutils.h | 4 +-
tests/qemusecuritymock.c | 4 +-
.../blockjob-blockdev-in.xml | 116 ++--
tests/qemuxml2argvtest.c | 4 +-
tests/qemuxml2xmltest.c | 5 +-
tests/testutilsqemu.c | 6 +-
tests/testutilsqemu.h | 4 +-
tests/testutilsqemuschema.c | 10 +-
tests/testutilsqemuschema.h | 8 +-
tests/virdeterministichashmock.c | 36 --
tests/virhashdata.h | 284 ---------
tests/virhashtest.c | 564 -----------------
tests/virmacmaptest.c | 2 +-
87 files changed, 690 insertions(+), 1682 deletions(-)
delete mode 100644 tests/virdeterministichashmock.c
delete mode 100644 tests/virhashdata.h
delete mode 100644 tests/virhashtest.c
--
2.26.2
Series LGTM.
Reviewed-by: Neal Gompa <ngompa13(a)gmail.com>
--
真実はいつも一つ！/ Always, there's only one truth!
1477
days inactive
1479
days old
19 comments
4 participants
participants (4)
-
Daniel Henrique Barboza -
Matt Coleman -
Neal Gompa -
Peter Krempa