util: consolidate on one free callback for hash data

This previous commit introduced a simpler free callback for
hash data with only 1 arg, the value to free:

  commit 49288fac965f0ee23db45d83ae4ef3a9a71dafd0
  Author: Peter Krempa <pkrempa@redhat.com>
  Date:   Wed Oct 9 15:26:37 2019 +0200

    util: hash: Add possibility to use simpler data free function in virHash

It missed two functions in the hash table code which need
to call the alternate data free function, virHashRemoveEntry
and virHashRemoveSet.

After the previous patch though, there is no code that
makes functional use of the 2nd key arg in the data
free function. There is merely one log message that can
be dropped.

We can thus purge the current virHashDataFree callback
entirely, and rename virHashDataFreeSimple to replace
it.

Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>

diff --git a/src/conf/domain_addr.c b/src/conf/domain_addr.c
index 74d561cd12f9b5cba99556afceac7a6728310fee..165bd70f2b015869c94608093d2cdbbd4ae2b5cb 100644 (file)
--- a/src/conf/domain_addr.c
+++ b/src/conf/domain_addr.c
@@ -1037,14 +1037,14 @@ virDomainPCIAddressSetExtensionAlloc(virDomainPCIAddressSetPtr addrs,
         if (VIR_ALLOC(addrs->zpciIds) < 0)
             return -1;
 
-        if (!(addrs->zpciIds->uids = virHashCreateFull(10, NULL, NULL,
+        if (!(addrs->zpciIds->uids = virHashCreateFull(10, NULL,
                                                        virZPCIAddrKeyCode,
                                                        virZPCIAddrKeyEqual,
                                                        virZPCIAddrKeyCopy,
                                                        virZPCIAddrKeyFree)))
             goto error;
 
-        if (!(addrs->zpciIds->fids = virHashCreateFull(10, NULL, NULL,
+        if (!(addrs->zpciIds->fids = virHashCreateFull(10, NULL,
                                                        virZPCIAddrKeyCode,
                                                        virZPCIAddrKeyEqual,
                                                        virZPCIAddrKeyCopy,

diff --git a/src/conf/nwfilter_params.c b/src/conf/nwfilter_params.c
index 7608d4960e90c9f05d26ce2f3437293bf64b4a95..b1a2c50f270ee161c4103570b87594bffc808779 100644 (file)
--- a/src/conf/nwfilter_params.c
+++ b/src/conf/nwfilter_params.c
@@ -619,7 +619,7 @@ virNWFilterVarCombIterGetVarValue(virNWFilterVarCombIterPtr ci,
 }
 
 static void
-hashDataFree(void *payload, const void *name G_GNUC_UNUSED)
+hashDataFree(void *payload)
 {
     virNWFilterVarValueFree(payload);
 }

diff --git a/src/conf/virchrdev.c b/src/conf/virchrdev.c
index d5c0fdbe99a020a772cb32210328ddabe6e95482..d4ca3188c5038305d5516d4f8c05da4fff8b505d 100644 (file)
--- a/src/conf/virchrdev.c
+++ b/src/conf/virchrdev.c
@@ -212,7 +212,7 @@ typedef struct {
  *
  * @data Opaque data, struct holding information about the device
  */
-static void virChrdevHashEntryFree(void *data, const void *key G_GNUC_UNUSED)
+static void virChrdevHashEntryFree(void *data)
 {
     virChrdevHashEntry *ent = data;
 
@@ -455,6 +455,6 @@ int virChrdevOpen(virChrdevsPtr devs,
         VIR_FREE(cbdata->path);
     VIR_FREE(cbdata);
     virMutexUnlock(&devs->lock);
-    virChrdevHashEntryFree(ent, NULL);
+    virChrdevHashEntryFree(ent);
     return -1;
 }

diff --git a/src/conf/virdomainmomentobjlist.c b/src/conf/virdomainmomentobjlist.c
index ef702eb6aa4a3f36088a1c86c9ba5e0c45a1a515..18dbd434fb2345f0adb8376b3294ee2f7029a6f9 100644 (file)
--- a/src/conf/virdomainmomentobjlist.c
+++ b/src/conf/virdomainmomentobjlist.c
@@ -262,8 +262,7 @@ virDomainMomentAssignDef(virDomainMomentObjListPtr moments,
 
 
 static void
-virDomainMomentObjListDataFree(void *payload,
-                               const void *name G_GNUC_UNUSED)
+virDomainMomentObjListDataFree(void *payload)
 {
     virDomainMomentObjPtr obj = payload;
 

diff --git a/src/conf/virnetworkobj.c b/src/conf/virnetworkobj.c
index a0daaefb74b2cc17af5dabcdec79b06aaa25147d..5daf4a8cb1b44e4fb3aa285f47b31052b5e51aa1 100644 (file)
--- a/src/conf/virnetworkobj.c
+++ b/src/conf/virnetworkobj.c
@@ -94,7 +94,7 @@ virNetworkObjLoadAllPorts(virNetworkObjPtr net,
 
 
 static void
-virNetworkObjPortFree(void *val, const void *key G_GNUC_UNUSED)
+virNetworkObjPortFree(void *val)
 {
     virNetworkPortDefFree(val);
 }

diff --git a/src/libxl/libxl_logger.c b/src/libxl/libxl_logger.c
index a829142b2be35cc91bf4db9b78cd88e724e2d57e..1581a3070c3b0d0cbfa5ec5b42b23e42e827270f 100644 (file)
--- a/src/libxl/libxl_logger.c
+++ b/src/libxl/libxl_logger.c
@@ -47,7 +47,7 @@ struct xentoollog_logger_libvirt {
 };
 
 static void
-libxlLoggerFileFree(void *payload, const void *key G_GNUC_UNUSED)
+libxlLoggerFileFree(void *payload)
 {
     FILE *file = payload;
     VIR_FORCE_FCLOSE(file);

diff --git a/src/locking/lock_daemon.c b/src/locking/lock_daemon.c
index 2fa32387944e3d5731b5052c868d07775706d4ae..0d12a97231cea33324defc72d746ac2928e91d32 100644 (file)
--- a/src/locking/lock_daemon.c
+++ b/src/locking/lock_daemon.c
@@ -139,8 +139,7 @@ virLockDaemonUnlock(virLockDaemonPtr lockd)
     virMutexUnlock(&lockd->lock);
 }
 
-static void virLockDaemonLockSpaceDataFree(void *data,
-                                           const void *key G_GNUC_UNUSED)
+static void virLockDaemonLockSpaceDataFree(void *data)
 {
     virLockSpaceFree(data);
 }

diff --git a/src/nwfilter/nwfilter_dhcpsnoop.c b/src/nwfilter/nwfilter_dhcpsnoop.c
index 4e77ca0d2d63be0071d72b7f93e8cae0534d03c1..9514dfd75c6149cb06cece68105f07fcbaa8175c 100644 (file)
--- a/src/nwfilter/nwfilter_dhcpsnoop.c
+++ b/src/nwfilter/nwfilter_dhcpsnoop.c
@@ -660,7 +660,7 @@ virNWFilterSnoopReqUnlock(virNWFilterSnoopReqPtr req)
  * virNWFilterSnoopReqRelease - hash table free function to kill a request
  */
 static void
-virNWFilterSnoopReqRelease(void *req0, const void *name G_GNUC_UNUSED)
+virNWFilterSnoopReqRelease(void *req0)
 {
     virNWFilterSnoopReqPtr req = req0;
 
@@ -721,7 +721,7 @@ virNWFilterSnoopReqPut(virNWFilterSnoopReqPtr req)
          * - if we still have a valid lease, keep the req for restarts
          */
         if (virHashLookup(virNWFilterSnoopState.snoopReqs, req->ifkey) != req) {
-            virNWFilterSnoopReqRelease(req, NULL);
+            virNWFilterSnoopReqRelease(req);
         } else if (!req->start || req->start->timeout < time(0)) {
             ignore_value(virHashRemoveEntry(virNWFilterSnoopState.snoopReqs,
                                             req->ifkey));

diff --git a/src/nwfilter/nwfilter_learnipaddr.c b/src/nwfilter/nwfilter_learnipaddr.c
index 08ef02be7cf37b7f8d6ad2f243c0131c6d881079..9b4fab7ffbb25ad59f380163e8637b4e86841691 100644 (file)
--- a/src/nwfilter/nwfilter_learnipaddr.c
+++ b/src/nwfilter/nwfilter_learnipaddr.c
@@ -307,7 +307,7 @@ virNWFilterHasLearnReq(int ifindex)
 
 
 static void
-freeLearnReqEntry(void *payload, const void *name G_GNUC_UNUSED)
+freeLearnReqEntry(void *payload)
 {
     virNWFilterIPAddrLearnReqFree(payload);
 }

diff --git a/src/qemu/qemu_block.c b/src/qemu/qemu_block.c
index 1140a33114baa5d7a9b247bb74ddd19339cd5e84..ada2c5294776632ad880c0c4637c67afc1207aaa 100644 (file)
--- a/src/qemu/qemu_block.c
+++ b/src/qemu/qemu_block.c
@@ -93,8 +93,7 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuBlockNodeNameBackingChainData,
 
 
 static void
-qemuBlockNodeNameBackingChainDataHashEntryFree(void *opaque,
-                                               const void *name G_GNUC_UNUSED)
+qemuBlockNodeNameBackingChainDataHashEntryFree(void *opaque)
 {
     qemuBlockNodeNameBackingChainDataFree(opaque);
 }

diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c
index 21025d078553d268831c3cfae7af4c038443311b..30637b21ac632cc289afbbc320973c91f0ec224c 100644 (file)
--- a/src/qemu/qemu_conf.c
+++ b/src/qemu/qemu_conf.c
@@ -1516,7 +1516,7 @@ qemuSharedDeviceEntryDomainExists(qemuSharedDeviceEntryPtr entry,
 }
 
 void
-qemuSharedDeviceEntryFree(void *payload, const void *name G_GNUC_UNUSED)
+qemuSharedDeviceEntryFree(void *payload)
 {
     qemuSharedDeviceEntryPtr entry = payload;
     size_t i;
@@ -1566,7 +1566,7 @@ qemuSharedDeviceEntryInsert(virQEMUDriverPtr driver,
     return 0;
 
  error:
-    qemuSharedDeviceEntryFree(entry, NULL);
+    qemuSharedDeviceEntryFree(entry);
     return -1;
 }
 

diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h
index 7334a440f8473457c5426e390a1f12b71bbd39fc..95b33a1093b4ce98c0fb9dd4ae28ba623ca7cbcc 100644 (file)
--- a/src/qemu/qemu_conf.h
+++ b/src/qemu/qemu_conf.h
@@ -338,7 +338,7 @@ bool qemuSharedDeviceEntryDomainExists(qemuSharedDeviceEntryPtr entry,
 char *qemuGetSharedDeviceKey(const char *disk_path)
     ATTRIBUTE_NONNULL(1);
 
-void qemuSharedDeviceEntryFree(void *payload, const void *name);
+void qemuSharedDeviceEntryFree(void *payload);
 
 int qemuAddSharedDisk(virQEMUDriverPtr driver,
                       virDomainDiskDefPtr disk,

diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index c4d5f085416f6b8abdee777392174d351ddf6d2c..168e7464a9655a8b116161016d46e7faa7ea6d41 100644 (file)
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -2063,8 +2063,7 @@ qemuDomainSetPrivatePaths(virQEMUDriverPtr driver,
 
 
 static void
-dbusVMStateHashFree(void *opaque,
-                    const void *name G_GNUC_UNUSED)
+dbusVMStateHashFree(void *opaque)
 {
     qemuDBusVMStateFree(opaque);
 }

diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 6b667728aae7eca2179977c39ff338d786512310..c38bf342d7f08638932b602e976e8bde227fc453 100644 (file)
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -5432,8 +5432,7 @@ qemuMigrationJobFinish(virQEMUDriverPtr driver, virDomainObjPtr vm)
 
 
 static void
-qemuMigrationDstErrorFree(void *data,
-                       const void *name G_GNUC_UNUSED)
+qemuMigrationDstErrorFree(void *data)
 {
     virErrorPtr err = data;
     virFreeError(err);

diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 231387a3f3409dc34546da6cb6bf46b3691f979b..a48305b046c643310fa2de12949d77979b789ed0 100644 (file)
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -2109,7 +2109,7 @@ qemuMonitorBlockIOStatusToError(const char *status)
 
 
 static void
-qemuDomainDiskInfoFree(void *value, const void *name G_GNUC_UNUSED)
+qemuDomainDiskInfoFree(void *value)
 {
     struct qemuDomainDiskInfo *info = value;
 
@@ -2774,8 +2774,7 @@ qemuMonitorQueryRxFilter(qemuMonitorPtr mon, const char *alias,
 
 
 void
-qemuMonitorChardevInfoFree(void *data,
-                           const void *name G_GNUC_UNUSED)
+qemuMonitorChardevInfoFree(void *data)
 {
     qemuMonitorChardevInfoPtr info = data;
 

diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h
index d30d075b430ed7db14cf6a479d9481c0e2741bc0..a17d7200c2533ee66dcfc57b92d3250536782b3e 100644 (file)
--- a/src/qemu/qemu_monitor.h
+++ b/src/qemu/qemu_monitor.h
@@ -882,7 +882,7 @@ struct _qemuMonitorChardevInfo {
     char *ptyPath;
     virDomainChrDeviceState state;
 };
-void qemuMonitorChardevInfoFree(void *data, const void *name);
+void qemuMonitorChardevInfoFree(void *data);
 int qemuMonitorGetChardevInfo(qemuMonitorPtr mon,
                               virHashTablePtr *retinfo);
 

diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index c729450a5282271b38e40207a21220cc270eef0d..4d38030179f3ca2c58a9f5adf2778e213faaa545 100644 (file)
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -2925,7 +2925,7 @@ qemuMonitorJSONBlockGetNamedNodeData(qemuMonitorPtr mon)
     if (!(nodes = qemuMonitorJSONQueryNamedBlockNodes(mon)))
         return NULL;
 
-    if (!(ret = virHashNew((virHashDataFreeSimple) qemuMonitorJSONBlockNamedNodeDataFree)))
+    if (!(ret = virHashNew((virHashDataFree) qemuMonitorJSONBlockNamedNodeDataFree)))
         return NULL;
 
     if (virJSONValueArrayForeachSteal(nodes,

diff --git a/src/util/vircgroup.c b/src/util/vircgroup.c
index a70ffdf748008d9d3d48ee408637682f10e16d18..87ed9f4565012617d7f6be5eb1cb3176e901375b 100644 (file)
--- a/src/util/vircgroup.c
+++ b/src/util/vircgroup.c
@@ -2583,7 +2583,7 @@ virCgroupKillRecursive(virCgroupPtr group, int signum)
     bool backendAvailable = false;
     virCgroupBackendPtr *backends = virCgroupBackendGetAll();
     virHashTablePtr pids = virHashCreateFull(100,
-                                             NULL, NULL,
+                                             NULL,
                                              virCgroupPidCode,
                                              virCgroupPidEqual,
                                              virCgroupPidCopy,

diff --git a/src/util/virhash.c b/src/util/virhash.c
index 1df7f6efcab81f0f163c94ef59a6db148cc37fb3..313ca57a544b8a0a47e62f252ab4f4dd398a4f16 100644 (file)
--- a/src/util/virhash.c
+++ b/src/util/virhash.c
@@ -56,7 +56,6 @@ struct _virHashTable {
     size_t size;
     size_t nbElems;
     virHashDataFree dataFree;
-    virHashDataFreeSimple dataFreeSimple;
     virHashKeyCode keyCode;
     virHashKeyEqual keyEqual;
     virHashKeyCopy keyCopy;
@@ -106,7 +105,7 @@ static void virHashStrFree(void *name)
 
 
 void
-virHashValueFree(void *value, const void *name G_GNUC_UNUSED)
+virHashValueFree(void *value)
 {
     VIR_FREE(value);
 }
@@ -134,7 +133,6 @@ virHashComputeKey(const virHashTable *table, const void *name)
  */
 virHashTablePtr virHashCreateFull(ssize_t size,
                                   virHashDataFree dataFree,
-                                  virHashDataFreeSimple dataFreeSimple,
                                   virHashKeyCode keyCode,
                                   virHashKeyEqual keyEqual,
                                   virHashKeyCopy keyCopy,
@@ -151,10 +149,7 @@ virHashTablePtr virHashCreateFull(ssize_t size,
     table->seed = virRandomBits(32);
     table->size = size;
     table->nbElems = 0;
-    if (dataFree)
-        table->dataFree = dataFree;
-    else
-        table->dataFreeSimple = dataFreeSimple;
+    table->dataFree = dataFree;
     table->keyCode = keyCode;
     table->keyEqual = keyEqual;
     table->keyCopy = keyCopy;
@@ -178,10 +173,9 @@ virHashTablePtr virHashCreateFull(ssize_t size,
  * Returns the newly created object, or NULL if an error occurred.
  */
 virHashTablePtr
-virHashNew(virHashDataFreeSimple dataFree)
+virHashNew(virHashDataFree dataFree)
 {
     return virHashCreateFull(32,
-                             NULL,
                              dataFree,
                              virHashStrCode,
                              virHashStrEqual,
@@ -203,7 +197,6 @@ virHashTablePtr virHashCreate(ssize_t size, virHashDataFree dataFree)
 {
     return virHashCreateFull(size,
                              dataFree,
-                             NULL,
                              virHashStrCode,
                              virHashStrEqual,
                              virHashStrCopy,
@@ -324,9 +317,7 @@ virHashFree(virHashTablePtr table)
             virHashEntryPtr next = iter->next;
 
             if (table->dataFree)
-                table->dataFree(iter->payload, iter->name);
-            if (table->dataFreeSimple)
-                table->dataFreeSimple(iter->payload);
+                table->dataFree(iter->payload);
             if (table->keyFree)
                 table->keyFree(iter->name);
             VIR_FREE(iter);
@@ -358,9 +349,7 @@ virHashAddOrUpdateEntry(virHashTablePtr table, const void *name,
         if (table->keyEqual(entry->name, name)) {
             if (is_update) {
                 if (table->dataFree)
-                    table->dataFree(entry->payload, entry->name);
-                if (table->dataFreeSimple)
-                    table->dataFreeSimple(entry->payload);
+                    table->dataFree(entry->payload);
                 entry->payload = userdata;
                 return 0;
             } else {
@@ -518,12 +507,9 @@ void *virHashSteal(virHashTablePtr table, const void *name)
     void *data = virHashLookup(table, name);
     if (data) {
         virHashDataFree dataFree = table->dataFree;
-        virHashDataFreeSimple dataFreeSimple = table->dataFreeSimple;
         table->dataFree = NULL;
-        table->dataFreeSimple = NULL;
         virHashRemoveEntry(table, name);
         table->dataFree = dataFree;
-        table->dataFreeSimple = dataFreeSimple;
     }
     return data;
 }
@@ -601,7 +587,7 @@ virHashRemoveEntry(virHashTablePtr table, const void *name)
     for (entry = *nextptr; entry; entry = entry->next) {
         if (table->keyEqual(entry->name, name)) {
             if (table->dataFree)
-                table->dataFree(entry->payload, entry->name);
+                table->dataFree(entry->payload);
             if (table->keyFree)
                 table->keyFree(entry->name);
             *nextptr = entry->next;
@@ -689,7 +675,7 @@ virHashRemoveSet(virHashTablePtr table,
             } else {
                 count++;
                 if (table->dataFree)
-                    table->dataFree(entry->payload, entry->name);
+                    table->dataFree(entry->payload);
                 if (table->keyFree)
                     table->keyFree(entry->name);
                 *nextptr = entry->next;

diff --git a/src/util/virhash.h b/src/util/virhash.h
index 8087965ee9ed870cb203e4caed3d5e10daee739e..6318c0b3cd4a43abbecc1f7d99ffeb096e36dd9a 100644 (file)
--- a/src/util/virhash.h
+++ b/src/util/virhash.h
@@ -25,19 +25,10 @@ typedef virHashAtomic *virHashAtomicPtr;
 /**
  * virHashDataFree:
  * @payload:  the data in the hash
- * @name:  the name associated
  *
  * Callback to free data from a hash.
  */
-typedef void (*virHashDataFree) (void *payload, const void *name);
-/**
- * virHashDataFreeSimple:
- * @payload:  the data in the hash
- * @name:  the name associated
- *
- * Callback to free data from a hash.
- */
-typedef void (*virHashDataFreeSimple) (void *payload);
+typedef void (*virHashDataFree) (void *payload);
 
 /**
  * virHashIterator:
@@ -107,14 +98,13 @@ typedef void (*virHashKeyFree)(void *name);
 /*
  * Constructor and destructor.
  */
-virHashTablePtr virHashNew(virHashDataFreeSimple dataFree);
+virHashTablePtr virHashNew(virHashDataFree dataFree);
 virHashTablePtr virHashCreate(ssize_t size,
                               virHashDataFree dataFree);
 virHashAtomicPtr virHashAtomicNew(ssize_t size,
                                   virHashDataFree dataFree);
 virHashTablePtr virHashCreateFull(ssize_t size,
                                   virHashDataFree dataFree,
-                                  virHashDataFreeSimple dataFreeSimple,
                                   virHashKeyCode keyCode,
                                   virHashKeyEqual keyEqual,
                                   virHashKeyCopy keyCopy,
@@ -203,6 +193,6 @@ void *virHashSearch(const virHashTable *table, virHashSearcher iter,
                     const void *data, void **name);
 
 /* Convenience for when VIR_FREE(value) is sufficient as a data freer.  */
-void virHashValueFree(void *value, const void *name);
+void virHashValueFree(void *value);
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virHashTable, virHashFree);

diff --git a/src/util/virjson.c b/src/util/virjson.c
index 76efb17e24c75d06037ac176c91e418ef6b9fe4e..c57dc11f78544ebae8e52553c74a6d851e1ab755 100644 (file)
--- a/src/util/virjson.c
+++ b/src/util/virjson.c
@@ -425,8 +425,7 @@ virJSONValueFree(virJSONValuePtr value)
 
 
 void
-virJSONValueHashFree(void *opaque,
-                     const void *name G_GNUC_UNUSED)
+virJSONValueHashFree(void *opaque)
 {
     virJSONValueFree(opaque);
 }

diff --git a/src/util/virjson.h b/src/util/virjson.h
index fa8571c73ba2f7edead83f0e0a43c6d57d49be03..7a6b063b17f5839656d8d014e6fe18cb2e453a02 100644 (file)
--- a/src/util/virjson.h
+++ b/src/util/virjson.h
@@ -42,7 +42,7 @@ typedef struct _virJSONValue virJSONValue;
 typedef virJSONValue *virJSONValuePtr;
 
 void virJSONValueFree(virJSONValuePtr value);
-void virJSONValueHashFree(void *opaque, const void *name);
+void virJSONValueHashFree(void *opaque);
 
 virJSONType virJSONValueGetType(const virJSONValue *value);
 

diff --git a/src/util/virkeyfile.c b/src/util/virkeyfile.c
index c7e756d26ab25b41cf809ca8ea222cd74fab4d62..dc7a558c6f759ed46ff09361ffdb5ce695270edc 100644 (file)
--- a/src/util/virkeyfile.c
+++ b/src/util/virkeyfile.c
@@ -265,7 +265,7 @@ static int virKeyFileParse(virKeyFilePtr conf,
 }
 
 
-static void virKeyFileEntryFree(void *payload, const void *name G_GNUC_UNUSED)
+static void virKeyFileEntryFree(void *payload)
 {
     virHashFree(payload);
 }

diff --git a/src/util/virlockspace.c b/src/util/virlockspace.c
index b7e1b6cfdab308eb0a8bbee7ced680eddb6c1e9d..59d47daae85295e857361d5ada29b7d0db1c4b7d 100644 (file)
--- a/src/util/virlockspace.c
+++ b/src/util/virlockspace.c
@@ -231,7 +231,7 @@ virLockSpaceResourceNew(virLockSpacePtr lockspace,
 }
 
 
-static void virLockSpaceResourceDataFree(void *opaque, const void *name G_GNUC_UNUSED)
+static void virLockSpaceResourceDataFree(void *opaque)
 {
     virLockSpaceResourcePtr res = opaque;
     virLockSpaceResourceFree(res);

diff --git a/src/util/virobject.c b/src/util/virobject.c
index 812b013e722c8e27a8e1be3031dae5c1733f912b..5af14234f26665642c1d7c8ce8591b75e77e746a 100644 (file)
--- a/src/util/virobject.c
+++ b/src/util/virobject.c
@@ -589,8 +589,7 @@ void virObjectFreeCallback(void *opaque)
  * typedef.
  */
 void
-virObjectFreeHashData(void *opaque,
-                      const void *name G_GNUC_UNUSED)
+virObjectFreeHashData(void *opaque)
 {
     virObjectUnref(opaque);
 }

diff --git a/src/util/virobject.h b/src/util/virobject.h
index 7cb3457021ed4713b6e3d8ec875f186a364208e2..5c4bcf4dde904b7058af25228ed20569f5cc4506 100644 (file)
--- a/src/util/virobject.h
+++ b/src/util/virobject.h
@@ -123,8 +123,7 @@ void
 virObjectFreeCallback(void *opaque);
 
 void
-virObjectFreeHashData(void *opaque,
-                      const void *name);
+virObjectFreeHashData(void *opaque);
 
 void *
 virObjectLockableNew(virClassPtr klass)

diff --git a/src/util/virsystemd.c b/src/util/virsystemd.c
index 1f9eddf70b489a3e5d56dca0b5559a85fdb441e0..2acb54d41ed58c7f50937110a3c9ef41eb0000c2 100644 (file)
--- a/src/util/virsystemd.c
+++ b/src/util/virsystemd.c
@@ -619,12 +619,12 @@ int virSystemdCanHybridSleep(bool *result)
 
 
 static void
-virSystemdActivationEntryFree(void *data, const void *name)
+virSystemdActivationEntryFree(void *data)
 {
     virSystemdActivationEntryPtr ent = data;
     size_t i;
 
-    VIR_DEBUG("Closing activation FDs for %s", (const char *)name);
+    VIR_DEBUG("Closing activation FDs");
     for (i = 0; i < ent->nfds; i++) {
         VIR_DEBUG("Closing activation FD %d", ent->fds[i]);
         VIR_FORCE_CLOSE(ent->fds[i]);
@@ -647,7 +647,7 @@ virSystemdActivationAddFD(virSystemdActivationPtr act,
             return -1;
 
         if (VIR_ALLOC_N(ent->fds, 1) < 0) {
-            virSystemdActivationEntryFree(ent, name);
+            virSystemdActivationEntryFree(ent);
             return -1;
         }
 
@@ -655,7 +655,7 @@ virSystemdActivationAddFD(virSystemdActivationPtr act,
 
         VIR_DEBUG("Record first FD %d with name %s", fd, name);
         if (virHashAddEntry(act->fds, name, ent) < 0) {
-            virSystemdActivationEntryFree(ent, name);
+            virSystemdActivationEntryFree(ent);
             return -1;
         }