From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) client-ip=63.128.21.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727554; cv=none; d=zohomail.com; s=zohoarc; b=Kn/LKhxVuJZSCu3R0veZyH2Hv2AF7sjFj2U+btRdCRkIMESzyDGpYyvJ1oIfgWArbJ7CoFnDaKdtpTHkxjGQT9yZJcNCbbZkiixk3x1Q1nWcVM7ZTACcVPVuZUziVDop1nCajxkikr0Oo/AZj8K9opA2Ym93AzW8z+FGSJElIhE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727554; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=cqI73WzE1O9ebeyYdw0NJhalkgLT+dnXWxFDEy6Ko6c=; b=GBOf5gC6/cuQT9ETW8RRFoLVMZRBI3Zej0GHBWGNsv3vdsfFRPBXnnGr8vQvWWILZjJDzPiVnrYwe7l4SDBxpQ4mscmcJ3AS+cTRfnlF/eFmOH91HX/m8kzKlqYSdd1zHj5GTfBuhh9UWplgyEl6ln8g40yRy7r887SLQ27/a/g= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) by mx.zohomail.com with SMTPS id 1603727554968578.3201169634548; Mon, 26 Oct 2020 08:52:34 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-86-8RNh09mfOo-lU6-LNMy9gg-1; Mon, 26 Oct 2020 11:52:31 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 4F78B1882FBC; Mon, 26 Oct 2020 15:52:25 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 415D062A0B; Mon, 26 Oct 2020 15:52:24 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id F193792F28; Mon, 26 Oct 2020 15:52:23 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFjxmW018480 for ; Mon, 26 Oct 2020 11:45:59 -0400 Received: by smtp.corp.redhat.com (Postfix) id E0BE919D7D; Mon, 26 Oct 2020 15:45:59 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 41C1319D6C for ; Mon, 26 Oct 2020 15:45:59 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727553; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=cqI73WzE1O9ebeyYdw0NJhalkgLT+dnXWxFDEy6Ko6c=; b=GWj/pBycFoNQeQ24I5sVUkRUHepCPIegaXef5eaL4kMNP2VgiEPCPX0sxX/cOTbDb8yx2L r9ISnuq1diWJyhD0EJpkFBqd4cBcHlov0znJY30bDNvX3u0QuqXTdJH4wVT/Y4aOKDweGJ rkrVGL1BTAWUREkcd9Mp15hrYpPlXnQ= X-MC-Unique: 8RNh09mfOo-lU6-LNMy9gg-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 01/13] virhashtest: testHashGetItems: Remove test case for sorting by value Date: Mon, 26 Oct 2020 16:45:41 +0100 Message-Id: In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" 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 --- 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 =3D 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 =3D 0; cleanup: --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) client-ip=216.205.24.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727584; cv=none; d=zohomail.com; s=zohoarc; b=SYp7gztr1dZCb+4qW3hnOs2pdrBVELqGqLmRUrJ4ZQl2Oojqh7Q/O8De1pNTDdGJV+xIzRJQ6nN7Hz/9iJHNBmghiTioWEt9hJ6c11HfpXQJyNwSawPcP8cfldZZJfG4Siyqr02eEAVW6zVQ7pRYYnz7Hoz0smxkpkAYW9qsy28= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727584; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=d1QnaBWNuPcNuDHZMKKvl2IZeJvf0KH1D+44Lde3xmQ=; b=CambdDVn2u9ArnqlSE5TEraTkhmMg44uZl2kwmqlkApEuRljZoHlDxaj8dBw7toQocrEyGtVlf8wM+WhZ85D9d+oAQIbqpKLF4+CYNQcAAct7v5EJgwqhEIcOvzz43mgJApupytxOxc0EhNqbp7uqfPtetgnlns5LpYE35jZK3c= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by mx.zohomail.com with SMTPS id 1603727584864905.421119226289; Mon, 26 Oct 2020 08:53:04 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-434-v5sGMH0MNXWhFWd3IySeiw-1; Mon, 26 Oct 2020 11:52:32 -0400 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 596C7809DC3; Mon, 26 Oct 2020 15:52:27 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 37B376EF58; Mon, 26 Oct 2020 15:52:27 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 036EA181A06E; Mon, 26 Oct 2020 15:52:27 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFk1IT018492 for ; Mon, 26 Oct 2020 11:46:01 -0400 Received: by smtp.corp.redhat.com (Postfix) id 0C49E19D7D; Mon, 26 Oct 2020 15:46:01 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 5322519D6C for ; Mon, 26 Oct 2020 15:46:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727583; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=d1QnaBWNuPcNuDHZMKKvl2IZeJvf0KH1D+44Lde3xmQ=; b=fltj66CHH7IUGt+X6sZcMKOjY1NeTcjFOi6nuGLSHN8GYGJdgStOZratxG/VCMnVs5PpHi QhurUO4tWJ/zXq/B1v7Ywh5dIOZX78/MoVNqlMj5mcckyExLaM3NA12PpFf1biOKszRwu9 D4yjm+KN5Z68PYJWSZ8gmxOF9R3fCcs= X-MC-Unique: v5sGMH0MNXWhFWd3IySeiw-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 02/13] util: hash: Rewrite sorting of elements in virHashGetItems Date: Mon, 26 Oct 2020 16:45:42 +0100 Message-Id: <9f1a96cb25b626e0ccb0153289bc901e65f66370.1603726723.git.pkrempa@redhat.com> In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" All but one of the callers either use the list in arbitrary order or sorted by key. Rewrite the function so that it supports sorting by key natively and make it return the element count. This in turn allows to rewrite the only caller to sort by value internally. This allows to remove multiple sorting functions which were sorting by key and the function will be also later reused for some hash operations internally. Signed-off-by: Peter Krempa --- src/conf/nwfilter_params.c | 10 +--- src/hyperv/hyperv_wmi.c | 2 +- src/locking/lock_daemon.c | 2 +- src/nwfilter/nwfilter_ebiptables_driver.c | 13 +++-- src/qemu/qemu_interop_config.c | 9 +--- src/rpc/virnetdaemon.c | 11 +--- src/util/virhash.c | 66 ++++++++++++++--------- src/util/virhash.h | 5 +- src/util/virlockspace.c | 2 +- tests/virhashtest.c | 11 +--- 10 files changed, 59 insertions(+), 72 deletions(-) diff --git a/src/conf/nwfilter_params.c b/src/conf/nwfilter_params.c index 73160a38a4..dd2b92c97b 100644 --- a/src/conf/nwfilter_params.c +++ b/src/conf/nwfilter_params.c @@ -755,13 +755,6 @@ virNWFilterParseParamAttributes(xmlNodePtr cur) } -static int -virNWFilterFormatParameterNameSorter(const virHashKeyValuePair *a, - const virHashKeyValuePair *b) -{ - return strcmp(a->key, b->key); -} - int virNWFilterFormatParamAttributes(virBufferPtr buf, virHashTablePtr table, @@ -779,8 +772,7 @@ virNWFilterFormatParamAttributes(virBufferPtr buf, return -1; } - items =3D virHashGetItems(table, - virNWFilterFormatParameterNameSorter); + items =3D virHashGetItems(table, NULL, true); if (!items) return -1; diff --git a/src/hyperv/hyperv_wmi.c b/src/hyperv/hyperv_wmi.c index 421cbfa31b..3de7f0ed90 100644 --- a/src/hyperv/hyperv_wmi.c +++ b/src/hyperv/hyperv_wmi.c @@ -683,7 +683,7 @@ hypervSerializeEmbeddedParam(hypervParamPtr p, const ch= ar *resourceUri, /* retrieve parameters out of hash table */ numKeys =3D virHashSize(p->embedded.table); - items =3D virHashGetItems(p->embedded.table, NULL); + items =3D virHashGetItems(p->embedded.table, NULL, false); if (!items) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not read embedded param hash table")); diff --git a/src/locking/lock_daemon.c b/src/locking/lock_daemon.c index 8f16dfd064..021792cc69 100644 --- a/src/locking/lock_daemon.c +++ b/src/locking/lock_daemon.c @@ -730,7 +730,7 @@ virLockDaemonPreExecRestart(const char *state_file, } - tmp =3D pairs =3D virHashGetItems(lockDaemon->lockspaces, NULL); + tmp =3D pairs =3D virHashGetItems(lockDaemon->lockspaces, NULL, false); while (tmp && tmp->key) { virLockSpacePtr lockspace =3D (virLockSpacePtr)tmp->value; diff --git a/src/nwfilter/nwfilter_ebiptables_driver.c b/src/nwfilter/nwfil= ter_ebiptables_driver.c index da6f88f135..8dfc870ab7 100644 --- a/src/nwfilter/nwfilter_ebiptables_driver.c +++ b/src/nwfilter/nwfilter_ebiptables_driver.c @@ -3126,9 +3126,12 @@ virNWFilterRuleInstSortPtr(const void *a, const void= *b) static int -ebiptablesFilterOrderSort(const virHashKeyValuePair *a, - const virHashKeyValuePair *b) +ebiptablesFilterOrderSort(const void *va, + const void *vb) { + const virHashKeyValuePair *a =3D va; + const virHashKeyValuePair *b =3D vb; + /* elements' values has been limited to range [-1000, 1000] */ return *(virNWFilterChainPriority *)a->value - *(virNWFilterChainPriority *)b->value; @@ -3288,13 +3291,15 @@ ebtablesGetSubChainInsts(virHashTablePtr chains, size_t *ninsts) { g_autofree virHashKeyValuePairPtr filter_names =3D NULL; + size_t nfilter_names; size_t i; - filter_names =3D virHashGetItems(chains, - ebiptablesFilterOrderSort); + filter_names =3D virHashGetItems(chains, &nfilter_names, false); if (filter_names =3D=3D NULL) return -1; + qsort(filter_names, nfilter_names, sizeof(*filter_names), ebiptablesFi= lterOrderSort); + for (i =3D 0; filter_names[i].key; i++) { g_autofree ebtablesSubChainInstPtr inst =3D NULL; enum l3_proto_idx idx =3D ebtablesGetProtoIdxByFiltername( diff --git a/src/qemu/qemu_interop_config.c b/src/qemu/qemu_interop_config.c index 53b251f056..e806d1e41f 100644 --- a/src/qemu/qemu_interop_config.c +++ b/src/qemu/qemu_interop_config.c @@ -83,13 +83,6 @@ qemuBuildFileList(virHashTablePtr files, const char *dir) return ret; } -static int -qemuConfigFilesSorter(const virHashKeyValuePair *a, - const virHashKeyValuePair *b) -{ - return strcmp(a->key, b->key); -} - #define QEMU_SYSTEM_LOCATION PREFIX "/share/qemu" #define QEMU_ETC_LOCATION SYSCONFDIR "/qemu" @@ -145,7 +138,7 @@ qemuInteropFetchConfigs(const char *name, if (virHashSize(files) =3D=3D 0) return 0; - if (!(pairs =3D virHashGetItems(files, qemuConfigFilesSorter))) + if (!(pairs =3D virHashGetItems(files, NULL, true))) return -1; for (tmp =3D pairs; tmp->key; tmp++) { diff --git a/src/rpc/virnetdaemon.c b/src/rpc/virnetdaemon.c index ce13f0d927..525cbb3ce6 100644 --- a/src/rpc/virnetdaemon.c +++ b/src/rpc/virnetdaemon.c @@ -378,15 +378,6 @@ virNetDaemonNewPostExecRestart(virJSONValuePtr object, } -static int -daemonServerCompare(const virHashKeyValuePair *a, const virHashKeyValuePai= r *b) -{ - const char *as =3D a->key; - const char *bs =3D b->key; - - return strcmp(as, bs); -} - virJSONValuePtr virNetDaemonPreExecRestart(virNetDaemonPtr dmn) { @@ -402,7 +393,7 @@ virNetDaemonPreExecRestart(virNetDaemonPtr dmn) goto error; } - if (!(srvArray =3D virHashGetItems(dmn->servers, daemonServerCompare))) + if (!(srvArray =3D virHashGetItems(dmn->servers, NULL, true))) goto error; for (i =3D 0; srvArray[i].key; i++) { diff --git a/src/util/virhash.c b/src/util/virhash.c index 301e485e69..2a27ce8de6 100644 --- a/src/util/virhash.c +++ b/src/util/virhash.c @@ -626,49 +626,63 @@ void *virHashSearch(const virHashTable *ctable, return NULL; } -struct getKeysIter -{ - virHashKeyValuePair *sortArray; - size_t arrayIdx; + +struct virHashGetItemsIteratorData { + virHashKeyValuePair *items; + size_t i; }; -static int virHashGetKeysIterator(void *payload, - const char *key, void *data) + +static int +virHashGetItemsIterator(void *payload, + const char *key, + void *opaque) { - struct getKeysIter *iter =3D data; + struct virHashGetItemsIteratorData *data =3D opaque; - iter->sortArray[iter->arrayIdx].key =3D key; - iter->sortArray[iter->arrayIdx].value =3D payload; + data->items[data->i].key =3D key; + data->items[data->i].value =3D payload; - iter->arrayIdx++; + data->i++; return 0; } -typedef int (*qsort_comp)(const void *, const void *); -virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table, - virHashKeyComparator compar) +static int +virHashGetItemsKeySorter(const void *va, + const void *vb) { - ssize_t numElems =3D virHashSize(table); - struct getKeysIter iter =3D { - .arrayIdx =3D 0, - .sortArray =3D NULL, - }; + const virHashKeyValuePair *a =3D va; + const virHashKeyValuePair *b =3D vb; - if (numElems < 0) - return NULL; + return strcmp(a->key, b->key); +} + + +virHashKeyValuePairPtr +virHashGetItems(virHashTablePtr table, + size_t *nitems, + bool sortKeys) +{ + size_t dummy; + struct virHashGetItemsIteratorData data =3D { .items =3D NULL, .i =3D = 0 }; - iter.sortArray =3D g_new0(virHashKeyValuePair, numElems + 1); + if (!nitems) + nitems =3D &dummy; - virHashForEach(table, virHashGetKeysIterator, &iter); + *nitems =3D virHashSize(table); - if (compar) - qsort(&iter.sortArray[0], numElems, sizeof(iter.sortArray[0]), - (qsort_comp)compar); + data.items =3D g_new0(virHashKeyValuePair, *nitems + 1); - return iter.sortArray; + virHashForEach(table, virHashGetItemsIterator, &data); + + if (sortKeys) + qsort(data.items, *nitems, sizeof(* data.items), virHashGetItemsKe= ySorter); + + return data.items; } + struct virHashEqualData { bool equal; diff --git a/src/util/virhash.h b/src/util/virhash.h index 029e6e83b7..d8b31e43a1 100644 --- a/src/util/virhash.h +++ b/src/util/virhash.h @@ -116,10 +116,9 @@ struct _virHashKeyValuePair { const void *key; const void *value; }; -typedef int (*virHashKeyComparator)(const virHashKeyValuePair *, - const virHashKeyValuePair *); virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table, - virHashKeyComparator compar); + size_t *nitems, + bool sortedKeys); /* * Compare two tables for equality: the lookup of a key's value in diff --git a/src/util/virlockspace.c b/src/util/virlockspace.c index 2731d46dfc..d39f2c026f 100644 --- a/src/util/virlockspace.c +++ b/src/util/virlockspace.c @@ -435,7 +435,7 @@ virJSONValuePtr virLockSpacePreExecRestart(virLockSpace= Ptr lockspace) goto error; } - tmp =3D pairs =3D virHashGetItems(lockspace->resources, NULL); + tmp =3D pairs =3D virHashGetItems(lockspace->resources, NULL, false); while (tmp && tmp->value) { virLockSpaceResourcePtr res =3D (virLockSpaceResourcePtr)tmp->valu= e; virJSONValuePtr child =3D virJSONValueNewObject(); diff --git a/tests/virhashtest.c b/tests/virhashtest.c index 8cc3109929..93949d8b7a 100644 --- a/tests/virhashtest.c +++ b/tests/virhashtest.c @@ -361,13 +361,6 @@ testHashSearch(const void *data G_GNUC_UNUSED) } -static int -testHashGetItemsCompKey(const virHashKeyValuePair *a, - const virHashKeyValuePair *b) -{ - return strcmp(a->key, b->key); -} - static int testHashGetItems(const void *data G_GNUC_UNUSED) { @@ -389,14 +382,14 @@ testHashGetItems(const void *data G_GNUC_UNUSED) goto cleanup; } - if (!(array =3D virHashGetItems(hash, NULL)) || + if (!(array =3D 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 =3D virHashGetItems(hash, testHashGetItemsCompKey)) || + if (!(array =3D virHashGetItems(hash, NULL, true)) || STRNEQ(array[0].key, "a") || STRNEQ(array[0].value, "3") || STRNEQ(array[1].key, "b") || --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) client-ip=216.205.24.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727183; cv=none; d=zohomail.com; s=zohoarc; b=LkPn27uUrQTEgkAJ6PioXHZ5NCzA1g9EH50um6chENnuka8SpEJCsMTTRsmU/Tc+4rI0J5wIHC6L2JSE9C5M/+5n1lIbFNGfkltZJVOXvuE9pFPU/jygtUD6Dp5lPNwp5eU+aPsKtz64+eZYnXEPx6ZxJes7/mPeybnN7pqgYFc= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727183; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=A2szlORmJkLC4JIrKY8xXRyBxm0JlJfqbsedDNpahr8=; b=JiumErZteyHSlM+OQNUB5Uz6OIP7WDvkYR3GUlpyMxeNqwSp1nU0oQOalU99/l8XeLxSno8cndPsBNkuSH+Hs2IuuFPUGgcsBrt3xIL8ObDr7UZ2OVbgsvb8iYhIttIvLLwF1SXAurNMQz+Jx/2I6SXyfrUiGm1ekebp2OE/3yI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by mx.zohomail.com with SMTPS id 1603727183006705.836981772555; Mon, 26 Oct 2020 08:46:23 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-159-CP4wmNqMPmC4kuiVTD8KGQ-1; Mon, 26 Oct 2020 11:46:19 -0400 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 2E3A218B9F0A; Mon, 26 Oct 2020 15:46:11 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 56FE910013D0; Mon, 26 Oct 2020 15:46:09 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 78ADB181A06C; Mon, 26 Oct 2020 15:46:03 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFk2Bt018500 for ; Mon, 26 Oct 2020 11:46:02 -0400 Received: by smtp.corp.redhat.com (Postfix) id 3D4911992F; Mon, 26 Oct 2020 15:46:02 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 88ED019D7D for ; Mon, 26 Oct 2020 15:46:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727181; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=A2szlORmJkLC4JIrKY8xXRyBxm0JlJfqbsedDNpahr8=; b=Y0L35G3qDLHahWlvRYHG+DtTVmv/OBjNByLOh3MDU/u7zHYRgWJUUnNUiZd4zSaRpqkVpy t9wNF5BfQIwVjh7Cd3d2OOYmXycwBPNaVA9dIRce5w9Ecg2G5jWF9iTmV1hxZ0bzoDCpul FvhQivqMDSYq/jRf6oxJyxcSx35Co5k= X-MC-Unique: CP4wmNqMPmC4kuiVTD8KGQ-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 03/13] util: virhash: Standardize on 'opaque' for opaque data Date: Mon, 26 Oct 2020 16:45:43 +0100 Message-Id: In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" Rename 'data' argument which is used for opaque data. Signed-off-by: Peter Krempa Reviewed-by: J=C3=A1n Tomko --- 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 *n= ame) * 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 *n= ame) * 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 =3D -1; @@ -507,7 +507,7 @@ virHashForEach(virHashTablePtr table, virHashIterator i= ter, void *data) virHashEntryPtr entry =3D table->table[i]; while (entry) { virHashEntryPtr next =3D entry->next; - ret =3D iter(entry->payload, entry->name, data); + ret =3D iter(entry->payload, entry->name, opaque); if (ret < 0) return ret; @@ -524,7 +524,7 @@ virHashForEach(virHashTablePtr table, virHashIterator i= ter, 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 i= ter, void *data) ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, - const void *data) + const void *opaque) { size_t i, count =3D 0; @@ -548,7 +548,7 @@ virHashRemoveSet(virHashTablePtr table, while (*nextptr) { virHashEntryPtr entry =3D *nextptr; - if (!iter(entry->payload, entry->name, data)) { + if (!iter(entry->payload, entry->name, opaque)) { nextptr =3D &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 =3D 0; i < table->size; i++) { virHashEntryPtr entry; for (entry =3D table->table[i]; entry; entry =3D entry->next) { - if (iter(entry->payload, entry->name, data)) { + if (iter(entry->payload, entry->name, opaque)) { if (name) *name =3D 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 =3D (void *)data; + struct virHashEqualData *vhed =3D (void *)opaque; const void *value; value =3D 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 *dat= a); +typedef int (*virHashIterator) (void *payload, const char *name, void *opa= que); /** * 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, cons= t void *data); +int virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaq= ue); +ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, cons= t 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); --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) client-ip=63.128.21.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727201; cv=none; d=zohomail.com; s=zohoarc; b=mTwvnRS12yKmBnXDY6pTuTssv28f1FluUFXnzAWIAEakSDFzpZLZGEZuM06DWOEZuNS05C0Uwrc2pzW/tFhaMjolqaorJs/NqhlxvxSggW1xVznC707Eh7vRaAZmYUeB0sErfEPQxCI8GVn4944k4yFHJbiUW25uuo8l3j0Z6/A= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727201; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=1jyv+uAwatxJG72ZraGergShzVXU8ft5zSLhct9+nHk=; b=Gwov70vLasfDlmIuc3MtrqaMKZi8AfJFodO7MeR2QVITXPCzyUJ8006lefWihccjeBJSguYiLhm4RlWrFI8+h0dpq0g+pbubAszryZZ2zxn9M15VkG7e0FovTczVJ9BD9yOrVBKGLv1Srcpc8Q3bcnAKkFWhT1rhAek0QOt8UB8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) by mx.zohomail.com with SMTPS id 1603727201383694.2088782482688; Mon, 26 Oct 2020 08:46:41 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-342-5PB1OLzjMbij7bvJDIPAAg-1; Mon, 26 Oct 2020 11:46:38 -0400 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 7118C809DC8; Mon, 26 Oct 2020 15:46:32 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 2332419728; Mon, 26 Oct 2020 15:46:32 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 77EB0181A07B; Mon, 26 Oct 2020 15:46:31 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFk3Fh018513 for ; Mon, 26 Oct 2020 11:46:03 -0400 Received: by smtp.corp.redhat.com (Postfix) id 7070819D7D; Mon, 26 Oct 2020 15:46:03 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id C2CDC1992F for ; Mon, 26 Oct 2020 15:46:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727200; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=1jyv+uAwatxJG72ZraGergShzVXU8ft5zSLhct9+nHk=; b=gsxI67Tqcd4Zr2FTsmrgi2DY7LeD88CDkpN8eMX74wLRKkf9C/rjMHGXE4diy6d2/wsZBi WJkShKgNeNLQNgDNBcLR10ksuQgdv9kt23YTiC8CX3dzhHIDTswLdsxMTgqtp0fcWPOXJD smjHoI3CZrfDsriyRKSg5/H7S8fQiDc= X-MC-Unique: 5PB1OLzjMbij7bvJDIPAAg-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 04/13] util: hash: Introduce virHashForEachSorted Date: Mon, 26 Oct 2020 16:45:44 +0100 Message-Id: In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" 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 --- 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 prohib= ited. + * Iterates over every element in the hash table, invoking the 'iter' call= back. + * + * 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 =3D virHashGetItems(table, NUL= L, true); + size_t i; + + if (!items) + return -1; + + for (i =3D 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 *opaq= ue); +int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void= *opaque); ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, cons= t void *opaque); void *virHashSearch(const virHashTable *table, virHashSearcher iter, const void *opaque, char **name); --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) client-ip=216.205.24.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727210; cv=none; d=zohomail.com; s=zohoarc; b=kHqiRVeA6NCTKtcy9O/igsIJHoXkm4+wAnIqRJp8AT8e+48oJzfSdMEykqrH40kv6EEWtmhd7PjLcmi1OImos5KwSgRWY3Cc3TeTouzptFPkcMRdVRDasUHE2pxZxK/g1y5tc/kQ77wdK0UCYR3NmtQlxzEjBciFa9XcCNuVD6I= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727210; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=YQP2UsNfUfjbztkepYM6+WPx+2PDyvZidXQ88Gt86x8=; b=iDPz87tiYgI2fS6UpDh38DsX5FOyIS+qlNh24U4yBZRsv/YUy3X17h2ylUbH/z/htTiiK8xT0N3HaR6h6wyfjNRY5gk4GP0joduOxjbCezK19t5kRNVaBFwHi1cZdFFOAUS98SpYs45kLKfCRMx16q9/GG6LJjT/DdSdqEY3c4U= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by mx.zohomail.com with SMTPS id 1603727210115838.6720359517234; Mon, 26 Oct 2020 08:46:50 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-29-aZXZZL9NO_WrpMBB0dj5cA-1; Mon, 26 Oct 2020 11:46:44 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 0ACD82FD08; Mon, 26 Oct 2020 15:46:38 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id DD9D262A0B; Mon, 26 Oct 2020 15:46:37 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id A826892F21; Mon, 26 Oct 2020 15:46:37 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFk4iw018527 for ; Mon, 26 Oct 2020 11:46:04 -0400 Received: by smtp.corp.redhat.com (Postfix) id 9A5BC19D7D; Mon, 26 Oct 2020 15:46:04 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id DE9A01992F for ; Mon, 26 Oct 2020 15:46:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727209; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=YQP2UsNfUfjbztkepYM6+WPx+2PDyvZidXQ88Gt86x8=; b=Q7XRk8fes02pWe1uNa/y7oqCfPovJZUVWmKWQgmoOL3n1myfQXwSFoVToH0W2d/85mV80I E3k3dnG65uvSnMHMof9v8eNE3gvBnSTm2jWZ9TucHEPK3V6u1axuo3RXYXqiH97ZHHysqz oSGzYrOYwWvfM7Di4327e9GPbK7GoYw= X-MC-Unique: aZXZZL9NO_WrpMBB0dj5cA-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 05/13] Use virHashForEachSorted in tested code Date: Mon, 26 Oct 2020 16:45:45 +0100 Message-Id: <21106e147e2d631e1c7ca9f75d45d26eac70932d.1603726723.git.pkrempa@redhat.com> In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" The simplest way to write tests is to check the output against expected output, but we must ensure that the output is stable. We can use virHashForEachSorted as a hash iterator to ensure stable ordering. This patch fixes 3 instances of hash iteration which is tested in various parts, including test output changes in appropriate places. Signed-off-by: Peter Krempa --- src/qemu/qemu_domain.c | 6 +- src/util/virmacmap.c | 2 +- tests/qemumonitorjsontest.c | 2 +- .../blockjob-blockdev-in.xml | 116 +++++++++--------- 4 files changed, 63 insertions(+), 63 deletions(-) diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index d7dbca487a..e770940aca 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -2223,9 +2223,9 @@ qemuDomainObjPrivateXMLFormatBlockjobs(virBufferPtr b= uf, virTristateBoolTypeToString(virTristateBoolFromBool(= bj))); if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV) && - virHashForEach(priv->blockjobs, - qemuDomainObjPrivateXMLFormatBlockjobIterator, - &iterdata) < 0) + virHashForEachSorted(priv->blockjobs, + qemuDomainObjPrivateXMLFormatBlockjobIterator, + &iterdata) < 0) return -1; virXMLFormatElement(buf, "blockjobs", &attrBuf, &childBuf); diff --git a/src/util/virmacmap.c b/src/util/virmacmap.c index 2d203e72af..fe71b06dd7 100644 --- a/src/util/virmacmap.c +++ b/src/util/virmacmap.c @@ -244,7 +244,7 @@ virMacMapDumpStrLocked(virMacMapPtr mgr, arr =3D virJSONValueNewArray(); - if (virHashForEach(mgr->macs, virMACMapHashDumper, arr) < 0) + if (virHashForEachSorted(mgr->macs, virMACMapHashDumper, arr) < 0) goto cleanup; if (!(*str =3D virJSONValueToString(arr, true))) diff --git a/tests/qemumonitorjsontest.c b/tests/qemumonitorjsontest.c index 61935134af..d7c9af7e88 100644 --- a/tests/qemumonitorjsontest.c +++ b/tests/qemumonitorjsontest.c @@ -2792,7 +2792,7 @@ testBlockNodeNameDetect(const void *opaque) blockstatsJson))) goto cleanup; - virHashForEach(nodedata, testBlockNodeNameDetectFormat, &buf); + virHashForEachSorted(nodedata, testBlockNodeNameDetectFormat, &buf); virBufferTrim(&buf, "\n"); diff --git a/tests/qemustatusxml2xmldata/blockjob-blockdev-in.xml b/tests/q= emustatusxml2xmldata/blockjob-blockdev-in.xml index 8ffc91bdcb..c70742418b 100644 --- a/tests/qemustatusxml2xmldata/blockjob-blockdev-in.xml +++ b/tests/qemustatusxml2xmldata/blockjob-blockdev-in.xml @@ -234,9 +234,12 @@ - - - + + + + + + @@ -244,9 +247,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -284,61 +339,6 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -2 --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) client-ip=63.128.21.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727209; cv=none; d=zohomail.com; s=zohoarc; b=TeMcoqDO/8TYRNvkj4ZijP+IdT/tt3yDVtNmyKr6h/pkXR7O5BJXVbkySzUB0HDUWpoDnx/EWJMi443Sfs/5QXav3+bvxSyseoeeRtNE+YQ3d8bKLthfJgO9dQkzOt59TgoLsDQ8zQsCFXgBj9sJyBO7WUeZxw7LYXrkyz+zRss= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727209; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=3ZR7vy60PJJeBReF4JldbsFve2eWDoZEVIjt80mVmVI=; b=bCdL1i1RSkPKA2J/ai8i8OtiRaSf/hY8TF1/ki3ZYA/ZHzgnRHu18umvPEmWTRU+ZSj33eiY2/jc9QJn0gHJrseXUA66j6G/UqOSQtm1qH0aJdDxeEZnZntnxW/VRxNR4nOPDSWQf58pQFVpr3ap3uMDJnfbVCxgQkuogbw0WKY= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) by mx.zohomail.com with SMTPS id 1603727209795992.872543691784; Mon, 26 Oct 2020 08:46:49 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-484-0MrnwVOFOyyvvawR_lnnMg-1; Mon, 26 Oct 2020 11:46:46 -0400 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id D698E803F65; Mon, 26 Oct 2020 15:46:40 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id B88C16EF40; Mon, 26 Oct 2020 15:46:40 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 7E84D92F2C; Mon, 26 Oct 2020 15:46:40 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFk5kA018539 for ; Mon, 26 Oct 2020 11:46:05 -0400 Received: by smtp.corp.redhat.com (Postfix) id B0CBB1992F; Mon, 26 Oct 2020 15:46:05 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 0DE1B19D7D for ; Mon, 26 Oct 2020 15:46:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727208; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=3ZR7vy60PJJeBReF4JldbsFve2eWDoZEVIjt80mVmVI=; b=P9i0Ti81BLThdKnNW8c82+yAWT4MDXfLKJABjgcFE6FkPWDeX+CTFjfmgjThglISDuqVS0 +p7bEEqeHVTeMgJwxyhGu2ZWPTb1Ycc6BgAEF3FLR81wM1SVUXtoPZqZE4AnHQF2d/jJLl rARaUzQbAKOTEjmfEb2je4e6PPjicTY= X-MC-Unique: 0MrnwVOFOyyvvawR_lnnMg-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 06/13] tests: remove virdeterministichashmock.so Date: Mon, 26 Oct 2020 16:45:46 +0100 Message-Id: <6d196972df9ced3cd28873cb5a27d5a8a8a1a372.1603726723.git.pkrempa@redhat.com> In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" Code which is sensitive to ordering now uses deterministic iterator functions, so we can remove the mock override. Signed-off-by: Peter Krempa --- 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 =3D [ { '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 =3D=3D 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 =3D=3D 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/virdeterministichashm= ock.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 - * . - */ - -#include - -#include "util/virhashcode.h" - -uint32_t -virHashCodeGen(const void *key, - size_t len, - uint32_t seed G_GNUC_UNUSED) -{ - const uint8_t *k =3D key; - uint32_t h =3D 0; - size_t i; - - for (i =3D 0; i < len; i++) - h +=3D 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 =3D=3D 0 ? EXIT_SUCCESS : EXIT_FAILURE; } -VIR_TEST_MAIN_PRELOAD(mymain, VIR_TEST_MOCK("virdeterministichash")) +VIR_TEST_MAIN(mymain) --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) client-ip=216.205.24.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727583; cv=none; d=zohomail.com; s=zohoarc; b=gVjcTt6/xF+Y4tdsETGdw1uJaqPAfbrN5bnOUUPoI9zu9Cd0ULPowS8w3iXjXiu5cdZM/rBmNIEDvzNt0fuERmrsYtwOAb2fPgy/mrbp/SfYKJiVtMtxMugTlWQPLiFJp0bHE0VCpk9RpjLcUP8dkU7+02yAbu9eR11CzMLUUuE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727583; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=bgCJut4KlWzbe+AWmhKMvRF5f37kWg+mnZlfflTfCwg=; b=imEuogfQI0odOF/ebM4CulI0SCZ8EftHsXpWyfEl1EeV1DZVHvndwRTky2mGEHGkyWHvanTQY41wH8S/HmI2bIuK6J6ESsw09ePP48Gu1hI/IZmTCkxLTaE/79JCpEMWTDJe7ypSpyUhsB5xtVejiCBw8TO9/RT7cqzmj7a9m0U= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by mx.zohomail.com with SMTPS id 1603727583936900.7382261400805; Mon, 26 Oct 2020 08:53:03 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-146-Ck6xrpLtPYic_kNv8nj7Qg-1; Mon, 26 Oct 2020 11:52:37 -0400 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 431378030DC; Mon, 26 Oct 2020 15:52:32 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 1BE8873664; Mon, 26 Oct 2020 15:52:32 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id D8A5F92F28; Mon, 26 Oct 2020 15:52:30 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFk6xB018548 for ; Mon, 26 Oct 2020 11:46:06 -0400 Received: by smtp.corp.redhat.com (Postfix) id DC45119D7D; Mon, 26 Oct 2020 15:46:06 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 2C3D51992F for ; Mon, 26 Oct 2020 15:46:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727583; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=bgCJut4KlWzbe+AWmhKMvRF5f37kWg+mnZlfflTfCwg=; b=Uc5vjZ849sraW8LJUMmkr07E8z02c75+DLU057yiAFapNY+ZNdzX2SR5lOThP2C0sUnaCA C7MhZVIzDg+UOupszHkGCG5rY/F34znrmpr4cDrEKV899EO/Ry2eCyVwMYMKpwaRX5iN58 ejlgsJ/63/BN9a1Dw3a/QvWlm0JG/nw= X-MC-Unique: Ck6xrpLtPYic_kNv8nj7Qg-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 07/13] util: hash: Add delete-safe hash iterator Date: Mon, 26 Oct 2020 16:45:47 +0100 Message-Id: <29a47e6b1423613c6bc5bc0c17149bfc517fdadf.1603726723.git.pkrempa@redhat.com> In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" 'virHashForEach' historically allowed deletion of the current element as 'virHashRemoveSet' didn't exits. To prevent us from having to deepy analyse all iterators add virHashForEachSafe which first gets a list of elements and iterates them outside of the hash table. This will allow replace the internals of the hash table with other implementation which don't allow such operation. Signed-off-by: Peter Krempa --- src/libvirt_private.syms | 1 + src/util/virhash.c | 26 +++++++++++++++++++++++--- src/util/virhash.h | 1 + 3 files changed, 25 insertions(+), 3 deletions(-) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 1793b81ad9..f7b0d11ca2 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -2203,6 +2203,7 @@ virHashAtomicSteal; virHashAtomicUpdate; virHashEqual; virHashForEach; +virHashForEachSafe; virHashForEachSorted; virHashFree; virHashGetItems; diff --git a/src/util/virhash.c b/src/util/virhash.c index f205291de9..e54052985f 100644 --- a/src/util/virhash.c +++ b/src/util/virhash.c @@ -481,7 +481,7 @@ virHashRemoveEntry(virHashTablePtr table, const char *n= ame) /** - * virHashForEach, virHashForEachSorted + * virHashForEach, virHashForEachSorted, virHashForEachSafe * @table: the hash table to process * @iter: callback to process each element * @opaque: opaque data to pass to the iterator @@ -490,14 +490,14 @@ virHashRemoveEntry(virHashTablePtr table, const char = *name) * * The elements are iterated in arbitrary order. * - * virHashForEach allows the callback to remove the current + * virHashForEach, virHashForEachSafe allow the callback to remove the cur= rent * element using virHashRemoveEntry but calling other virHash* functions is * prohibited. Note that removing the entry invalidates @key and @payload = in * the callback. * * virHashForEachSorted iterates the elements in order by sorted key. * - * virHashForEachSorted is more computationally + * virHashForEachSorted and virHashForEachSafe are more computationally * expensive than virHashForEach. * * If @iter fails and returns a negative value, the evaluation is stopped = and -1 @@ -531,6 +531,26 @@ virHashForEach(virHashTablePtr table, virHashIterator = iter, void *opaque) } +int +virHashForEachSafe(virHashTablePtr table, + virHashIterator iter, + void *opaque) +{ + g_autofree virHashKeyValuePairPtr items =3D virHashGetItems(table, NUL= L, false); + size_t i; + + if (!items) + return -1; + + for (i =3D 0; items[i].key; i++) { + if (iter((void *)items[i].value, items[i].key, opaque) < 0) + return -1; + } + + return 0; +} + + int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, diff --git a/src/util/virhash.h b/src/util/virhash.h index 1a59e9799d..b00ab0447e 100644 --- a/src/util/virhash.h +++ b/src/util/virhash.h @@ -136,6 +136,7 @@ bool virHashEqual(const virHashTable *table1, * Iterators */ int virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaq= ue); +int virHashForEachSafe(virHashTablePtr table, virHashIterator iter, void *= opaque); int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void= *opaque); ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, cons= t void *opaque); void *virHashSearch(const virHashTable *table, virHashSearcher iter, --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) client-ip=216.205.24.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727213; cv=none; d=zohomail.com; s=zohoarc; b=T93KVmKGnGa0zkq8RPaWaoK0dOXoPiI6f3wtsgCXH1oai6afJKDihUMXmJH5gpaW7uCBAiwdjI6Pp4Bp8dVvVLsqzGXaDSVgpaivHyx3JLOMBDNH+FacCY8r3q0a5qP0atyTUdMxlp0B6mXJsKWMWJcMUvJVxJx+qRwUSSrkO/Y= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727213; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=b9Vr5vkpJ2B9+W5Lt7VUbanhC1mVyLsM7ZFwETYNzHc=; b=X+yX1LunLl/wpHCeOcbKOqkvazouPJ0Icc1LdBamgdjX8Vn8aaanGDa4uIMqx3DFrE1H4piebjF4AHGduw1Z+qlx3DLo3Z/U/Cnn1yRxjMYKhy1i4FmICjl7a0zSvJmSuH1sKs/Y4vR3udGvjNVbAD89N2P9Gv5uPA1EAothk/o= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by mx.zohomail.com with SMTPS id 1603727213949273.89287283028204; Mon, 26 Oct 2020 08:46:53 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-47-vKIyU07bNPudCqxsN-Z5eg-1; Mon, 26 Oct 2020 11:46:50 -0400 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 8D90C809DCA; Mon, 26 Oct 2020 15:46:43 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 6A3FA5D9E4; Mon, 26 Oct 2020 15:46:43 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 35D9C92F2E; Mon, 26 Oct 2020 15:46:43 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFk8Ug018559 for ; Mon, 26 Oct 2020 11:46:08 -0400 Received: by smtp.corp.redhat.com (Postfix) id 0BF7819728; Mon, 26 Oct 2020 15:46:08 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4AB2A19D7D for ; Mon, 26 Oct 2020 15:46:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727213; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=b9Vr5vkpJ2B9+W5Lt7VUbanhC1mVyLsM7ZFwETYNzHc=; b=GwyPw08Z40lz6OYqeOh4NISBo5Sw3k8TGHqoLHGzb0wAUFIFZ+zrvuHU1n2/lp5MdMfM1q /HJ9qYAs/Kjnuex0zb31USArla8hsiQoOs2TOQfyNmpxrEPDWf8cIUk+p82GLjgXw6LsfE OOLS6sJFAk3bTDwNELlIv5qzlZmVLeE= X-MC-Unique: vKIyU07bNPudCqxsN-Z5eg-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 08/13] util: hash: Use virHashForEachSafe in places which might delete the element Date: Mon, 26 Oct 2020 16:45:48 +0100 Message-Id: In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" 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 --- 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/virdomainmomentob= jlist.c index 511bf1d415..5665819874 100644 --- a/src/conf/virdomainmomentobjlist.c +++ b/src/conf/virdomainmomentobjlist.c @@ -475,7 +475,7 @@ virDomainMomentForEach(virDomainMomentObjListPtr moment= s, 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 =3D { .callback =3D callback, .opaque =3D opaque, .ret =3D 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 =3D { 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/virnwfilterbin= dingobjlist.c index 4cbb62abfa..ffcf8faf3a 100644 --- a/src/conf/virnwfilterbindingobjlist.c +++ b/src/conf/virnwfilterbindingobjlist.c @@ -365,7 +365,7 @@ virNWFilterBindingObjListForEach(virNWFilterBindingObjL= istPtr bindings, callback, opaque, 0, }; virObjectRWLockRead(bindings); - virHashForEach(bindings->objs, virNWFilterBindingObjListHelper, &data); + virHashForEachSafe(bindings->objs, virNWFilterBindingObjListHelper, &d= ata); 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 p= ools, struct _virStoragePoolObjListForEachData data =3D { .iter =3D iter, .opaque =3D opaque }; - virHashForEach(pools->objs, virStoragePoolObjListForEachCb, &data); + virHashForEachSafe(pools->objs, virStoragePoolObjListForEachCb, &data); } @@ -753,7 +753,7 @@ virStoragePoolObjForEachVolume(virStoragePoolObjPtr obj, .iter =3D iter, .opaque =3D opaque }; virObjectRWLockRead(obj->volumes); - virHashForEach(obj->volumes->objsKey, virStoragePoolObjForEachVolumeCb, + virHashForEachSafe(obj->volumes->objsKey, virStoragePoolObjForEachVolu= meCb, &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 *n= ame) * * The elements are iterated in arbitrary order. * - * virHashForEach, virHashForEachSafe allow the callback to remove the cur= rent + * 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 =3D 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; } --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) client-ip=63.128.21.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727330; cv=none; d=zohomail.com; s=zohoarc; b=RxgIMjzHmVNyEyOYXv+clvQA1dog36C6Mn35yMyIVHXRSfdnPib3bUTeB8nvdpoEOGDQH7m4pG3TUYmgJdx243CFMWsmFiO7XCBVwd0zF1R5Fnm45Zr319ZyChSyXDAX7fPnrS0bC1GgQjdzFQ6uj2AqMKGeYfLeIyrrV4i9eyM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727330; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=kf65ubFIKizi2vE1UoIqrSQ3e0qPtkZZZwiuhOIpXMs=; b=JQ1d91ku5NQmm8B2eSiaX8yBtyHjtkRHJ5YMXJqp06kwwmrUqeacKoDELOvNr8kEzrCPCV+Giw7iM/hgjS1su4VTFkPUam9zCqqAj00dbgH1McMvptqCSewjd0R5SDRrBXnN1PBj3Ybx/lkdEjOMQFVENHm41BOEm4VPnIBtka0= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) by mx.zohomail.com with SMTPS id 1603727330960989.7386262317119; Mon, 26 Oct 2020 08:48:50 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-278-D7QxZWiVOFi7KvV21CVARg-1; Mon, 26 Oct 2020 11:48:47 -0400 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 2952C803637; Mon, 26 Oct 2020 15:48:42 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id F3C115C1C2; Mon, 26 Oct 2020 15:48:41 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id AB95492F26; Mon, 26 Oct 2020 15:48:41 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFk94n018577 for ; Mon, 26 Oct 2020 11:46:09 -0400 Received: by smtp.corp.redhat.com (Postfix) id 3339A1992F; Mon, 26 Oct 2020 15:46:09 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 7E24319D7D for ; Mon, 26 Oct 2020 15:46:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727329; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=kf65ubFIKizi2vE1UoIqrSQ3e0qPtkZZZwiuhOIpXMs=; b=bGzch2MNNOSv1OlxA8wBpYDgIH4VB+Wg8MznNNHRAJZoZvg8vIe+98ulTl2Q/CUdGM+ROe ZbXRB9GBIuCtKm2MqBUDW+/fEKrQoTyPsxFA5wF43PcXUpXmKUaKuDXR+KKy6pM9ihuGtw cPGBYCrPQPpzEkFGY7E3zCGgoXfOWmU= X-MC-Unique: D7QxZWiVOFi7KvV21CVARg-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 09/13] util: hash: Don't use 'const' with virHashTablePtr Date: Mon, 26 Oct 2020 16:45:49 +0100 Message-Id: In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" We didn't use it rigorously and some helpers even dasted it away. Remove const from all hash utility functions. Signed-off-by: Peter Krempa --- src/conf/nwfilter_params.c | 2 +- src/conf/nwfilter_params.h | 2 +- src/util/virhash.c | 17 ++++++++--------- src/util/virhash.h | 12 ++++++------ 4 files changed, 16 insertions(+), 17 deletions(-) diff --git a/src/conf/nwfilter_params.c b/src/conf/nwfilter_params.c index dd2b92c97b..33bd7437f1 100644 --- a/src/conf/nwfilter_params.c +++ b/src/conf/nwfilter_params.c @@ -983,7 +983,7 @@ virNWFilterVarAccessGetIntIterId(const virNWFilterVarAc= cess *vap) bool virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *varAccess, - const virHashTable *hash) + virHashTablePtr hash) { const char *varName =3D virNWFilterVarAccessGetVarName(varAccess); const char *res; diff --git a/src/conf/nwfilter_params.h b/src/conf/nwfilter_params.h index 4962a86864..b91f830c31 100644 --- a/src/conf/nwfilter_params.h +++ b/src/conf/nwfilter_params.h @@ -119,7 +119,7 @@ virNWFilterVarAccessType virNWFilterVarAccessGetType( unsigned int virNWFilterVarAccessGetIterId(const virNWFilterVarAccess *vap= ); unsigned int virNWFilterVarAccessGetIndex(const virNWFilterVarAccess *vap); bool virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *vap, - const virHashTable *hash); + virHashTablePtr hash); typedef struct _virNWFilterVarCombIterEntry virNWFilterVarCombIterEntry; typedef virNWFilterVarCombIterEntry *virNWFilterVarCombIterEntryPtr; diff --git a/src/util/virhash.c b/src/util/virhash.c index 4f8df8fae3..a5ab48dbf5 100644 --- a/src/util/virhash.c +++ b/src/util/virhash.c @@ -360,7 +360,8 @@ virHashGetEntry(const virHashTable *table, * Returns a pointer to the userdata */ void * -virHashLookup(const virHashTable *table, const char *name) +virHashLookup(virHashTablePtr table, + const char *name) { virHashEntryPtr entry =3D virHashGetEntry(table, name); @@ -381,7 +382,7 @@ virHashLookup(const virHashTable *table, const char *na= me) * Returns true if the entry exists and false otherwise */ bool -virHashHasEntry(const virHashTable *table, +virHashHasEntry(virHashTablePtr table, const char *name) { return !!virHashGetEntry(table, name); @@ -434,7 +435,7 @@ virHashAtomicSteal(virHashAtomicPtr table, * -1 in case of error */ ssize_t -virHashSize(const virHashTable *table) +virHashSize(virHashTablePtr table) { if (table =3D=3D NULL) return -1; @@ -652,15 +653,13 @@ virHashRemoveAll(virHashTablePtr table) * The elements are processed in a undefined order. Caller is * responsible for freeing the @name. */ -void *virHashSearch(const virHashTable *ctable, +void *virHashSearch(virHashTablePtr table, virHashSearcher iter, const void *opaque, char **name) { size_t i; - /* Cast away const for internal detection of misuse. */ - virHashTablePtr table =3D (virHashTablePtr)ctable; if (table =3D=3D NULL || iter =3D=3D NULL) return NULL; @@ -739,7 +738,7 @@ virHashGetItems(virHashTablePtr table, struct virHashEqualData { bool equal; - const virHashTable *table2; + virHashTablePtr table2; virHashValueComparator compar; }; @@ -760,8 +759,8 @@ static int virHashEqualSearcher(const void *payload, co= nst char *name, return 0; } -bool virHashEqual(const virHashTable *table1, - const virHashTable *table2, +bool virHashEqual(virHashTablePtr table1, + virHashTablePtr table2, virHashValueComparator compar) { struct virHashEqualData data =3D { diff --git a/src/util/virhash.h b/src/util/virhash.h index b00ab0447e..3af4786e9b 100644 --- a/src/util/virhash.h +++ b/src/util/virhash.h @@ -60,7 +60,7 @@ typedef int (*virHashSearcher) (const void *payload, cons= t char *name, virHashTablePtr virHashNew(virHashDataFree dataFree); virHashAtomicPtr virHashAtomicNew(virHashDataFree dataFree); void virHashFree(virHashTablePtr table); -ssize_t virHashSize(const virHashTable *table); +ssize_t virHashSize(virHashTablePtr table); /* * Add a new entry to the hash table. @@ -88,8 +88,8 @@ void virHashRemoveAll(virHashTablePtr table); /* * Retrieve the userdata. */ -void *virHashLookup(const virHashTable *table, const char *name); -bool virHashHasEntry(const virHashTable *table, const char *name); +void *virHashLookup(virHashTablePtr table, const char *name); +bool virHashHasEntry(virHashTablePtr table, const char *name); /* * Retrieve & remove the userdata. @@ -127,8 +127,8 @@ virHashKeyValuePairPtr virHashGetItems(virHashTablePtr = table, * of two keys. */ typedef int (*virHashValueComparator)(const void *value1, const void *valu= e2); -bool virHashEqual(const virHashTable *table1, - const virHashTable *table2, +bool virHashEqual(virHashTablePtr table1, + virHashTablePtr table2, virHashValueComparator compar); @@ -139,7 +139,7 @@ int virHashForEach(virHashTablePtr table, virHashIterat= or 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, cons= t void *opaque); -void *virHashSearch(const virHashTable *table, virHashSearcher iter, +void *virHashSearch(virHashTablePtr table, virHashSearcher iter, const void *opaque, char **name); G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, virHashFree); --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) client-ip=63.128.21.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727564; cv=none; d=zohomail.com; s=zohoarc; b=ncj0a3r+/IzHppWZc8YOSwIZxPZfC70uY1N/e0Ht581QIA2YucsGO2ExPAkvR0nEAAVJEHMFgPDL9GKSaxP3pUjf2fbc3q/F3AsBWECT46bsir3WmB5oxDavpzUG3+2LvbbvUpkFSYVECHYgAYq2VSNshdjL0P/Oo3RWsnQVpSQ= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727564; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=0RgoA/qCLJHG/mFwg/fR+q/KSvIrouxZbn+T3UL32oo=; b=Dyyl8sQZL7wS1l5y2KUqmNR0BgFkG+cpBYw5kFrZMNZ/+CD/2Eg4yqluspefNJ/I/9kDkexXJMLdcwJ/UwXi1EJhMV9fvfOOSbGPthpPt4wIiiD3LYjO04+kqFfiWtHcIUO15td2RfNSj9THCCe637UfUqRGQFzuCXcomuwrCeU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 63.128.21.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) by mx.zohomail.com with SMTPS id 1603727564545296.92130090652415; Mon, 26 Oct 2020 08:52:44 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-424-KcQLaFWwNreZZJm5J0ZfmQ-1; Mon, 26 Oct 2020 11:52:40 -0400 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id C2382809DC0; Mon, 26 Oct 2020 15:52:34 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 9AC161002D47; Mon, 26 Oct 2020 15:52:34 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 66974181A07C; Mon, 26 Oct 2020 15:52:34 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFkAl4018586 for ; Mon, 26 Oct 2020 11:46:10 -0400 Received: by smtp.corp.redhat.com (Postfix) id 6DB3E19D7D; Mon, 26 Oct 2020 15:46:10 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 96C011992F for ; Mon, 26 Oct 2020 15:46:09 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727563; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=0RgoA/qCLJHG/mFwg/fR+q/KSvIrouxZbn+T3UL32oo=; b=M0kUj5WrA/gL6Mv1L2TVEiCNVpK6rJ9jBvzpQeslEtzY5w5QRdBoa+C+TsaWqwY6+jTPHN ov+9ZxJdlqEolGGd8ckmxHxuKvB0GsGvExGtMYL68faDKAQUg8YS66jOjQY5Bx4hd+eJhz T5F7i9p7wrtwmW4XstcZ6+/bDx+KSyQ= X-MC-Unique: KcQLaFWwNreZZJm5J0ZfmQ-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 10/13] util: hash: Reimplement virHashTable using GHashTable Date: Mon, 26 Oct 2020 16:45:50 +0100 Message-Id: In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" Glib's hash table provides basically the same functionality as our hash table. In most cases the only thing that remains in the virHash* wrappers is NULL-checks of '@table' argument as glib's hash functions don't tolerate NULL. In case of iterators, we adapt the existing API of iterators to glibs to prevent having rewrite all callers at this point. Signed-off-by: Peter Krempa --- src/libvirt_private.syms | 4 - src/util/meson.build | 1 - src/util/virhash.c | 416 ++++++++++----------------------------- src/util/virhash.h | 4 +- src/util/virhashcode.c | 125 ------------ src/util/virhashcode.h | 33 ---- 6 files changed, 107 insertions(+), 476 deletions(-) delete mode 100644 src/util/virhashcode.c delete mode 100644 src/util/virhashcode.h diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index f7b0d11ca2..9a5269fd0b 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -2219,10 +2219,6 @@ virHashSteal; virHashUpdateEntry; -# util/virhashcode.h -virHashCodeGen; - - # util/virhook.h virHookCall; virHookInitialize; diff --git a/src/util/meson.build b/src/util/meson.build index 3b711b1dc2..99f72cb04a 100644 --- a/src/util/meson.build +++ b/src/util/meson.build @@ -36,7 +36,6 @@ util_sources =3D [ 'virgettext.c', 'virgic.c', 'virhash.c', - 'virhashcode.c', 'virhook.c', 'virhostcpu.c', 'virhostmem.c', diff --git a/src/util/virhash.c b/src/util/virhash.c index a5ab48dbf5..ed658714e8 100644 --- a/src/util/virhash.c +++ b/src/util/virhash.c @@ -21,42 +21,13 @@ #include "virerror.h" #include "virhash.h" -#include "viralloc.h" #include "virlog.h" -#include "virhashcode.h" -#include "virrandom.h" -#include "virstring.h" #include "virobject.h" #define VIR_FROM_THIS VIR_FROM_NONE VIR_LOG_INIT("util.hash"); -#define MAX_HASH_LEN 8 - -/* #define DEBUG_GROW */ - -/* - * A single entry in the hash table - */ -typedef struct _virHashEntry virHashEntry; -typedef virHashEntry *virHashEntryPtr; -struct _virHashEntry { - struct _virHashEntry *next; - char *name; - void *payload; -}; - -/* - * The entire hash table - */ -struct _virHashTable { - virHashEntryPtr *table; - uint32_t seed; - size_t size; - size_t nbElems; - virHashDataFree dataFree; -}; struct _virHashAtomic { virObjectLockable parent; @@ -76,13 +47,6 @@ static int virHashAtomicOnceInit(void) VIR_ONCE_GLOBAL_INIT(virHashAtomic); -static size_t -virHashComputeKey(const virHashTable *table, const char *name) -{ - uint32_t value =3D virHashCodeGen(name, strlen(name), table->seed); - return value % table->size; -} - /** * virHashNew: @@ -95,18 +59,7 @@ virHashComputeKey(const virHashTable *table, const char = *name) virHashTablePtr virHashNew(virHashDataFree dataFree) { - virHashTablePtr table =3D NULL; - - table =3D g_new0(virHashTable, 1); - - table->seed =3D virRandomBits(32); - table->size =3D 32; - table->nbElems =3D 0; - table->dataFree =3D dataFree; - - table->table =3D g_new0(virHashEntryPtr, table->size); - - return table; + return g_hash_table_new_full(g_str_hash, g_str_equal, g_free, dataFree= ); } @@ -138,66 +91,6 @@ virHashAtomicDispose(void *obj) } -/** - * virHashGrow: - * @table: the hash table - * @size: the new size of the hash table - * - * resize the hash table - * - * Returns 0 in case of success, -1 in case of failure - */ -static int -virHashGrow(virHashTablePtr table, size_t size) -{ - size_t oldsize, i; - virHashEntryPtr *oldtable; - -#ifdef DEBUG_GROW - size_t nbElem =3D 0; -#endif - - if (table =3D=3D NULL) - return -1; - if (size < 8) - return -1; - if (size > 8 * 2048) - return -1; - - oldsize =3D table->size; - oldtable =3D table->table; - if (oldtable =3D=3D NULL) - return -1; - - table->table =3D g_new0(virHashEntryPtr, size); - table->size =3D size; - - for (i =3D 0; i < oldsize; i++) { - virHashEntryPtr iter =3D oldtable[i]; - while (iter) { - virHashEntryPtr next =3D iter->next; - size_t key =3D virHashComputeKey(table, iter->name); - - iter->next =3D table->table[key]; - table->table[key] =3D iter; - -#ifdef DEBUG_GROW - nbElem++; -#endif - iter =3D next; - } - } - - VIR_FREE(oldtable); - -#ifdef DEBUG_GROW - VIR_DEBUG("virHashGrow : from %d to %d, %ld elems", oldsize, - size, nbElem); -#endif - - return 0; -} - /** * virHashFree: * @table: the hash table @@ -208,76 +101,12 @@ virHashGrow(virHashTablePtr table, size_t size) void virHashFree(virHashTablePtr table) { - size_t i; - if (table =3D=3D NULL) return; - for (i =3D 0; i < table->size; i++) { - virHashEntryPtr iter =3D table->table[i]; - while (iter) { - virHashEntryPtr next =3D iter->next; - - if (table->dataFree) - table->dataFree(iter->payload); - g_free(iter->name); - VIR_FREE(iter); - iter =3D next; - } - } - - VIR_FREE(table->table); - VIR_FREE(table); + g_hash_table_unref(table); } -static int -virHashAddOrUpdateEntry(virHashTablePtr table, const char *name, - void *userdata, - bool is_update) -{ - size_t key, len =3D 0; - virHashEntryPtr entry; - virHashEntryPtr last =3D NULL; - - if ((table =3D=3D NULL) || (name =3D=3D NULL)) - return -1; - - key =3D virHashComputeKey(table, name); - - /* Check for duplicate entry */ - for (entry =3D table->table[key]; entry; entry =3D entry->next) { - if (STREQ(entry->name, name)) { - if (is_update) { - if (table->dataFree) - table->dataFree(entry->payload); - entry->payload =3D userdata; - return 0; - } else { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Duplicate hash table key '%s'"), name); - return -1; - } - } - last =3D entry; - len++; - } - - entry =3D g_new0(virHashEntry, 1); - entry->name =3D g_strdup(name); - entry->payload =3D userdata; - - if (last) - last->next =3D entry; - else - table->table[key] =3D entry; - - table->nbElems++; - - if (len > MAX_HASH_LEN) - virHashGrow(table, MAX_HASH_LEN * table->size); - - return 0; -} /** * virHashAddEntry: @@ -293,7 +122,18 @@ virHashAddOrUpdateEntry(virHashTablePtr table, const c= har *name, int virHashAddEntry(virHashTablePtr table, const char *name, void *userdata) { - return virHashAddOrUpdateEntry(table, name, userdata, false); + if (!table || !name) + return -1; + + if (g_hash_table_contains(table, name)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Duplicate hash table key '%s'"), name); + return -1; + } + + g_hash_table_insert(table, g_strdup(name), userdata); + + return 0; } /** @@ -312,7 +152,12 @@ int virHashUpdateEntry(virHashTablePtr table, const char *name, void *userdata) { - return virHashAddOrUpdateEntry(table, name, userdata, true); + if (!table || !name) + return -1; + + g_hash_table_insert(table, g_strdup(name), userdata); + + return 0; } int @@ -323,33 +168,13 @@ virHashAtomicUpdate(virHashAtomicPtr table, int ret; virObjectLock(table); - ret =3D virHashAddOrUpdateEntry(table->hash, name, userdata, true); + ret =3D virHashUpdateEntry(table->hash, name, userdata); virObjectUnlock(table); return ret; } -static virHashEntryPtr -virHashGetEntry(const virHashTable *table, - const char *name) -{ - size_t key; - virHashEntryPtr entry; - - if (!table || !name) - return NULL; - - key =3D virHashComputeKey(table, name); - for (entry =3D table->table[key]; entry; entry =3D entry->next) { - if (STREQ(entry->name, name)) - return entry; - } - - return NULL; -} - - /** * virHashLookup: * @table: the hash table @@ -363,12 +188,10 @@ void * virHashLookup(virHashTablePtr table, const char *name) { - virHashEntryPtr entry =3D virHashGetEntry(table, name); - - if (!entry) + if (!table || !name) return NULL; - return entry->payload; + return g_hash_table_lookup(table, name); } @@ -385,7 +208,10 @@ bool virHashHasEntry(virHashTablePtr table, const char *name) { - return !!virHashGetEntry(table, name); + if (!table || !name) + return false; + + return g_hash_table_contains(table, name); } @@ -401,14 +227,19 @@ virHashHasEntry(virHashTablePtr table, */ void *virHashSteal(virHashTablePtr table, const char *name) { - void *data =3D virHashLookup(table, name); - if (data) { - virHashDataFree dataFree =3D table->dataFree; - table->dataFree =3D NULL; - virHashRemoveEntry(table, name); - table->dataFree =3D dataFree; - } - return data; + g_autofree void *orig_name =3D NULL; + void *val =3D NULL; + + if (!table || !name) + return NULL; + + /* we can replace this by g_hash_table_steal_extended with glib 2.58 */ + if (!(g_hash_table_lookup_extended(table, name, &orig_name, &val))) + return NULL; + + g_hash_table_steal(table, name); + + return val; } void * @@ -439,7 +270,8 @@ virHashSize(virHashTablePtr table) { if (table =3D=3D NULL) return -1; - return table->nbElems; + + return g_hash_table_size(table); } @@ -455,27 +287,14 @@ virHashSize(virHashTablePtr table) * Returns 0 if the removal succeeded and -1 in case of error or not found. */ int -virHashRemoveEntry(virHashTablePtr table, const char *name) +virHashRemoveEntry(virHashTablePtr table, + const char *name) { - virHashEntryPtr entry; - virHashEntryPtr *nextptr; - - if (table =3D=3D NULL || name =3D=3D NULL) + if (!table || !name) return -1; - nextptr =3D table->table + virHashComputeKey(table, name); - for (entry =3D *nextptr; entry; entry =3D entry->next) { - if (STREQ(entry->name, name)) { - if (table->dataFree) - table->dataFree(entry->payload); - g_free(entry->name); - *nextptr =3D entry->next; - VIR_FREE(entry); - table->nbElems--; - return 0; - } - nextptr =3D &entry->next; - } + if (g_hash_table_remove(table, name)) + return 0; return -1; } @@ -511,23 +330,18 @@ virHashRemoveEntry(virHashTablePtr table, const char = *name) int virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaque) { - size_t i; - int ret =3D -1; + GHashTableIter htitr; + void *key; + void *value; - if (table =3D=3D NULL || iter =3D=3D NULL) + if (!table || !iter) return -1; - for (i =3D 0; i < table->size; i++) { - virHashEntryPtr entry =3D table->table[i]; - while (entry) { - virHashEntryPtr next =3D entry->next; - ret =3D iter(entry->payload, entry->name, opaque); + g_hash_table_iter_init(&htitr, table); - if (ret < 0) - return ret; - - entry =3D next; - } + while (g_hash_table_iter_next(&htitr, &key, &value)) { + if (iter(value, key, opaque) < 0) + return -1; } return 0; @@ -574,6 +388,24 @@ virHashForEachSorted(virHashTablePtr table, } +struct virHashSearcherWrapFuncData { + virHashSearcher iter; + const void *opaque; + const char *name; +}; + +static gboolean +virHashSearcherWrapFunc(gpointer key, + gpointer value, + gpointer opaque) +{ + struct virHashSearcherWrapFuncData *data =3D opaque; + + data->name =3D key; + + return !!(data->iter(value, key, data->opaque)); +} + /** * virHashRemoveSet * @table: the hash table to process @@ -592,39 +424,12 @@ virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void *opaque) { - size_t i, count =3D 0; + struct virHashSearcherWrapFuncData data =3D { iter, opaque, NULL }; if (table =3D=3D NULL || iter =3D=3D NULL) return -1; - for (i =3D 0; i < table->size; i++) { - virHashEntryPtr *nextptr =3D table->table + i; - - while (*nextptr) { - virHashEntryPtr entry =3D *nextptr; - if (!iter(entry->payload, entry->name, opaque)) { - nextptr =3D &entry->next; - } else { - count++; - if (table->dataFree) - table->dataFree(entry->payload); - g_free(entry->name); - *nextptr =3D entry->next; - VIR_FREE(entry); - table->nbElems--; - } - } - } - - return count; -} - -static int -_virHashRemoveAllIter(const void *payload G_GNUC_UNUSED, - const char *name G_GNUC_UNUSED, - const void *opaque G_GNUC_UNUSED) -{ - return 1; + return g_hash_table_foreach_remove(table, virHashSearcherWrapFunc, &da= ta); } /** @@ -637,7 +442,10 @@ _virHashRemoveAllIter(const void *payload G_GNUC_UNUSE= D, void virHashRemoveAll(virHashTablePtr table) { - virHashRemoveSet(table, _virHashRemoveAllIter, NULL); + if (!table) + return; + + g_hash_table_remove_all(table); } /** @@ -658,45 +466,19 @@ void *virHashSearch(virHashTablePtr table, const void *opaque, char **name) { - size_t i; + struct virHashSearcherWrapFuncData data =3D { iter, opaque, NULL }; + void *ret; - - if (table =3D=3D NULL || iter =3D=3D NULL) + if (!table || !iter) return NULL; - for (i =3D 0; i < table->size; i++) { - virHashEntryPtr entry; - for (entry =3D table->table[i]; entry; entry =3D entry->next) { - if (iter(entry->payload, entry->name, opaque)) { - if (name) - *name =3D g_strdup(entry->name); - return entry->payload; - } - } - } - - return NULL; -} - - -struct virHashGetItemsIteratorData { - virHashKeyValuePair *items; - size_t i; -}; - - -static int -virHashGetItemsIterator(void *payload, - const char *key, - void *opaque) -{ - struct virHashGetItemsIteratorData *data =3D opaque; + if (!(ret =3D g_hash_table_find(table, virHashSearcherWrapFunc, &data)= )) + return NULL; - data->items[data->i].key =3D key; - data->items[data->i].value =3D payload; + if (name) + *name =3D g_strdup(data.name); - data->i++; - return 0; + return ret; } @@ -716,22 +498,34 @@ virHashGetItems(virHashTablePtr table, size_t *nitems, bool sortKeys) { + virHashKeyValuePair *items; size_t dummy; - struct virHashGetItemsIteratorData data =3D { .items =3D NULL, .i =3D = 0 }; + GHashTableIter htitr; + void *key; + void *value; + size_t i =3D 0; if (!nitems) nitems =3D &dummy; - *nitems =3D virHashSize(table); + if (!table) + return NULL; + + *nitems =3D g_hash_table_size(table); + items =3D g_new0(virHashKeyValuePair, *nitems + 1); - data.items =3D g_new0(virHashKeyValuePair, *nitems + 1); + g_hash_table_iter_init(&htitr, table); - virHashForEach(table, virHashGetItemsIterator, &data); + while (g_hash_table_iter_next(&htitr, &key, &value)) { + items[i].key =3D key; + items[i].value =3D value; + i++; + } if (sortKeys) - qsort(data.items, *nitems, sizeof(* data.items), virHashGetItemsKe= ySorter); + qsort(items, *nitems, sizeof(*items), virHashGetItemsKeySorter); - return data.items; + return items; } diff --git a/src/util/virhash.h b/src/util/virhash.h index 3af4786e9b..70f74dbc5f 100644 --- a/src/util/virhash.h +++ b/src/util/virhash.h @@ -12,7 +12,7 @@ /* * The hash table. */ -typedef struct _virHashTable virHashTable; +typedef GHashTable virHashTable; typedef virHashTable *virHashTablePtr; typedef struct _virHashAtomic virHashAtomic; @@ -142,4 +142,4 @@ ssize_t virHashRemoveSet(virHashTablePtr table, virHash= Searcher iter, const void void *virHashSearch(virHashTablePtr table, virHashSearcher iter, const void *opaque, char **name); -G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, virHashFree); +G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, g_hash_table_unref); diff --git a/src/util/virhashcode.c b/src/util/virhashcode.c deleted file mode 100644 index baa7a0b1c0..0000000000 --- a/src/util/virhashcode.c +++ /dev/null @@ -1,125 +0,0 @@ -/* - * virhashcode.c: hash code generation - * - * Copyright (C) 2012 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 - * . - * - * The hash code generation is based on the public domain MurmurHash3 from= Austin Appleby: - * https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp - * - * We use only the 32 bit variant because the 2 produce different results = while - * we need to produce the same result regardless of the architecture as - * clients can be both 64 or 32 bit at the same time. - */ - -#include - -#include "virhashcode.h" - -static uint32_t rotl32(uint32_t x, int8_t r) -{ - return (x << r) | (x >> (32 - r)); -} - -/* slower than original but handles platforms that do only aligned reads */ -static inline uint32_t getblock(const uint8_t *p, int i) -{ - uint32_t r; - size_t size =3D sizeof(r); - - memcpy(&r, &p[i * size], size); - - return r; -} - -/* - * Finalization mix - force all bits of a hash block to avalanche - */ -static inline uint32_t fmix(uint32_t h) -{ - h ^=3D h >> 16; - h *=3D 0x85ebca6b; - h ^=3D h >> 13; - h *=3D 0xc2b2ae35; - h ^=3D h >> 16; - - return h; -} - - -uint32_t virHashCodeGen(const void *key, size_t len, uint32_t seed) -{ - const uint8_t *blocks; - const uint8_t *tail; - size_t nblocks; - uint32_t h1; - uint32_t k1; - uint32_t c1; - uint32_t c2; - size_t i; - - blocks =3D (const uint8_t *)key; - nblocks =3D len / 4; - h1 =3D seed; - c1 =3D 0xcc9e2d51; - c2 =3D 0x1b873593; - - /* body */ - - for (i =3D 0; i < nblocks; i++) { - - k1 =3D getblock(blocks, i); - - k1 *=3D c1; - k1 =3D rotl32(k1, 15); - k1 *=3D c2; - - h1 ^=3D k1; - h1 =3D rotl32(h1, 13); - h1 =3D h1 * 5 + 0xe6546b64; - } - - /* tail */ - - tail =3D (const uint8_t *)key + nblocks * 4; - - k1 =3D 0; - - switch (len & 3) { - case 3: - k1 ^=3D tail[2] << 16; - G_GNUC_FALLTHROUGH; - case 2: - k1 ^=3D tail[1] << 8; - G_GNUC_FALLTHROUGH; - case 1: - k1 ^=3D tail[0]; - k1 *=3D c1; - k1 =3D rotl32(k1, 15); - k1 *=3D c2; - h1 ^=3D k1; - G_GNUC_FALLTHROUGH; - default: - break; - } - - /* finalization */ - - h1 ^=3D len; - h1 =3D fmix(h1); - - return h1; -} diff --git a/src/util/virhashcode.h b/src/util/virhashcode.h deleted file mode 100644 index 10d8451795..0000000000 --- a/src/util/virhashcode.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * virhashcode.h: hash code generation - * - * Copyright (C) 2012 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 - * . - * - * The hash code generation is based on the public domain MurmurHash3 from= Austin Appleby: - * https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp - * - * We use only the 32 bit variant because the 2 produce different result w= hile - * we need to produce the same result regardless of the architecture as - * clients can be both 64 or 32 bit at the same time. - */ - -#pragma once - -#include "internal.h" - -uint32_t virHashCodeGen(const void *key, size_t len, uint32_t seed) - G_GNUC_NO_INLINE; --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) client-ip=216.205.24.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727337; cv=none; d=zohomail.com; s=zohoarc; b=VkQddKNPuwIVShCR2T8b88zjPOr+xt04i1EFJfAn3bJRL2Id+CMuoTdP368e+6P2Nt/FG8gVILnlEbBMwmx3BIrnDQh1fjIoRbl9CkyMQ+CIQ7+70EmuoHmUnsx7Oqhyjh8ZW61kQiIGJ88GWK/XLZ2GR47ZZGVueiTKKyBBKO4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727337; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=5bWimcbUawd0AjZXoVvvPL8uAhteIUAeDZdmdyxkqvw=; b=MwHcIR3F5boWMFU8Wjo3lMZC4z9vvqvX+IxbHE5ap6AiTgykVGEuVKN0vqtZToOjlIpGcjRgVoA1VtpcviUM4pJfBIYbwEA/hz1cJ/fHQv5+vwTB9D8y+iyWF6M80lbMo+w8ZTVqr94flHX3ew7mlrXBxSdcjdHDggwYaAd43yM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by mx.zohomail.com with SMTPS id 1603727337461665.3260245521011; Mon, 26 Oct 2020 08:48:57 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-469-mhJcKDM6OXO98NvqT5eBIg-1; Mon, 26 Oct 2020 11:48:52 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id E6937101EBE9; Mon, 26 Oct 2020 15:48:45 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id C052C55792; Mon, 26 Oct 2020 15:48:45 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 88AF2181A06B; Mon, 26 Oct 2020 15:48:45 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFkC8k018606 for ; Mon, 26 Oct 2020 11:46:12 -0400 Received: by smtp.corp.redhat.com (Postfix) id 1E6141992F; Mon, 26 Oct 2020 15:46:12 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id D463419D6C for ; Mon, 26 Oct 2020 15:46:10 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727336; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=5bWimcbUawd0AjZXoVvvPL8uAhteIUAeDZdmdyxkqvw=; b=PEriKSv8/5YYmKmiXD7CGGeVQbzYB/S5gvvJ6lqYSOMc829M3czDQdxdyN5RxfK1UTqYGz QAJKQi1ZCkFv3+FZmIq+IHNVl3lgiWVdvqhjRPdtTbNVsfXd+GaF+u7h0d9LJwl56Gzh+0 HxDLch+MyI0ITxxmxJOCbMOHsC85ofM= X-MC-Unique: mhJcKDM6OXO98NvqT5eBIg-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 11/13] util: hash: Retire 'virHashTable' in favor of 'GHashTable' Date: Mon, 26 Oct 2020 16:45:51 +0100 Message-Id: In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" 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 --- 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 =3D virHashNew(NULL); + g_autoptr(GHashTable) disks =3D virHashNew(NULL); size_t i; int ndisks; bool backup_all =3D 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_GN= UC_UNUSED, virDomainDeviceInfoPtr info, void *data) { - virHashTablePtr bootHash =3D data; + GHashTable *bootHash =3D data; g_autofree char *order =3D NULL; if (info->bootIndex =3D=3D 0) @@ -5818,7 +5818,7 @@ virDomainDefCollectBootOrder(virDomainDefPtr def G_GN= UC_UNUSED, static int virDomainDefBootOrderPostParse(virDomainDefPtr def) { - virHashTablePtr bootHash =3D NULL; + GHashTable *bootHash =3D NULL; int ret =3D -1; if (!(bootHash =3D virHashNew(NULL))) @@ -6862,7 +6862,7 @@ virDomainDeviceDefValidateInternal(const virDomainDev= iceDef *dev, struct virDomainDefValidateAliasesData { - virHashTablePtr aliases; + GHashTable *aliases; }; @@ -6921,7 +6921,7 @@ virDomainDeviceDefValidateAliasesIterator(virDomainDe= fPtr def, */ static int virDomainDefValidateAliases(const virDomainDef *def, - virHashTablePtr *aliases) + GHashTable **aliases) { struct virDomainDefValidateAliasesData data; int ret =3D -1; @@ -6950,7 +6950,7 @@ static int virDomainDeviceValidateAliasImpl(const virDomainDef *def, virDomainDeviceDefPtr dev) { - virHashTablePtr aliases =3D NULL; + GHashTable *aliases =3D NULL; virDomainDeviceInfoPtr info =3D virDomainDeviceGetInfo(dev); int ret =3D -1; @@ -11961,7 +11961,7 @@ virDomainNetDefParseXML(virDomainXMLOptionPtr xmlop= t, virDomainHostdevDefPtr hostdev; xmlNodePtr cur; xmlNodePtr tmpNode; - virHashTablePtr filterparams =3D NULL; + GHashTable *filterparams =3D NULL; virDomainActualNetDefPtr actual =3D NULL; VIR_XPATH_NODE_AUTORESTORE(ctxt) virDomainChrSourceReconnectDef reconnect =3D {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 virNWFilterInclud= eDef; 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 =3D 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(virNWFilterVarCombIterE= ntryPtr cie, static int virNWFilterVarCombIterAddVariable(virNWFilterVarCombIterEntryPtr cie, - virHashTablePtr hash, + GHashTable *hash, const virNWFilterVarAccess *varAccess) { virNWFilterVarValuePtr varValue; @@ -397,7 +397,7 @@ virNWFilterVarCombIterAddVariable(virNWFilterVarCombIte= rEntryPtr cie, */ static bool virNWFilterVarCombIterEntryAreUniqueEntries(virNWFilterVarCombIterEntryPtr= cie, - virHashTablePtr hash) + GHashTable *hash) { size_t i, j; virNWFilterVarValuePtr varValue, tmp; @@ -455,7 +455,7 @@ virNWFilterVarCombIterEntryAreUniqueEntries(virNWFilter= VarCombIterEntryPtr 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 =3D { .target =3D 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 =3D virHashNew(virNWFilterVarValueHashFree); + GHashTable *table =3D 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 virNWFilterVarAc= cess *vap) bool virNWFilterVarAccessIsAvailable(const virNWFilterVarAccess *varAccess, - virHashTablePtr hash) + GHashTable *hash) { const char *varName =3D 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 *va= lue); -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 sna= pdef, bool require_match) { virDomainDefPtr domdef =3D snapdef->parent.dom; - g_autoptr(virHashTable) map =3D virHashNew(NULL); + g_autoptr(GHashTable) map =3D virHashNew(NULL); g_autofree virDomainSnapshotDiskDefPtr olddisks =3D 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/virdomainmomentob= jlist.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/virnwfilterbinding= def.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/virnwfilterbin= dingobjlist.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 aut= ostart) Msvm_VirtualSystemSettingData *vssd =3D NULL; g_autoptr(hypervInvokeParamsList) params =3D NULL; g_auto(virBuffer) eprQuery =3D VIR_BUFFER_INITIALIZER; - g_autoptr(virHashTable) autostartParam =3D NULL; + g_autoptr(GHashTable) autostartParam =3D NULL; const char *methodName =3D NULL; hypervWmiClassInfoListPtr embeddedParamClass =3D NULL; const char *enabledValue =3D NULL, *disabledValue =3D NULL; @@ -1938,7 +1938,7 @@ hypervDomainSetMemoryFlags(virDomainPtr domain, unsig= ned long memory, Msvm_VirtualSystemSettingData *vssd =3D NULL; Msvm_MemorySettingData *memsd =3D NULL; g_auto(virBuffer) eprQuery =3D VIR_BUFFER_INITIALIZER; - g_autoptr(virHashTable) memResource =3D NULL; + g_autoptr(GHashTable) memResource =3D 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, c= onst 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 i= nfo) { size_t i; size_t count; - g_autoptr(virHashTable) table =3D NULL; + g_autoptr(GHashTable) table =3D NULL; XmlSerializerInfo *typeinfo =3D NULL; hypervWmiClassInfoPtr classInfo =3D NULL; @@ -368,7 +368,7 @@ hypervCreateEmbeddedParam(hypervPrivate *priv, hypervWm= iClassInfoListPtr 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 clear= ed out. @@ -395,7 +395,7 @@ int hypervAddEmbeddedParam(hypervInvokeParamsListPtr params, hypervPrivate *priv, const char *name, - virHashTablePtr *table, + GHashTable **table, hypervWmiClassInfoListPtr info) { hypervParamPtr p =3D 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 represent= s */ }; typedef struct _hypervEmbeddedParam hypervEmbeddedParam; @@ -146,20 +146,20 @@ int hypervAddEprParam(hypervInvokeParamsListPtr param= s, 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/vircloseca= llbacks.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_dhcp= snoop.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/nwfil= ter_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 =3D virFirewallNew(); - g_autoptr(virHashTable) chains_in_set =3D virHashNew(NULL); - g_autoptr(virHashTable) chains_out_set =3D virHashNew(NULL); + g_autoptr(GHashTable) chains_in_set =3D virHashNew(NULL); + g_autoptr(GHashTable) chains_out_set =3D virHashNew(NULL); bool haveEbtables =3D false; bool haveIptables =3D false; bool haveIp6tables =3D 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 *na= me, 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 =3D virHashNew(virNWFilterVarValueHashFree); + GHashTable *res =3D 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 =3D NULL; + GHashTable *tmpvars =3D NULL; virNWFilterDefPtr childdef; virNWFilterDefPtr newChilddef; int ret =3D -1; @@ -369,7 +369,7 @@ virNWFilterIncludeDefToRuleInst(virNWFilterDriverStateP= tr 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 fi= lter, } } } else if (inc) { - g_autoptr(virHashTable) tmpvars =3D NULL; + g_autoptr(GHashTable) tmpvars =3D NULL; VIR_DEBUG("Following filter %s", inc->filterref); if (!(obj =3D virNWFilterObjListFindInstantiateFilter(driver->= nwfilters, @@ -516,7 +516,7 @@ virNWFilterDoInstantiate(virNWFilterTechDriverPtr techd= river, const char *learning; bool reportIP =3D false; - virHashTablePtr missing_vars =3D virHashNew(virNWFilterVarValueHashFre= e); + GHashTable *missing_vars =3D virHashNew(virNWFilterVarValueHashFree); memset(&inst, 0, sizeof(inst)); @@ -639,7 +639,7 @@ virNWFilterDoInstantiate(virNWFilterTechDriverPtr techd= river, 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(virNWFilterDriverSta= tePtr driver, int virNWFilterTeardownFilter(virNWFilterBindingDefPtr binding); -virHashTablePtr virNWFilterCreateVarHashmap(const char *macaddr, +GHashTable *virNWFilterCreateVarHashmap(const char *macaddr, const virNWFilterVarValue *val= ue); int virNWFilterBuildAll(virNWFilterDriverStatePtr driver, diff --git a/src/nwfilter/nwfilter_learnipaddr.c b/src/nwfilter/nwfilter_le= arnipaddr.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 =3D VIR_MUTEX_INITIALIZER; -static virHashTablePtr pendingLearnReq; +static GHashTable *pendingLearnReq; static virMutex ifaceMapLock =3D 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_te= ch_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 =3D NULL; @@ -2205,7 +2205,7 @@ static int qemuAgentGetAllInterfaceAddresses(virDomainInterfacePtr **ifaces_ret, virJSONValuePtr ret_array) { - g_autoptr(virHashTable) ifaces_store =3D NULL; + g_autoptr(GHashTable) ifaces_store =3D NULL; size_t ifaces_count =3D 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(virStorageSourcePt= r backingChain, const char *targetbitmap, const char *incremental, virJSONValuePtr actions, - virHashTablePtr blockNamedNodeData) + GHashTable *blockNamedNodeData) { g_autoptr(virJSONValue) tmpactions =3D NULL; @@ -201,7 +201,7 @@ qemuBackupDiskPrepareOneBitmapsChain(virStorageSourcePt= r 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 =3D vm->privateData; @@ -344,7 +344,7 @@ qemuBackupDiskPrepareDataOnePull(virJSONValuePtr action= s, 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 =3D NULL; struct qemuBackupDiskData *dd =3D NULL; ssize_t ndd =3D 0; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; bool job_started =3D false; bool nbd_running =3D false; bool reuse =3D (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 =3D opaque; + GHashTable *table =3D opaque; const char *name; if (!(name =3D 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, qemuBlockNodeNameBackingChainDataP= tr *nodenamedata) { g_autoptr(qemuBlockNodeNameBackingChainData) data =3D NULL; @@ -224,13 +224,13 @@ qemuBlockNodeNameGetBackingChainDisk(size_t pos G_GNU= C_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 =3D NULL; - g_autoptr(virHashTable) disks =3D NULL; + g_autoptr(GHashTable) namednodestable =3D NULL; + g_autoptr(GHashTable) disks =3D NULL; memset(&data, 0, sizeof(data)); @@ -273,7 +273,7 @@ qemuBlockDiskClearDetectedNodes(virDomainDiskDefPtr dis= k) static int qemuBlockDiskDetectNodes(virDomainDiskDefPtr disk, - virHashTablePtr disktable) + GHashTable *disktable) { qemuBlockNodeNameBackingChainDataPtr entry =3D NULL; virStorageSourcePtr src =3D disk->src; @@ -324,7 +324,7 @@ qemuBlockNodeNamesDetect(virQEMUDriverPtr driver, qemuDomainAsyncJob asyncJob) { qemuDomainObjPrivatePtr priv =3D vm->privateData; - g_autoptr(virHashTable) disktable =3D NULL; + g_autoptr(GHashTable) disktable =3D NULL; g_autoptr(virJSONValue) data =3D NULL; g_autoptr(virJSONValue) blockstats =3D NULL; virDomainDiskDefPtr disk; @@ -363,12 +363,12 @@ qemuBlockNodeNamesDetect(virQEMUDriverPtr driver, * Returns a hash table organized by the node name of the JSON value objec= ts 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 =3D NULL; + g_autoptr(GHashTable) nodedata =3D NULL; if (!(nodedata =3D 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(virHashTableP= tr blockNamedNodeData, } -virHashTablePtr +GHashTable * qemuBlockGetNamedNodeData(virDomainObjPtr vm, qemuDomainAsyncJob asyncJob) { qemuDomainObjPrivatePtr priv =3D vm->privateData; virQEMUDriverPtr driver =3D priv->driver; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; bool supports_flat =3D virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QMP_QUERY_NAMED_BLOCK_NO= DES_FLAT); @@ -2892,7 +2892,7 @@ qemuBlockGetNamedNodeData(virDomainObjPtr vm, static GSList * qemuBlockGetBitmapMergeActionsGetBitmaps(virStorageSourcePtr topsrc, const char *bitmapname, - virHashTablePtr blockNamedNodeDat= a) + GHashTable *blockNamedNodeData) { g_autoptr(GSList) ret =3D NULL; qemuBlockNamedNodeDataPtr entry; @@ -2972,7 +2972,7 @@ qemuBlockGetBitmapMergeActions(virStorageSourcePtr to= psrc, const char *dstbitmapname, virStorageSourcePtr writebitmapsrc, virJSONValuePtr *actions, - virHashTablePtr blockNamedNodeData) + GHashTable *blockNamedNodeData) { g_autoptr(virJSONValue) act =3D virJSONValueNewArray(); virStorageSourcePtr n; @@ -3066,7 +3066,7 @@ qemuBlockGetBitmapMergeActions(virStorageSourcePtr to= psrc, bool qemuBlockBitmapChainIsValid(virStorageSourcePtr src, const char *bitmapname, - virHashTablePtr blockNamedNodeData) + GHashTable *blockNamedNodeData) { virStorageSourcePtr n; bool found =3D 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 =3D 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 to= psrc, 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(virDomainO= bjPtr vm, qemuDomainAsyncJob asyncJob) { qemuDomainObjPrivatePtr priv =3D vm->privateData; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; g_autoptr(virJSONValue) actions =3D NULL; if (!(blockNamedNodeData =3D qemuBlockGetNamedNodeData(vm, asyncJob))) @@ -1097,7 +1097,7 @@ qemuBlockJobProcessEventCompletedCommitBitmaps(virDom= ainObjPtr vm, qemuDomainAsyncJob asyncJob) { qemuDomainObjPrivatePtr priv =3D vm->privateData; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; g_autoptr(virJSONValue) actions =3D NULL; bool active =3D job->type =3D=3D QEMU_BLOCKJOB_TYPE_ACTIVE_COMMIT; @@ -1326,7 +1326,7 @@ qemuBlockJobProcessEventCompletedCopyBitmaps(virDomai= nObjPtr vm, qemuDomainAsyncJob asyncJob) { qemuDomainObjPrivatePtr priv =3D vm->privateData; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; g_autoptr(virJSONValue) actions =3D NULL; bool shallow =3D 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 *virQEMUDomainCapsCacheP= tr; struct _virQEMUDomainCapsCache { virObjectLockable parent; - virHashTablePtr cache; + GHashTable *cache; }; G_DEFINE_AUTOPTR_CLEANUP_FUNC(virQEMUDomainCapsCache, virObjectUnref); @@ -2686,7 +2686,7 @@ virQEMUCapsProbeQMPDeviceProperties(virQEMUCapsPtr qe= muCaps, for (i =3D 0; i < G_N_ELEMENTS(virQEMUCapsDeviceProps); i++) { virQEMUCapsDeviceTypeProps *device =3D virQEMUCapsDeviceProps + i; - g_autoptr(virHashTable) qemuprops =3D NULL; + g_autoptr(GHashTable) qemuprops =3D NULL; size_t j; if (device->capsCondition >=3D 0 && @@ -3065,7 +3065,7 @@ virQEMUCapsProbeQMPHostCPU(virQEMUCapsPtr qemuCaps, const char *model =3D virtType =3D=3D VIR_DOMAIN_VIRT_KVM ? "host" : "= max"; qemuMonitorCPUModelInfoPtr modelInfo =3D NULL; qemuMonitorCPUModelInfoPtr nonMigratable =3D NULL; - virHashTablePtr hash =3D NULL; + GHashTable *hash =3D NULL; virCPUDefPtr cpu; qemuMonitorCPUModelExpansionType type; bool fail_no_props =3D true; @@ -5258,7 +5258,7 @@ virQEMUCapsProbeQMPSchemaCapabilities(virQEMUCapsPtr = qemuCaps, { struct virQEMUCapsStringFlags *entry; virJSONValuePtr schemareply; - virHashTablePtr schema =3D NULL; + GHashTable *schema =3D 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 =3D vm->privateData; virQEMUDriverPtr driver =3D priv->driver; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; int rc =3D -1; g_autoptr(virJSONValue) actions =3D NULL; size_t i; @@ -579,7 +579,7 @@ qemuCheckpointGetXMLDescUpdateSize(virDomainObjPtr vm, { qemuDomainObjPrivatePtr priv =3D vm->privateData; virQEMUDriverPtr driver =3D priv->driver; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; g_autofree struct qemuCheckpointDiskMap *diskmap =3D NULL; g_autoptr(virJSONValue) recoveractions =3D NULL; g_autoptr(virJSONValue) mergeactions =3D 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 dri= ver, int asyncJob) { qemuDomainObjPrivatePtr priv =3D vm->privateData; - virHashTablePtr meminfo =3D NULL; + GHashTable *meminfo =3D 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 =3D vm->privateData; bool blockdev =3D virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV); virDomainDiskDefPtr disk =3D NULL; - virHashTablePtr blockstats =3D NULL; + GHashTable *blockstats =3D NULL; qemuBlockStatsPtr stats; size_t i; int nstats; @@ -14982,7 +14982,7 @@ qemuDomainBlockCopyCommon(virDomainObjPtr vm, g_autoptr(qemuBlockStorageSourceChainData) crdata =3D NULL; virStorageSourcePtr n; virStorageSourcePtr mirrorBacking =3D NULL; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; int rc =3D 0; /* Preliminaries: find the disk we are editing, sanity checks */ @@ -16545,7 +16545,7 @@ qemuDomainGetDiskErrors(virDomainPtr dom, virQEMUDriverPtr driver =3D dom->conn->privateData; virDomainObjPtr vm =3D NULL; qemuDomainObjPrivatePtr priv; - virHashTablePtr table =3D NULL; + GHashTable *table =3D NULL; bool blockdev =3D false; int ret =3D -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 c= har *entryname, static int qemuDomainGetStatsBlockExportFrontend(const char *frontendname, - virHashTablePtr stats, + GHashTable *stats, size_t idx, virTypedParamListPtr par) { @@ -18372,8 +18372,8 @@ qemuDomainGetStatsBlockExportHeader(virDomainDiskDe= fPtr 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 =3D -1; int rc; - virHashTablePtr stats =3D NULL; - virHashTablePtr nodestats =3D NULL; + GHashTable *stats =3D NULL; + GHashTable *nodestats =3D NULL; virJSONValuePtr nodedata =3D NULL; qemuDomainObjPrivatePtr priv =3D dom->privateData; g_autoptr(virQEMUDriverConfig) cfg =3D 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 =3D NULL; @@ -91,7 +91,7 @@ qemuInteropFetchConfigs(const char *name, char ***configs, bool privileged) { - g_autoptr(virHashTable) files =3D NULL; + g_autoptr(GHashTable) files =3D NULL; g_autofree char *homeConfig =3D NULL; g_autofree char *xdgConfig =3D NULL; g_autofree char *sysLocation =3D 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 dri= ver, size_t i; qemuDomainObjPrivatePtr priv =3D vm->privateData; bool nbd =3D false; - virHashTablePtr blockinfo =3D NULL; + GHashTable *blockinfo =3D NULL; qemuDomainMirrorStatsPtr stats =3D &jobInfo->mirrorStats; for (i =3D 0; i < vm->def->ndisks; i++) { diff --git a/src/qemu/qemu_migration_cookie.c b/src/qemu/qemu_migration_coo= kie.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 =3D vm->privateData; - g_autoptr(virHashTable) stats =3D virHashNew(g_free); + g_autoptr(GHashTable) stats =3D virHashNew(g_free); bool blockdev =3D 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 =3D -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=3D%p, backing=3D%d", stats, backingChain); @@ -2191,7 +2191,7 @@ qemuMonitorBlockStatsUpdateCapacity(qemuMonitorPtr mo= n, int qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitorPtr mon, - virHashTablePtr stats) + GHashTable *stats) { VIR_DEBUG("stats=3D%p", stats); @@ -2210,7 +2210,7 @@ qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonit= orPtr mon, * storage nodes and returns them in a hash table of qemuBlockNamedNodeDat= aPtrs * 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 =3D NULL; + GHashTable *info =3D NULL; VIR_DEBUG("retinfo=3D%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 =3D 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 =3D -1; - virHashTablePtr info =3D NULL; + GHashTable *info =3D NULL; *retinfo =3D 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 qemuMonitorCurrentMachineIn= fo; 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 =3D -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 =3D 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 =3D NULL; @@ -2732,7 +2732,7 @@ qemuMonitorJSONQueryBlockstats(qemuMonitorPtr mon) int qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mon, - virHashTablePtr hash, + GHashTable *hash, bool backingChain) { int nstats =3D 0; @@ -2781,7 +2781,7 @@ qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitorPtr mo= n, 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 =3D -1; @@ -2845,7 +2845,7 @@ qemuMonitorJSONBlockStatsUpdateCapacityOne(virJSONVal= uePtr image, int qemuMonitorJSONBlockStatsUpdateCapacity(qemuMonitorPtr mon, - virHashTablePtr stats, + GHashTable *stats, bool backingChain) { int ret =3D -1; @@ -2891,7 +2891,7 @@ qemuMonitorJSONBlockStatsUpdateCapacityBlockdevWorker= (size_t pos G_GNUC_UNUSED, virJSONValuePtr val, void *opaque) { - virHashTablePtr stats =3D opaque; + GHashTable *stats =3D 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 =3D -1; @@ -3020,7 +3020,7 @@ qemuMonitorJSONBlockGetNamedNodeDataWorker(size_t pos= G_GNUC_UNUSED, virJSONValuePtr val, void *opaque) { - virHashTablePtr nodes =3D opaque; + GHashTable *nodes =3D opaque; virJSONValuePtr img; virJSONValuePtr bitmaps; const char *nodename; @@ -3059,10 +3059,10 @@ qemuMonitorJSONBlockGetNamedNodeDataWorker(size_t p= os G_GNUC_UNUSED, } -virHashTablePtr +GHashTable * qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValuePtr nodes) { - g_autoptr(virHashTable) ret =3D NULL; + g_autoptr(GHashTable) ret =3D NULL; ret =3D virHashNew((virHashDataFree) qemuMonitorJSONBlockNamedNodeData= Free); @@ -3075,7 +3075,7 @@ qemuMonitorJSONBlockGetNamedNodeDataJSON(virJSONValue= Ptr nodes) } -virHashTablePtr +GHashTable * qemuMonitorJSONBlockGetNamedNodeData(qemuMonitorPtr mon, bool supports_flat) { @@ -4464,7 +4464,7 @@ qemuMonitorJSONQueryRxFilter(qemuMonitorPtr mon, cons= t char *alias, */ static int qemuMonitorJSONExtractChardevInfo(virJSONValuePtr reply, - virHashTablePtr info) + GHashTable *info) { virJSONValuePtr data; int ret =3D -1; @@ -4532,7 +4532,7 @@ qemuMonitorJSONExtractChardevInfo(virJSONValuePtr rep= ly, int qemuMonitorJSONGetChardevInfo(qemuMonitorPtr mon, - virHashTablePtr info) + GHashTable *info) { int ret =3D -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 bloc= kJobs, 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 =3D NULL; + GHashTable *blockJobs =3D NULL; cmd =3D qemuMonitorJSONMakeCommand("query-block-jobs", NULL); if (!cmd) @@ -6951,7 +6951,7 @@ qemuMonitorJSONGetDevicePropsWorker(size_t pos G_GNUC= _UNUSED, void *opaque) { const char *name =3D virJSONValueObjectGetString(item, "name"); - virHashTablePtr devices =3D opaque; + GHashTable *devices =3D opaque; if (!name) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -6966,11 +6966,11 @@ qemuMonitorJSONGetDevicePropsWorker(size_t pos G_GN= UC_UNUSED, } -virHashTablePtr +GHashTable * qemuMonitorJSONGetDeviceProps(qemuMonitorPtr mon, const char *device) { - g_autoptr(virHashTable) props =3D virHashNew(virJSONValueHashFree); + g_autoptr(GHashTable) props =3D virHashNew(virJSONValueHashFree); g_autoptr(virJSONValue) cmd =3D NULL; g_autoptr(virJSONValue) reply =3D NULL; @@ -8381,7 +8381,7 @@ qemuMonitorJSONSetIOThread(qemuMonitorPtr mon, int qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitorPtr mon, - virHashTablePtr info) + GHashTable *info) { int ret =3D -1; virJSONValuePtr cmd; @@ -9265,7 +9265,7 @@ qemuMonitorJSONGetSEVMeasurement(qemuMonitorPtr mon) */ static int qemuMonitorJSONExtractPRManagerInfo(virJSONValuePtr reply, - virHashTablePtr info) + GHashTable *info) { qemuMonitorPRManagerInfoPtr entry =3D NULL; virJSONValuePtr data; @@ -9309,7 +9309,7 @@ qemuMonitorJSONExtractPRManagerInfo(virJSONValuePtr r= eply, int qemuMonitorJSONGetPRManagerInfo(qemuMonitorPtr mon, - virHashTablePtr info) + GHashTable *info) { int ret =3D -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, co= nst 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 =3D 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 =3D vm->privateData; - virHashTablePtr info =3D NULL; + GHashTable *info =3D NULL; int ret =3D -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 =3D vm->privateData; qemuMonitorPRManagerInfoPtr prManagerInfo; @@ -2343,7 +2343,7 @@ qemuRefreshPRManagerState(virQEMUDriverPtr driver, virDomainObjPtr vm) { qemuDomainObjPrivatePtr priv =3D vm->privateData; - virHashTablePtr info =3D NULL; + GHashTable *info =3D NULL; int ret =3D -1; if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_PR_MANAGER_HELPER) || @@ -2438,7 +2438,7 @@ qemuProcessWaitForMonitor(virQEMUDriverPtr driver, qemuDomainLogContextPtr logCtxt) { int ret =3D -1; - virHashTablePtr info =3D NULL; + GHashTable *info =3D NULL; qemuDomainObjPrivatePtr priv =3D vm->privateData; bool retry =3D true; @@ -7962,7 +7962,7 @@ qemuProcessRefreshDisks(virQEMUDriverPtr driver, { qemuDomainObjPrivatePtr priv =3D vm->privateData; bool blockdev =3D virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV); - virHashTablePtr table =3D NULL; + GHashTable *table =3D NULL; int ret =3D -1; size_t i; @@ -8190,7 +8190,7 @@ static int qemuProcessRefreshLegacyBlockjobs(virQEMUDriverPtr driver, virDomainObjPtr vm) { - virHashTablePtr blockJobs =3D NULL; + GHashTable *blockJobs =3D NULL; int ret =3D -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 virQ= EMUQAPISchemaTraverseCo static void virQEMUQAPISchemaTraverseContextInit(struct virQEMUQAPISchemaTraverseConte= xt *ctxt, char **queries, - virHashTablePtr schema) + GHashTable *schema) { memset(ctxt, 0, sizeof(*ctxt)); ctxt->schema =3D schema; @@ -429,7 +429,7 @@ virQEMUQAPISchemaTraverse(const char *baseName, */ int virQEMUQAPISchemaPathGet(const char *query, - virHashTablePtr schema, + GHashTable *schema, virJSONValuePtr *entry) { VIR_AUTOSTRINGLIST elems =3D NULL; @@ -478,7 +478,7 @@ virQEMUQAPISchemaPathGet(const char *query, bool virQEMUQAPISchemaPathExists(const char *query, - virHashTablePtr schema) + GHashTable *schema) { return virQEMUQAPISchemaPathGet(query, schema, NULL) =3D=3D 1; } @@ -489,7 +489,7 @@ virQEMUQAPISchemaEntryProcess(size_t pos G_GNUC_UNUSED, void *opaque) { const char *name; - virHashTablePtr schema =3D opaque; + GHashTable *schema =3D opaque; if (!(name =3D virJSONValueObjectGetString(item, "name"))) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -511,10 +511,10 @@ virQEMUQAPISchemaEntryProcess(size_t pos G_GNUC_UNUSE= D, * Converts the schema into the hash-table used by the functions working w= ith * the schema. @schemareply is consumed and freed. */ -virHashTablePtr +GHashTable * virQEMUQAPISchemaConvert(virJSONValuePtr schemareply) { - g_autoptr(virHashTable) schema =3D NULL; + g_autoptr(GHashTable) schema =3D NULL; g_autoptr(virJSONValue) schemajson =3D schemareply; if (!(schema =3D 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 dri= ver, qemuSnapshotDiskDataPtr dd, virQEMUDriverConfigPtr cfg, bool reuse, - virHashTablePtr blockNamedNodeData, + GHashTable *blockNamedNodeData, qemuDomainAsyncJob asyncJob) { qemuDomainObjPrivatePtr priv =3D 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 =3D 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 =3D NULL; @@ -1279,7 +1279,7 @@ qemuSnapshotDiskCreate(qemuSnapshotDiskContextPtr sna= pctxt, 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 =3D priv->driver; g_autoptr(virQEMUDriverConfig) cfg =3D virQEMUDriverGetConfig(driver); g_autoptr(qemuSnapshotDiskContext) snapctxt =3D NULL; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D NULL; if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV)) { if (!(blockNamedNodeData =3D qemuBlockGetNamedNodeData(vm, asyncJo= b))) @@ -1362,7 +1362,7 @@ qemuSnapshotCreateActiveExternal(virQEMUDriverPtr dri= ver, int compressed; g_autoptr(virCommand) compressor =3D NULL; virQEMUSaveDataPtr data =3D NULL; - g_autoptr(virHashTable) blockNamedNodeData =3D NULL; + g_autoptr(GHashTable) blockNamedNodeData =3D 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_selinu= x.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 =3D=3D 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 =3D NULL; void *val =3D NULL; @@ -266,7 +266,7 @@ virHashAtomicSteal(virHashAtomicPtr table, * -1 in case of error */ ssize_t -virHashSize(virHashTablePtr table) +virHashSize(GHashTable *table) { if (table =3D=3D 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 i= ter, 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, co= nst char *name, return 0; } -bool virHashEqual(virHashTablePtr table1, - virHashTablePtr table2, +bool virHashEqual(GHashTable *table1, + GHashTable *table2, virHashValueComparator compar) { struct virHashEqualData data =3D { 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, co= nst 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(virHashTablePt= r table, * of two keys. */ typedef int (*virHashValueComparator)(const void *value1, const void *valu= e2); -bool virHashEqual(virHashTablePtr table1, - virHashTablePtr table2, +bool virHashEqual(GHashTable *table1, + GHashTable *table2, virHashValueComparator compar); /* * Iterators */ -int virHashForEach(virHashTablePtr table, virHashIterator iter, void *opaq= ue); -int virHashForEachSafe(virHashTablePtr table, virHashIterator iter, void *= opaque); -int virHashForEachSorted(virHashTablePtr table, virHashIterator iter, void= *opaque); -ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, cons= t void *opaque); -void *virHashSearch(virHashTablePtr table, virHashSearcher iter, +int virHashForEach(GHashTable *table, virHashIterator iter, void *opaque); +int virHashForEachSafe(GHashTable *table, virHashIterator iter, void *opaq= ue); +int virHashForEachSorted(GHashTable *table, virHashIterator iter, void *op= aque); +ssize_t virHashRemoveSet(GHashTable *table, virHashSearcher iter, const vo= id *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 =3D opaque; - virHashTablePtr chains =3D NULL; - virHashTablePtr links =3D NULL; + GHashTable *chains =3D NULL; + GHashTable *links =3D NULL; const char *const *tmp; int ret =3D -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 =3D NULL; + GHashTable *cycle =3D NULL; bool beginSlash =3D false; bool beginDoubleSlash =3D false; char **components =3D NULL; @@ -5160,7 +5160,7 @@ virStorageFileGetMetadataRecurseReadHeader(virStorage= SourcePtr src, gid_t gid, char **buf, size_t *headerLen, - virHashTablePtr cycle) + GHashTable *cycle) { int ret =3D -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 =3D src->format; @@ -5309,7 +5309,7 @@ virStorageFileGetMetadata(virStorageSourcePtr src, uid_t uid, gid_t gid, bool report_broken) { - virHashTablePtr cycle =3D NULL; + GHashTable *cycle =3D NULL; virStorageType actualType =3D virStorageSourceGetActualType(src); int ret =3D -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/nwfilterxml2firewallt= est.c index 30f3dab97e..f3fbacce59 100644 --- a/tests/nwfilterxml2firewalltest.c +++ b/tests/nwfilterxml2firewalltest.c @@ -145,11 +145,11 @@ static const char *commonRules[] =3D { }; -static virHashTablePtr -virNWFilterCreateVarsFrom(virHashTablePtr vars1, - virHashTablePtr vars2) +static GHashTable * +virNWFilterCreateVarsFrom(GHashTable *vars1, + GHashTable *vars2) { - virHashTablePtr res =3D virHashNew(virNWFilterVarValueHashFree); + GHashTable *res =3D 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 =3D NULL; + GHashTable *tmpvars =3D NULL; int ret =3D -1; char *xml; @@ -266,7 +266,7 @@ virNWFilterIncludeDefToRuleInst(virNWFilterIncludeDefPt= r 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 =3D NULL; g_auto(virBuffer) buf =3D VIR_BUFFER_INITIALIZER; - virHashTablePtr vars =3D virHashNew(virNWFilterVarValueHashFree); + GHashTable *vars =3D virHashNew(virNWFilterVarValueHashFree); virNWFilterInst inst; int ret =3D -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 =3D 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 *o= paque) 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 =3D "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 =3D opaque; g_autoptr(virJSONValue) nodedatajson =3D NULL; - g_autoptr(virHashTable) nodedata =3D NULL; + g_autoptr(GHashTable) nodedata =3D NULL; g_autofree char *actual =3D NULL; g_autofree char *expectpath =3D NULL; g_auto(virBuffer) buf =3D VIR_BUFFER_INITIALIZER; @@ -729,7 +729,7 @@ testQemuBackupIncrementalBitmapCalculate(const void *op= aque) { const struct testQemuBackupIncrementalBitmapCalculateData *data =3D op= aque; g_autoptr(virJSONValue) nodedatajson =3D NULL; - g_autoptr(virHashTable) nodedata =3D NULL; + g_autoptr(GHashTable) nodedata =3D NULL; g_autoptr(virJSONValue) actions =3D virJSONValueNewArray(); g_autofree char *expectpath =3D NULL; g_autoptr(virStorageSource) target =3D NULL; @@ -784,7 +784,7 @@ testQemuCheckpointDelete(const void *opaque) g_autofree char *expectpath =3D NULL; g_autoptr(virJSONValue) actions =3D NULL; g_autoptr(virJSONValue) nodedatajson =3D NULL; - g_autoptr(virHashTable) nodedata =3D NULL; + g_autoptr(GHashTable) nodedata =3D NULL; g_autoptr(GSList) reopenimages =3D NULL; g_auto(virBuffer) buf =3D VIR_BUFFER_INITIALIZER; @@ -834,7 +834,7 @@ testQemuBlockBitmapValidate(const void *opaque) { const struct testQemuBlockBitmapValidateData *data =3D opaque; g_autoptr(virJSONValue) nodedatajson =3D NULL; - g_autoptr(virHashTable) nodedata =3D NULL; + g_autoptr(GHashTable) nodedata =3D NULL; bool actual; if (!(nodedatajson =3D virTestLoadFileJSON(bitmapDetectPrefix, data->n= ame, @@ -875,7 +875,7 @@ testQemuBlockBitmapBlockcopy(const void *opaque) g_autofree char *expectpath =3D NULL; g_autoptr(virJSONValue) actions =3D NULL; g_autoptr(virJSONValue) nodedatajson =3D NULL; - g_autoptr(virHashTable) nodedata =3D NULL; + g_autoptr(GHashTable) nodedata =3D NULL; g_autoptr(virStorageSource) fakemirror =3D virStorageSourceNew(); g_auto(virBuffer) buf =3D VIR_BUFFER_INITIALIZER; @@ -927,7 +927,7 @@ testQemuBlockBitmapBlockcommit(const void *opaque) g_autofree char *expectpath =3D NULL; g_autoptr(virJSONValue) actionsMerge =3D NULL; g_autoptr(virJSONValue) nodedatajson =3D NULL; - g_autoptr(virHashTable) nodedata =3D NULL; + g_autoptr(GHashTable) nodedata =3D NULL; g_auto(virBuffer) buf =3D VIR_BUFFER_INITIALIZER; bool active =3D data->top =3D=3D data->chain; @@ -975,7 +975,7 @@ mymain(void) struct testQemuBlockBitmapBlockcommitData blockbitmapblockcommitdata; char *capslatest_x86_64 =3D NULL; g_autoptr(virQEMUCaps) caps_x86_64 =3D NULL; - g_autoptr(virHashTable) qmp_schema_x86_64 =3D NULL; + g_autoptr(GHashTable) qmp_schema_x86_64 =3D NULL; virJSONValuePtr qmp_schemaroot_x86_64_blockdev_add =3D NULL; g_autoptr(virStorageSource) bitmapSourceChain =3D 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 =3D NULL; virCapsPtr caps =3D 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 =3D NULL; + g_autoptr(GHashTable) qmpschema =3D NULL; int ret =3D 0; struct qemuHotplugTestData data =3D {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 =3D NULL; + g_autoptr(GHashTable) qmpschema =3D NULL; virQEMUDriver driver; int ret =3D 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 =3D @@ -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(virDomainXMLOptionP= tr xmlopt, static int qemuMonitorJSONTestAttachChardev(virDomainXMLOptionPtr xmlopt, - virHashTablePtr schema) + GHashTable *schema) { virDomainChrSourceDef chr; int ret =3D 0; @@ -1642,7 +1642,8 @@ testQemuMonitorJSONqemuMonitorJSONGetBlockInfo(const = void *opaque) const testGenericData *data =3D opaque; virDomainXMLOptionPtr xmlopt =3D data->xmlopt; int ret =3D -1; - virHashTablePtr blockDevices =3D NULL, expectedBlockDevices =3D NULL; + GHashTable *blockDevices =3D NULL; + GHashTable *expectedBlockDevices =3D NULL; struct qemuDomainDiskInfo *info; g_autoptr(qemuMonitorTest) test =3D NULL; @@ -1716,7 +1717,7 @@ testQemuMonitorJSONqemuMonitorJSONGetAllBlockStatsInf= o(const void *opaque) { const testGenericData *data =3D opaque; virDomainXMLOptionPtr xmlopt =3D data->xmlopt; - virHashTablePtr blockstats =3D NULL; + GHashTable *blockstats =3D NULL; qemuBlockStatsPtr stats; int ret =3D -1; g_autoptr(qemuMonitorTest) test =3D NULL; @@ -2008,7 +2009,8 @@ testQemuMonitorJSONqemuMonitorJSONGetChardevInfo(cons= t void *opaque) const testGenericData *data =3D opaque; virDomainXMLOptionPtr xmlopt =3D data->xmlopt; int ret =3D -1; - virHashTablePtr info =3D NULL, expectedInfo =3D NULL; + GHashTable *info =3D NULL; + GHashTable *expectedInfo =3D NULL; qemuMonitorChardevInfo info0 =3D { NULL, VIR_DOMAIN_CHR_DEVICE_STATE_D= EFAULT }; qemuMonitorChardevInfo info1 =3D { (char *) "/dev/pts/21", VIR_DOMAIN_= CHR_DEVICE_STATE_CONNECTED }; qemuMonitorChardevInfo info2 =3D { (char *) "/dev/pts/20", VIR_DOMAIN_= CHR_DEVICE_STATE_DEFAULT }; @@ -2404,7 +2406,7 @@ testQemuMonitorJSONqemuMonitorJSONGetDumpGuestMemoryC= apability(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 =3D NULL; virJSONValuePtr namedNodesJson =3D NULL; virJSONValuePtr blockstatsJson =3D NULL; - virHashTablePtr nodedata =3D NULL; + GHashTable *nodedata =3D NULL; g_auto(virBuffer) buf =3D VIR_BUFFER_INITIALIZER; int ret =3D -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 =3D (virHashTablePtr) opaque; + GHashTable *schema =3D (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 =3D NULL; virDomainChrSourceDef src; @@ -1341,7 +1341,7 @@ qemuMonitorTestPtr qemuMonitorTestNewFromFileFull(const char *fileName, virQEMUDriverPtr driver, virDomainObjPtr vm, - virHashTablePtr qmpschema) + GHashTable *qmpschema) { qemuMonitorTestPtr ret =3D NULL; g_autofree char *jsonstr =3D 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(virDomainXMLOptionP= tr 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 qmpschem= a); + 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 =3D 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 =3D NULL; +GHashTable *xattr_paths =3D 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 =3D NULL; +GHashTable *chown_paths =3D 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 =3D NULL; size_t nargs =3D 0; size_t i; - g_autoptr(virHashTable) schema =3D NULL; + g_autoptr(GHashTable) schema =3D NULL; g_autoptr(virCommand) cmd =3D NULL; unsigned int parseFlags =3D info->parseFlags; @@ -756,7 +756,7 @@ mymain(void) { int ret =3D 0; g_autofree char *fakerootdir =3D NULL; - g_autoptr(virHashTable) capslatest =3D NULL; + g_autoptr(GHashTable) capslatest =3D NULL; fakerootdir =3D 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 =3D 0; g_autofree char *fakerootdir =3D NULL; g_autoptr(virQEMUDriverConfig) cfg =3D NULL; - g_autoptr(virHashTable) capslatest =3D NULL; + g_autoptr(GHashTable) capslatest =3D NULL; g_autoptr(virConnect) conn =3D NULL; capslatest =3D 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[] =3D { @@ -573,7 +573,7 @@ testQemuGetLatestCaps(void) "s390x", "x86_64", }; - virHashTablePtr capslatest; + GHashTable *capslatest; size_t i; if (!(capslatest =3D 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 schemaen= try, 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 =3D 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 =3D 0; @@ -85,7 +85,7 @@ struct testInfo { static int testHashGrow(const void *data G_GNUC_UNUSED) { - virHashTablePtr hash; + GHashTable *hash; int ret =3D -1; if (!(hash =3D testHashInit())) @@ -106,7 +106,7 @@ static int testHashUpdate(const void *data G_GNUC_UNUSED) { int count =3D G_N_ELEMENTS(uuids) + G_N_ELEMENTS(uuids_new); - virHashTablePtr hash; + GHashTable *hash; size_t i; int ret =3D -1; @@ -144,7 +144,7 @@ static int testHashRemove(const void *data G_GNUC_UNUSED) { int count =3D G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset); - virHashTablePtr hash; + GHashTable *hash; size_t i; int ret =3D -1; @@ -178,7 +178,7 @@ testHashRemoveForEachSome(void *payload G_GNUC_UNUSED, const char *name, void *data) { - virHashTablePtr hash =3D data; + GHashTable *hash =3D data; size_t i; for (i =3D 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 =3D data; + GHashTable *hash =3D data; virHashRemoveEntry(hash, name); return 0; @@ -212,7 +212,7 @@ static int testHashRemoveForEach(const void *data) { const struct testInfo *info =3D data; - virHashTablePtr hash; + GHashTable *hash; int ret =3D -1; if (!(hash =3D testHashInit())) @@ -238,7 +238,7 @@ static int testHashSteal(const void *data G_GNUC_UNUSED) { int count =3D G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset); - virHashTablePtr hash; + GHashTable *hash; size_t i; int ret =3D -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 =3D 0; int rcount; int ret =3D -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 =3D -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 =3D NULL; int ret =3D -1; char keya[] =3D "a"; @@ -419,7 +419,8 @@ testHashEqualCompValue(const void *value1, const void *= value2) static int testHashEqual(const void *data G_GNUC_UNUSED) { - virHashTablePtr hash1, hash2 =3D NULL; + GHashTable *hash1; + GHashTable *hash2 =3D NULL; int ret =3D -1; char keya[] =3D "a"; char keyb[] =3D "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 =3D NULL; + g_autoptr(GHashTable) hash =3D NULL; if (!(hash =3D virHashNew(NULL))) return -1; --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) client-ip=216.205.24.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727568; cv=none; d=zohomail.com; s=zohoarc; b=MCtbaVe/0687DZ/wLMFEM0thaaeISBEw+nXwA/RGD0ed8vOdxMvVh3U1ZI8EYRWYPzwdoz/mulgDZ4Yd8iRxhgr/Xi0TijFsvCQgRCs0bFTLUqfZFU4GRaIgrypzQJjben80WOED8o0cCv6TeYJbtjOzitU3jkp0X90y6vHKJ/4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727568; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=8UQLll7JkVN8p8F9dolJSsnEH33ZmsICDs51RvXtEkE=; b=Q4rC9ry18+ckvpFCWx94/QxLoRPbky/O9DP8OEnu3GZ8mWNJ9zmSQ0fq7eTL9v1jnFixCd7pbcSHyvDnAXIjvmPa7fOSdvmFss7MPOUxvxRVJnHJZ+l3JoA9vpUYepYcPWDF81JQ7teZcCBGZR2hb6lZVYSUVjulADReSDra3x8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by mx.zohomail.com with SMTPS id 160372756844856.541616781760695; Mon, 26 Oct 2020 08:52:48 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-487-0XV2RBHtPQSSFn98t2jA8g-1; Mon, 26 Oct 2020 11:52:45 -0400 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 9C46987507F; Mon, 26 Oct 2020 15:52:37 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 70CEC1002393; Mon, 26 Oct 2020 15:52:37 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 3F18592F2F; Mon, 26 Oct 2020 15:52:37 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFkDRW018618 for ; Mon, 26 Oct 2020 11:46:13 -0400 Received: by smtp.corp.redhat.com (Postfix) id 5110819D6C; Mon, 26 Oct 2020 15:46:13 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id 97E851992F for ; Mon, 26 Oct 2020 15:46:12 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727567; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=8UQLll7JkVN8p8F9dolJSsnEH33ZmsICDs51RvXtEkE=; b=LSLUtqLD8aTFmy3RB+hXnxdXRzSCFi0HbRCGnNxBmd5nVaMtSgnln92epcy2Z0hbcdYEZO fpeoa43Pk5gUeMOjGC1bFwU40EXRLBcgbeoKB46utN9QuIO6sub2L4xzkcMSWgWsvsHh/o 1FI8juVdGsjkBp8k2osCLASylkyFZ3A= X-MC-Unique: 0XV2RBHtPQSSFn98t2jA8g-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 12/13] util: hash: Add deprecation notices for functions which have g_hash_table replacements Date: Mon, 26 Oct 2020 16:45:52 +0100 Message-Id: <06b8f80328c09b5cdf6714444d4dcef8b20ae9c8.1603726723.git.pkrempa@redhat.com> In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" For functions which have reasonable replacement, let's encourage usage of g_hash_table_ alternatives. Signed-off-by: Peter Krempa --- src/util/virhash.c | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/src/util/virhash.c b/src/util/virhash.c index d943ca3b99..49e6e93f77 100644 --- a/src/util/virhash.c +++ b/src/util/virhash.c @@ -52,7 +52,7 @@ VIR_ONCE_GLOBAL_INIT(virHashAtomic); * virHashNew: * @dataFree: callback to free data * - * Create a new GHashTable *. + * Create a new GHashTable * for use with string-based keys. * * Returns the newly created object. */ @@ -97,6 +97,8 @@ virHashAtomicDispose(void *obj) * * Free the hash @table and its contents. The userdata is * deallocated with function provided at creation time. + * + * Deprecated: consider using g_hash_table_unref instead */ void virHashFree(GHashTable *table) @@ -117,6 +119,10 @@ virHashFree(GHashTable *table) * Add the @userdata to the hash @table. This can later be retrieved * by using @name. Duplicate entries generate errors. * + * Deprecated: Consider using g_hash_table_insert insert. Note that + * g_hash_table_instead doesn't fail if entry exists. Also note that + * g_hash_table_insert doesn't copy the key. + * * Returns 0 the addition succeeded and -1 in case of error. */ int @@ -146,6 +152,9 @@ virHashAddEntry(GHashTable *table, const char *name, vo= id *userdata) * by using @name. Existing entry for this tuple * will be removed and freed with @f if found. * + * Deprecated: consider using g_hash_table_insert insert. Note that + * g_hash_table_insert doesn't copy the key. + * * Returns 0 the addition succeeded and -1 in case of error. */ int @@ -182,6 +191,8 @@ virHashAtomicUpdate(virHashAtomicPtr table, * * Find the userdata specified by @name * + * Deprecated: consider using g_hash_table_lookup instead + * * Returns a pointer to the userdata */ void * @@ -202,6 +213,8 @@ virHashLookup(GHashTable *table, * * Find whether entry specified by @name exists. * + * Deprecated: consider using g_hash_table_contains instead + * * Returns true if the entry exists and false otherwise */ bool @@ -223,6 +236,9 @@ virHashHasEntry(GHashTable *table, * Find the userdata specified by @name * and remove it from the hash without freeing it. * + * Deprecated: consider using g_hash_table_steal_extended once we upgrade = to + * glib 2.58 + * * Returns a pointer to the userdata */ void *virHashSteal(GHashTable *table, const char *name) @@ -262,6 +278,8 @@ virHashAtomicSteal(virHashAtomicPtr table, * * Query the number of elements installed in the hash @table. * + * Deprecated: consider using g_hash_table_size instead + * * Returns the number of elements in the hash table or * -1 in case of error */ @@ -284,6 +302,8 @@ virHashSize(GHashTable *table) * it from the hash @table. Existing userdata for this tuple will be remov= ed * and freed with @f. * + * Deprecated: consider using g_hash_table_remove + * * Returns 0 if the removal succeeded and -1 in case of error or not found. */ int @@ -325,6 +345,9 @@ virHashRemoveEntry(GHashTable *table, * If @iter fails and returns a negative value, the evaluation is stopped = and -1 * is returned. * + * Deprecated: Consider using g_hash_table_foreach as replacement for + * virHashForEach, rewrite your code if it would require virHashForEachSaf= e. + * * Returns 0 on success or -1 on failure. */ int @@ -417,6 +440,8 @@ virHashSearcherWrapFunc(gpointer key, * will be removed from the hash table & its payload passed to the * data freer callback registered at creation. * + * Deprecated: consider using g_hash_table_foreach_remove instead + * * Returns number of items removed on success, -1 on failure */ ssize_t @@ -438,6 +463,8 @@ virHashRemoveSet(GHashTable *table, * * Free the hash @table's contents. The userdata is * deallocated with the function provided at creation time. + * + * Deprecated: consider using g_hash_table_remove_all instead */ void virHashRemoveAll(GHashTable *table) @@ -460,6 +487,8 @@ virHashRemoveAll(GHashTable *table) * returns non-zero will be returned by this function. * The elements are processed in a undefined order. Caller is * responsible for freeing the @name. + * + * Deprecated: consider using g_hash_table_find instead */ void *virHashSearch(GHashTable *table, virHashSearcher iter, --=20 2.26.2 From nobody Sat Apr 27 10:02:27 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) client-ip=216.205.24.124; envelope-from=libvir-list-bounces@redhat.com; helo=us-smtp-delivery-124.mimecast.com; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com ARC-Seal: i=1; a=rsa-sha256; t=1603727571; cv=none; d=zohomail.com; s=zohoarc; b=HeUZcBIzBzodcThjz99disYDA63rbVvtr4y/tHMKphtO70pa+pSv9QFpVeAGXS0jvj0VLy9N0faREnKraCo8TS8fOT9xSCR4dlTJ3iD8VKyciViBMcmvxh2yMrYGM3g4ThKf8NjuftIhlqA6YSSVzGnCfWIRZBST/6fWUPOx4jM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1603727571; h=Content-Type:Content-Transfer-Encoding:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=raagTxXjdsAry8yt88nFrejvzOUfitzDsCEMw/xF6rY=; b=SkYkt1czumHfG5CzKjSkkm/ToilOONJlhVWgo5QHDssztifXuHFrwk99yMGsGjA2a398KWKYYimBC7R7sHbDcwTilSeIMZNuvv/zDCkzpCszOq8T09Y35dlX07zmHJ9pOPUXyyjqYcnT/is/c2Z4yVqjdMCu4y1IKIoET0uHQLM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of redhat.com designates 216.205.24.124 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass header.from= (p=none dis=none) header.from= Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by mx.zohomail.com with SMTPS id 1603727571266435.56510589815014; Mon, 26 Oct 2020 08:52:51 -0700 (PDT) Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-47-1sGaBtc_OF-MRXG6tT-fFA-1; Mon, 26 Oct 2020 11:52:46 -0400 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 650011084D73; Mon, 26 Oct 2020 15:52:40 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 3FDD919746; Mon, 26 Oct 2020 15:52:40 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 05E73181A261; Mon, 26 Oct 2020 15:52:40 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09QFkE0W018631 for ; Mon, 26 Oct 2020 11:46:14 -0400 Received: by smtp.corp.redhat.com (Postfix) id 5F33019D7D; Mon, 26 Oct 2020 15:46:14 +0000 (UTC) Received: from speedmetal.redhat.com (unknown [10.40.208.55]) by smtp.corp.redhat.com (Postfix) with ESMTP id BC7F81972B for ; Mon, 26 Oct 2020 15:46:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603727570; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=raagTxXjdsAry8yt88nFrejvzOUfitzDsCEMw/xF6rY=; b=NH4zubBsnR817rNoOB17qddyP8FTNyCVyC4ifG94RE99n40c1WKKNOSd91zAolWYBSitrW gmUgF5nE/m9Ff4XRvZxnzPyEEh2lsP79zmo4GWRF3WXnGbfZ4YLmoVPzBs6SW28TsDITZ1 LmBhW1PzOhOKiXurodfOVV+4WQXH1FU= X-MC-Unique: 1sGaBtc_OF-MRXG6tT-fFA-1 From: Peter Krempa To: libvir-list@redhat.com Subject: [PATCH 13/13] tests: Remove 'virhashtest' Date: Mon, 26 Oct 2020 16:45:53 +0100 Message-Id: <9a59f44b5116d8dae7707764a8f4d62c42b6aa62.1603726723.git.pkrempa@redhat.com> In-Reply-To: References: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=libvir-list-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable X-ZohoMail-DKIM: pass (identity @redhat.com) Content-Type: text/plain; charset="utf-8" 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 --- 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 +=3D [ { '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 - * . - */ - -#pragma once - -const char *uuids[] =3D { -/* [ 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[] =3D { - "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[] =3D { - "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 - -#include - -#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 =3D 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 =3D G_N_ELEMENTS(uuids) - 1; i >=3D 0; i--) { - if (virHashAddEntry(hash, uuids[i], (void *) uuids[i]) < 0) { - virHashFree(hash); - return NULL; - } - } - - for (i =3D 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 =3D data; - *count +=3D 1; - return 0; -} - -static int -testHashCheckCount(GHashTable *hash, size_t count) -{ - size_t iter_count =3D 0; - - if (virHashSize(hash) !=3D count) { - VIR_TEST_VERBOSE("\nhash contains %zd instead of %zu elements", - virHashSize(hash), count); - return -1; - } - - virHashForEach(hash, testHashCheckForEachCount, &iter_count); - if (count !=3D 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 =3D -1; - - if (!(hash =3D testHashInit())) - return -1; - - if (testHashCheckCount(hash, G_N_ELEMENTS(uuids)) < 0) - goto cleanup; - - ret =3D 0; - - cleanup: - virHashFree(hash); - return ret; -} - - -static int -testHashUpdate(const void *data G_GNUC_UNUSED) -{ - int count =3D G_N_ELEMENTS(uuids) + G_N_ELEMENTS(uuids_new); - GHashTable *hash; - size_t i; - int ret =3D -1; - - if (!(hash =3D testHashInit())) - return -1; - - for (i =3D 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 =3D 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 =3D 0; - - cleanup: - virHashFree(hash); - return ret; -} - - -static int -testHashRemove(const void *data G_GNUC_UNUSED) -{ - int count =3D G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset); - GHashTable *hash; - size_t i; - int ret =3D -1; - - if (!(hash =3D testHashInit())) - return -1; - - for (i =3D 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 =3D 0; - - cleanup: - virHashFree(hash); - return ret; -} - - -const int testHashCountRemoveForEachSome =3D - G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset); - -static int -testHashRemoveForEachSome(void *payload G_GNUC_UNUSED, - const char *name, - void *data) -{ - GHashTable *hash =3D data; - size_t i; - - for (i =3D 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 =3D 0; - -static int -testHashRemoveForEachAll(void *payload G_GNUC_UNUSED, - const char *name, - void *data) -{ - GHashTable *hash =3D data; - - virHashRemoveEntry(hash, name); - return 0; -} - - -static int -testHashRemoveForEach(const void *data) -{ - const struct testInfo *info =3D data; - GHashTable *hash; - int ret =3D -1; - - if (!(hash =3D 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 =3D 0; - - cleanup: - virHashFree(hash); - return ret; -} - - -static int -testHashSteal(const void *data G_GNUC_UNUSED) -{ - int count =3D G_N_ELEMENTS(uuids) - G_N_ELEMENTS(uuids_subset); - GHashTable *hash; - size_t i; - int ret =3D -1; - - if (!(hash =3D testHashInit())) - return -1; - - for (i =3D 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 =3D 0; - - cleanup: - virHashFree(hash); - return ret; -} - - -static int -testHashRemoveSetIter(const void *payload G_GNUC_UNUSED, - const char *name, - const void *data) -{ - int *count =3D (int *) data; - bool rem =3D false; - size_t i; - - for (i =3D 0; i < G_N_ELEMENTS(uuids_subset); i++) { - if (STREQ(uuids_subset[i], name)) { - rem =3D 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 =3D 0; - int rcount; - int ret =3D -1; - - if (!(hash =3D testHashInit())) - return -1; - - /* seed the generator so that rand() provides reproducible sequence */ - srand(9000); - - rcount =3D virHashRemoveSet(hash, testHashRemoveSetIter, &count); - - if (count !=3D rcount) { - VIR_TEST_VERBOSE("\nvirHashRemoveSet didn't remove expected number= of" - " entries, %d !=3D %d", - rcount, count); - goto cleanup; - } - - if (testHashCheckCount(hash, G_N_ELEMENTS(uuids) - count) < 0) - goto cleanup; - - ret =3D 0; - - cleanup: - virHashFree(hash); - return ret; -} - - -const int testSearchIndex =3D 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 =3D -1; - - if (!(hash =3D testHashInit())) - return -1; - - entry =3D 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 =3D 0; - - cleanup: - virHashFree(hash); - return ret; -} - - -static int -testHashGetItems(const void *data G_GNUC_UNUSED) -{ - GHashTable *hash; - virHashKeyValuePairPtr array =3D NULL; - int ret =3D -1; - char keya[] =3D "a"; - char keyb[] =3D "b"; - char keyc[] =3D "c"; - char value1[] =3D "1"; - char value2[] =3D "2"; - char value3[] =3D "3"; - - if (!(hash =3D 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 =3D 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 =3D 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 =3D 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 =3D NULL; - int ret =3D -1; - char keya[] =3D "a"; - char keyb[] =3D "b"; - char keyc[] =3D "c"; - char value1_l[] =3D "m"; - char value2_l[] =3D "n"; - char value3_l[] =3D "o"; - char value1_u[] =3D "M"; - char value2_u[] =3D "N"; - char value3_u[] =3D "O"; - char value4_u[] =3D "P"; - - if (!(hash1 =3D virHashNew(NULL)) || - !(hash2 =3D 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 elem= ents"); - 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 =3D 0; - - cleanup: - virHashFree(hash1); - virHashFree(hash2); - return ret; -} - - -static int -testHashDuplicate(const void *data G_GNUC_UNUSED) -{ - g_autoptr(GHashTable) hash =3D NULL; - - if (!(hash =3D 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) >=3D 0) { - VIR_TEST_VERBOSE("\nadding of key 'a' should have failed"); - return -1; - } - - return 0; -} - - -static int -mymain(void) -{ - int ret =3D 0; - -#define DO_TEST_FULL(name, cmd, data, count) \ - do { \ - struct testInfo info =3D { data, count }; \ - if (virTestRun(name, testHash ## cmd, &info) < 0) \ - ret =3D -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 =3D=3D 0) ? EXIT_SUCCESS : EXIT_FAILURE; -} - -VIR_TEST_MAIN(mymain) --=20 2.26.2