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@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

Rename 'data' argument which is used for opaque data. Signed-off-by: Peter Krempa <pkrempa@redhat.com> --- src/util/virhash.c | 24 ++++++++++++------------ src/util/virhash.h | 14 +++++++------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/src/util/virhash.c b/src/util/virhash.c index 2a27ce8de6..f644990712 100644 --- a/src/util/virhash.c +++ b/src/util/virhash.c @@ -484,7 +484,7 @@ virHashRemoveEntry(virHashTablePtr table, const char *name) * virHashForEach * @table: the hash table to process * @iter: callback to process each element - * @data: opaque data to pass to the iterator + * @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 @@ -495,7 +495,7 @@ virHashRemoveEntry(virHashTablePtr table, const char *name) * Returns 0 on success or -1 on failure. */ int -virHashForEach(virHashTablePtr table, virHashIterator iter, void *data) +virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque) { size_t i; int ret = -1; @@ -507,7 +507,7 @@ virHashForEach(virHashTablePtr table, virHashIterator iter, void *data) virHashEntryPtr entry = table->table[i]; while (entry) { virHashEntryPtr next = entry->next; - ret = iter(entry->payload, entry->name, data); + ret = iter(entry->payload, entry->name, opaque); if (ret < 0) return ret; @@ -524,7 +524,7 @@ virHashForEach(virHashTablePtr table, virHashIterator iter, void *data) * virHashRemoveSet * @table: the hash table to process * @iter: callback to identify elements for removal - * @data: opaque data to pass to the iterator + * @opaque: opaque data to pass to the iterator * * Iterates over all elements in the hash table, invoking the 'iter' * callback. If the callback returns a non-zero value, the element @@ -536,7 +536,7 @@ virHashForEach(virHashTablePtr table, virHashIterator iter, void *data) ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, - const void *data) + const void *opaque) { size_t i, count = 0; @@ -548,7 +548,7 @@ virHashRemoveSet(virHashTablePtr table, while (*nextptr) { virHashEntryPtr entry = *nextptr; - if (!iter(entry->payload, entry->name, data)) { + if (!iter(entry->payload, entry->name, opaque)) { nextptr = &entry->next; } else { count++; @@ -568,7 +568,7 @@ virHashRemoveSet(virHashTablePtr table, static int _virHashRemoveAllIter(const void *payload G_GNUC_UNUSED, const char *name G_GNUC_UNUSED, - const void *data G_GNUC_UNUSED) + const void *opaque G_GNUC_UNUSED) { return 1; } @@ -590,7 +590,7 @@ virHashRemoveAll(virHashTablePtr table) * virHashSearch: * @table: the hash table to search * @iter: an iterator to identify the desired element - * @data: extra opaque information passed to the iter + * @opaque: extra opaque information passed to the iter * @name: the name of found user data, pass NULL to ignore * * Iterates over the hash table calling the 'iter' callback @@ -601,7 +601,7 @@ virHashRemoveAll(virHashTablePtr table) */ void *virHashSearch(const virHashTable *ctable, virHashSearcher iter, - const void *data, + const void *opaque, char **name) { size_t i; @@ -615,7 +615,7 @@ void *virHashSearch(const virHashTable *ctable, for (i = 0; i < table->size; i++) { virHashEntryPtr entry; for (entry = table->table[i]; entry; entry = entry->next) { - if (iter(entry->payload, entry->name, data)) { + if (iter(entry->payload, entry->name, opaque)) { if (name) *name = g_strdup(entry->name); return entry->payload; @@ -691,9 +691,9 @@ struct virHashEqualData }; static int virHashEqualSearcher(const void *payload, const char *name, - const void *data) + const void *opaque) { - struct virHashEqualData *vhed = (void *)data; + struct virHashEqualData *vhed = (void *)opaque; const void *value; value = virHashLookup(vhed->table2, name); diff --git a/src/util/virhash.h b/src/util/virhash.h index d8b31e43a1..688e1adf4d 100644 --- a/src/util/virhash.h +++ b/src/util/virhash.h @@ -34,25 +34,25 @@ typedef void (*virHashDataFree) (void *payload); * virHashIterator: * @payload: the data in the hash * @name: the hash key - * @data: user supplied data blob + * @opaque: user supplied data blob * * Callback to process a hash entry during iteration * * Returns -1 to stop the iteration, e.g. in case of an error */ -typedef int (*virHashIterator) (void *payload, const char *name, void *data); +typedef int (*virHashIterator) (void *payload, const char *name, void *opaque); /** * virHashSearcher: * @payload: the data in the hash * @name: the hash key - * @data: user supplied data blob + * @opaque: user supplied data blob * * Callback to identify hash entry desired * Returns 1 if the hash entry is desired, 0 to move * to next entry */ typedef int (*virHashSearcher) (const void *payload, const char *name, - const void *data); + const void *opaque); /* * Constructor and destructor. @@ -135,9 +135,9 @@ bool virHashEqual(const virHashTable *table1, /* * Iterators */ -int virHashForEach(virHashTablePtr table, virHashIterator iter, void *data); -ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void *data); +int virHashForEach(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 *data, char **name); + const void *opaque, char **name); G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, virHashFree); -- 2.26.2

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@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

Code which is sensitive to ordering now uses deterministic iterator functions, so we can remove the mock override. Signed-off-by: Peter Krempa <pkrempa@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 d7c9af7e88..ec4199de68 100644 --- a/tests/qemumonitorjsontest.c +++ b/tests/qemumonitorjsontest.c @@ -3479,4 +3479,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

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@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 e9a4b271df..6d8b1eebba 100644 --- a/src/conf/virdomainobjlist.c +++ b/src/conf/virdomainobjlist.c @@ -838,7 +838,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 46205b163c..6d2f4b6ec9 100644 --- a/src/conf/virnetworkobj.c +++ b/src/conf/virnetworkobj.c @@ -1471,7 +1471,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; } @@ -1851,7 +1851,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 4cbb62abfa..ffcf8faf3a 100644 --- a/src/conf/virnwfilterbindingobjlist.c +++ b/src/conf/virnwfilterbindingobjlist.c @@ -365,7 +365,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 219594582c..ada53f2e8c 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

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@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 f4f017cf83..9302ad1a52 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 6d8b1eebba..2dc1d73761 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 6d2f4b6ec9..383649e5ce 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 ffcf8faf3a..13ef669270 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 146210fbe7..dec1e32283 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 ada53f2e8c..9851773121 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 002434c56a..988b59c393 100644 --- a/src/hyperv/hyperv_driver.c +++ b/src/hyperv/hyperv_driver.c @@ -1422,7 +1422,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; @@ -1938,7 +1938,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 3de7f0ed90..755495a401 100644 --- a/src/hyperv/hyperv_wmi.c +++ b/src/hyperv/hyperv_wmi.c @@ -314,18 +314,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; @@ -368,7 +368,7 @@ hypervCreateEmbeddedParam(hypervPrivate *priv, hypervWmiClassInfoListPtr info) * -1 otherwise. */ int -hypervSetEmbeddedProperty(virHashTablePtr table, +hypervSetEmbeddedProperty(GHashTable *table, const char *name, const char *value) { @@ -384,7 +384,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. @@ -395,7 +395,7 @@ int hypervAddEmbeddedParam(hypervInvokeParamsListPtr params, hypervPrivate *priv, const char *name, - virHashTablePtr *table, + GHashTable **table, hypervWmiClassInfoListPtr info) { hypervParamPtr p = NULL; @@ -426,7 +426,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 570aa07eb8..8ee44b21d5 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 0c2710a7c6..2e4fe26d9a 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 64a95951f7..f351006a12 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 f1191c1210..3b3733554b 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -9939,7 +9939,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; @@ -14982,7 +14982,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 */ @@ -16545,7 +16545,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; @@ -18229,8 +18229,8 @@ qemuDomainGetStatsOneBlockFallback(virQEMUDriverPtr driver, static void qemuDomainGetStatsOneBlockRefreshNamed(virStorageSourcePtr src, const char *alias, - virHashTablePtr stats, - virHashTablePtr nodedata) + GHashTable *stats, + GHashTable *nodedata) { qemuBlockStatsPtr entry; @@ -18259,7 +18259,7 @@ qemuDomainGetStatsOneBlock(virQEMUDriverPtr driver, const char *entryname, virStorageSourcePtr src, size_t block_idx, - virHashTablePtr stats) + GHashTable *stats) { qemuBlockStats *entry; @@ -18303,7 +18303,7 @@ qemuDomainGetStatsOneBlock(virQEMUDriverPtr driver, static int qemuDomainGetStatsBlockExportBackendStorage(const char *entryname, - virHashTablePtr stats, + GHashTable *stats, size_t recordnr, virTypedParamListPtr params) { @@ -18323,7 +18323,7 @@ qemuDomainGetStatsBlockExportBackendStorage(const char *entryname, static int qemuDomainGetStatsBlockExportFrontend(const char *frontendname, - virHashTablePtr stats, + GHashTable *stats, size_t idx, virTypedParamListPtr par) { @@ -18372,8 +18372,8 @@ qemuDomainGetStatsBlockExportHeader(virDomainDiskDefPtr disk, static int qemuDomainGetStatsBlockExportDisk(virDomainDiskDefPtr disk, - virHashTablePtr stats, - virHashTablePtr nodestats, + GHashTable *stats, + GHashTable *nodestats, virTypedParamListPtr params, size_t *recordnr, bool visitBacking, @@ -18463,8 +18463,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 e806d1e41f..1407d7291b 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) { DIR *dirp; struct dirent *ent = NULL; @@ -91,7 +91,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 2f5d61f8e7..01cc6c951a 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -5794,7 +5794,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 708c2cced7..34e37e705d 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 445d794905..18b338f4ac 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -2477,7 +2477,7 @@ qemuMonitorJSONGetBlockDevDevice(virJSONValuePtr dev) static int -qemuMonitorJSONBlockInfoAdd(virHashTablePtr table, +qemuMonitorJSONBlockInfoAdd(GHashTable *table, struct qemuDomainDiskInfo *info, const char *entryname) { @@ -2507,7 +2507,7 @@ qemuMonitorJSONBlockInfoAdd(virHashTablePtr table, int qemuMonitorJSONGetBlockInfo(qemuMonitorPtr mon, - virHashTablePtr table) + GHashTable *table) { int ret = -1; size_t i; @@ -2635,7 +2635,7 @@ qemuMonitorJSONBlockStatsCollectData(virJSONValuePtr dev, static int qemuMonitorJSONAddOneBlockStatsInfo(qemuBlockStatsPtr bstats, const char *name, - virHashTablePtr stats) + GHashTable *stats) { qemuBlockStatsPtr copy = NULL; @@ -2657,7 +2657,7 @@ static int qemuMonitorJSONGetOneBlockStatsInfo(virJSONValuePtr dev, const char *dev_name, int depth, - virHashTablePtr hash, + GHashTable *hash, bool backingChain) { g_autofree qemuBlockStatsPtr bstats = NULL; @@ -2732,7 +2732,7 @@ qemuMonitorJSONQueryBlockstats(qemuMonitorPtr mon) int qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mon, - virHashTablePtr hash, + GHashTable *hash, bool backingChain) { int nstats = 0; @@ -2781,7 +2781,7 @@ qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mon, static int qemuMonitorJSONBlockStatsUpdateCapacityData(virJSONValuePtr image, const char *name, - virHashTablePtr stats, + GHashTable *stats, qemuBlockStatsPtr *entry) { qemuBlockStatsPtr bstats; @@ -2816,7 +2816,7 @@ static int qemuMonitorJSONBlockStatsUpdateCapacityOne(virJSONValuePtr image, const char *dev_name, int depth, - virHashTablePtr stats, + GHashTable *stats, bool backingChain) { int ret = -1; @@ -2845,7 +2845,7 @@ qemuMonitorJSONBlockStatsUpdateCapacityOne(virJSONValuePtr image, int qemuMonitorJSONBlockStatsUpdateCapacity(qemuMonitorPtr mon, - virHashTablePtr stats, + GHashTable *stats, bool backingChain) { int ret = -1; @@ -2891,7 +2891,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; @@ -2916,7 +2916,7 @@ qemuMonitorJSONBlockStatsUpdateCapacityBlockdevWorker(size_t pos G_GNUC_UNUSED, int qemuMonitorJSONBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon, - virHashTablePtr stats) + GHashTable *stats) { virJSONValuePtr nodes; int ret = -1; @@ -3020,7 +3020,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; @@ -3059,10 +3059,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); @@ -3075,7 +3075,7 @@ qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValuePtr nodes) } -virHashTablePtr +GHashTable * qemuMonitorJSONBlockGetNamedNodeData(qemuMonitorPtr mon, bool supports_flat) { @@ -4464,7 +4464,7 @@ qemuMonitorJSONQueryRxFilter(qemuMonitorPtr mon, const char *alias, */ static int qemuMonitorJSONExtractChardevInfo(virJSONValuePtr reply, - virHashTablePtr info) + GHashTable *info) { virJSONValuePtr data; int ret = -1; @@ -4532,7 +4532,7 @@ qemuMonitorJSONExtractChardevInfo(virJSONValuePtr reply, int qemuMonitorJSONGetChardevInfo(qemuMonitorPtr mon, - virHashTablePtr info) + GHashTable *info) { int ret = -1; @@ -5084,7 +5084,7 @@ int qemuMonitorJSONScreendump(qemuMonitorPtr mon, static int -qemuMonitorJSONParseBlockJobInfo(virHashTablePtr blockJobs, +qemuMonitorJSONParseBlockJobInfo(GHashTable *blockJobs, virJSONValuePtr entry, bool rawjobname) { @@ -5152,7 +5152,7 @@ qemuMonitorJSONParseBlockJobInfo(virHashTablePtr blockJobs, return 0; } -virHashTablePtr +GHashTable * qemuMonitorJSONGetAllBlockJobInfo(qemuMonitorPtr mon, bool rawjobname) { @@ -5161,7 +5161,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) @@ -6951,7 +6951,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", @@ -6966,11 +6966,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; @@ -8381,7 +8381,7 @@ qemuMonitorJSONSetIOThread(qemuMonitorPtr mon, int qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitorPtr mon, - virHashTablePtr info) + GHashTable *info) { int ret = -1; virJSONValuePtr cmd; @@ -9265,7 +9265,7 @@ qemuMonitorJSONGetSEVMeasurement(qemuMonitorPtr mon) */ static int qemuMonitorJSONExtractPRManagerInfo(virJSONValuePtr reply, - virHashTablePtr info) + GHashTable *info) { qemuMonitorPRManagerInfoPtr entry = NULL; virJSONValuePtr data; @@ -9309,7 +9309,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 d334ad1e9b..148fa5c64e 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; @@ -7962,7 +7962,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; @@ -8190,7 +8190,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 733bcf23d9..b7300406d8 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 ed658714e8..d943ca3b99 100644 --- a/src/util/virhash.c +++ b/src/util/virhash.c @@ -31,7 +31,7 @@ VIR_LOG_INIT("util.hash"); struct _virHashAtomic { virObjectLockable parent; - virHashTablePtr hash; + GHashTable *hash; }; static virClassPtr virHashAtomicClass; @@ -52,11 +52,11 @@ VIR_ONCE_GLOBAL_INIT(virHashAtomic); * virHashNew: * @dataFree: callback to free data * - * Create a new virHashTablePtr. + * Create a new GHashTable *. * * Returns the newly created object. */ -virHashTablePtr +GHashTable * virHashNew(virHashDataFree dataFree) { return g_hash_table_new_full(g_str_hash, g_str_equal, g_free, dataFree); @@ -99,7 +99,7 @@ virHashAtomicDispose(void *obj) * deallocated with function provided at creation time. */ void -virHashFree(virHashTablePtr table) +virHashFree(GHashTable *table) { if (table == NULL) return; @@ -120,7 +120,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; @@ -149,7 +149,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) @@ -185,7 +185,7 @@ virHashAtomicUpdate(virHashAtomicPtr table, * Returns a pointer to the userdata */ void * -virHashLookup(virHashTablePtr table, +virHashLookup(GHashTable *table, const char *name) { if (!table || !name) @@ -205,7 +205,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) @@ -225,7 +225,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; @@ -266,7 +266,7 @@ virHashAtomicSteal(virHashAtomicPtr table, * -1 in case of error */ ssize_t -virHashSize(virHashTablePtr table) +virHashSize(GHashTable *table) { if (table == NULL) return -1; @@ -287,7 +287,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) @@ -328,7 +328,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; @@ -349,7 +349,7 @@ virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque) int -virHashForEachSafe(virHashTablePtr table, +virHashForEachSafe(GHashTable *table, virHashIterator iter, void *opaque) { @@ -369,7 +369,7 @@ virHashForEachSafe(virHashTablePtr table, int -virHashForEachSorted(virHashTablePtr table, +virHashForEachSorted(GHashTable *table, virHashIterator iter, void *opaque) { @@ -420,7 +420,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) { @@ -440,7 +440,7 @@ virHashRemoveSet(virHashTablePtr table, * deallocated with the function provided at creation time. */ void -virHashRemoveAll(virHashTablePtr table) +virHashRemoveAll(GHashTable *table) { if (!table) return; @@ -461,7 +461,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) @@ -494,7 +494,7 @@ virHashGetItemsKeySorter(const void *va, virHashKeyValuePairPtr -virHashGetItems(virHashTablePtr table, +virHashGetItems(GHashTable *table, size_t *nitems, bool sortKeys) { @@ -532,7 +532,7 @@ virHashGetItems(virHashTablePtr table, struct virHashEqualData { bool equal; - virHashTablePtr table2; + GHashTable *table2; virHashValueComparator compar; }; @@ -553,8 +553,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 ec4199de68..ea84f9ea6f 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 c5a0095e0d..8034cf0925 100644 --- a/tests/qemuxml2argvtest.c +++ b/tests/qemuxml2argvtest.c @@ -510,7 +510,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; @@ -756,7 +756,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 4defba0b7b..82f80e91f3 100644 --- a/tests/testutilsqemu.c +++ b/tests/testutilsqemu.c @@ -563,7 +563,7 @@ testQemuGetLatestCapsForArch(const char *arch, } -virHashTablePtr +GHashTable * testQemuGetLatestCaps(void) { const char *archs[] = { @@ -573,7 +573,7 @@ testQemuGetLatestCaps(void) "s390x", "x86_64", }; - virHashTablePtr capslatest; + GHashTable *capslatest; size_t i; if (!(capslatest = virHashNew(g_free))) @@ -675,7 +675,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

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@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