--name=virDomainSoundDefFree \
--name=virDomainVideoDefFree \
--name=virDomainWatchdogDefFree \
+ --name=virHashFree \
--name=virInterfaceDefFree \
--name=virInterfaceIpDefFree \
--name=virInterfaceObjFree \
#define VIR_DOMAIN_XML_WRITE_FLAGS VIR_DOMAIN_XML_SECURE
#define VIR_DOMAIN_XML_READ_FLAGS VIR_DOMAIN_XML_INACTIVE
+static void
+virDomainObjListDeallocator(void *payload, const char *name ATTRIBUTE_UNUSED)
+{
+ virDomainObjPtr obj = payload;
+ virDomainObjLock(obj);
+ if (virDomainObjUnref(obj) > 0)
+ virDomainObjUnlock(obj);
+}
+
int virDomainObjListInit(virDomainObjListPtr doms)
{
- doms->objs = virHashCreate(50);
+ doms->objs = virHashCreate(50, virDomainObjListDeallocator);
if (!doms->objs)
return -1;
return 0;
}
-static void virDomainObjListDeallocator(void *payload, const char *name ATTRIBUTE_UNUSED)
-{
- virDomainObjPtr obj = payload;
- virDomainObjLock(obj);
- if (virDomainObjUnref(obj) > 0)
- virDomainObjUnlock(obj);
-}
-
void virDomainObjListDeinit(virDomainObjListPtr doms)
{
- virHashFree(doms->objs, virDomainObjListDeallocator);
+ virHashFree(doms->objs);
}
}
/* Snapshot Obj List functions */
+static void
+virDomainSnapshotObjListDeallocator(void *payload,
+ const char *name ATTRIBUTE_UNUSED)
+{
+ virDomainSnapshotObjPtr obj = payload;
+
+ virDomainSnapshotObjUnref(obj);
+}
+
int virDomainSnapshotObjListInit(virDomainSnapshotObjListPtr snapshots)
{
- snapshots->objs = virHashCreate(50);
+ snapshots->objs = virHashCreate(50, virDomainSnapshotObjListDeallocator);
if (!snapshots->objs)
return -1;
return 0;
}
-static void virDomainSnapshotObjListDeallocator(void *payload,
- const char *name ATTRIBUTE_UNUSED)
-{
- virDomainSnapshotObjPtr obj = payload;
-
- virDomainSnapshotObjUnref(obj);
-}
-
-static void virDomainSnapshotObjListDeinit(virDomainSnapshotObjListPtr snapshots)
+static void
+virDomainSnapshotObjListDeinit(virDomainSnapshotObjListPtr snapshots)
{
- virHashFree(snapshots->objs, virDomainSnapshotObjListDeallocator);
+ virHashFree(snapshots->objs);
}
struct virDomainSnapshotNameData {
}
}
- paths = virHashCreate(5);
+ paths = virHashCreate(5, NULL);
do {
virStorageFileMetadata meta;
ret = 0;
cleanup:
- virHashFree(paths, NULL);
+ virHashFree(paths);
VIR_FREE(nextpath);
return ret;
* nwfilter_conf.c: network filter XML processing
* (derived from storage_conf.c)
*
- * Copyright (C) 2006-2010 Red Hat, Inc.
+ * Copyright (C) 2006-2011 Red Hat, Inc.
* Copyright (C) 2006-2008 Daniel P. Berrange
*
* Copyright (C) 2010 IBM Corporation
.conn = conn,
.err = 0,
.step = STEP_APPLY_NEW,
- .skipInterfaces = virHashCreate(0),
+ .skipInterfaces = virHashCreate(0, NULL),
};
if (!cb.skipInterfaces)
&cb);
}
- virHashFree(cb.skipInterfaces, NULL);
+ virHashFree(cb.skipInterfaces);
return err;
}
/*
* nwfilter_params.c: parsing and data maintenance of filter parameters
*
+ * Copyright (C) 2011 Red Hat, Inc.
* Copyright (C) 2010 IBM Corporation
*
* This library is free software; you can redistribute it and/or
int i;
if (!table)
return;
- virHashFree(table->hashTable, hashDealloc);
+ virHashFree(table->hashTable);
for (i = 0; i < table->nNames; i++)
VIR_FREE(table->names[i]);
virReportOOMError();
return NULL;
}
- ret->hashTable = virHashCreate(n);
+ ret->hashTable = virHashCreate(n, hashDealloc);
if (!ret->hashTable) {
VIR_FREE(ret);
return NULL;
* cpu_generic.c: CPU manipulation driver for architectures which are not
* handled by their own driver
*
- * Copyright (C) 2009--2010 Red Hat, Inc.
+ * Copyright (C) 2009-2011 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
virHashTablePtr hash;
unsigned int i;
- if ((hash = virHashCreate(cpu->nfeatures)) == NULL)
+ if ((hash = virHashCreate(cpu->nfeatures, NULL)) == NULL)
return NULL;
for (i = 0; i < cpu->nfeatures; i++) {
if (virHashAddEntry(hash,
cpu->features[i].name,
cpu->features + i)) {
- virHashFree(hash, NULL);
+ virHashFree(hash);
return NULL;
}
}
ret = VIR_CPU_COMPARE_IDENTICAL;
cleanup:
- virHashFree(hash, NULL);
+ virHashFree(hash);
return ret;
}
}
}
- virHashFree(hash, NULL);
+ virHashFree(hash);
}
if (VIR_ALLOC_N(cpu->features, count) < 0)
* nwfilter_learnipaddr.c: support for learning IP address used by a VM
* on an interface
*
+ * Copyright (C) 2011 Red Hat, Inc.
* Copyright (C) 2010 IBM Corp.
* Copyright (C) 2010 Stefan Berger
*
threadsTerminate = false;
- pendingLearnReq = virHashCreate(0);
+ pendingLearnReq = virHashCreate(0, freeLearnReqEntry);
if (!pendingLearnReq) {
return 1;
}
return 1;
}
- ifaceLockMap = virHashCreate(0);
+ ifaceLockMap = virHashCreate(0, freeIfaceLock);
if (!ifaceLockMap) {
virNWFilterLearnShutdown();
return 1;
virNWFilterLearnThreadsTerminate(false);
- virHashFree(pendingLearnReq, freeLearnReqEntry);
+ virHashFree(pendingLearnReq);
pendingLearnReq = NULL;
virNWFilterHashTableFree(ipAddressMap);
ipAddressMap = NULL;
- virHashFree(ifaceLockMap, freeIfaceLock);
+ virHashFree(ifaceLockMap);
ifaceLockMap = NULL;
}
}
+static void
+qemuDomainPCIAddressSetFreeEntry(void *payload,
+ const char *name ATTRIBUTE_UNUSED)
+{
+ VIR_FREE(payload);
+}
+
qemuDomainPCIAddressSetPtr qemuDomainPCIAddressSetCreate(virDomainDefPtr def)
{
qemuDomainPCIAddressSetPtr addrs;
if (VIR_ALLOC(addrs) < 0)
goto no_memory;
- if (!(addrs->used = virHashCreate(10)))
+ if (!(addrs->used = virHashCreate(10, qemuDomainPCIAddressSetFreeEntry)))
goto error;
if (virDomainDeviceInfoIterate(def, qemuCollectPCIAddress, addrs) < 0)
return ret;
}
-static void qemuDomainPCIAddressSetFreeEntry(void *payload, const char *name ATTRIBUTE_UNUSED)
-{
- VIR_FREE(payload);
-}
-
int qemuDomainPCIAddressReleaseAddr(qemuDomainPCIAddressSetPtr addrs,
virDomainDeviceInfoPtr dev)
if (!addrs)
return;
- virHashFree(addrs->used, qemuDomainPCIAddressSetFreeEntry);
+ virHashFree(addrs->used);
VIR_FREE(addrs);
}
* reliable if it's available.
* Note that the monitor itself can be on a pty, so we still need to try the
* log output method. */
- paths = virHashCreate(0);
+ paths = virHashCreate(0, qemuProcessFreePtyPath);
if (paths == NULL)
goto cleanup;
ret = qemuProcessFindCharDevicePTYsMonitor(vm, paths);
cleanup:
- virHashFree(paths, qemuProcessFreePtyPath);
+ virHashFree(paths);
if (kill(vm->pid, 0) == -1 && errno == ESRCH) {
/* VM is dead, any other error raised in the interim is probably
struct _virHashEntry *table;
int size;
int nbElems;
+ virHashDeallocator f;
};
/*
/**
* virHashCreate:
* @size: the size of the hash table
+ * @deallocator: function to call on each entry during virHashFree
*
* Create a new virHashTablePtr.
*
* Returns the newly created object, or NULL if an error occured.
*/
virHashTablePtr
-virHashCreate(int size)
+virHashCreate(int size, virHashDeallocator deallocator)
{
virHashTablePtr table = NULL;
table->size = size;
table->nbElems = 0;
+ table->f = deallocator;
if (VIR_ALLOC_N(table->table, size) < 0) {
virReportOOMError();
VIR_FREE(table);
/**
* virHashFree:
* @table: the hash table
- * @f: the deallocator function for items in the hash
*
* Free the hash @table and its contents. The userdata is
- * deallocated with @f if provided.
+ * deallocated with function provided at creation time.
*/
void
-virHashFree(virHashTablePtr table, virHashDeallocator f)
+virHashFree(virHashTablePtr table)
{
int i;
virHashEntryPtr iter;
inside_table = 1;
while (iter) {
next = iter->next;
- if ((f != NULL) && (iter->payload != NULL))
- f(iter->payload, iter->name);
+ if ((table->f != NULL) && (iter->payload != NULL))
+ table->f(iter->payload, iter->name);
VIR_FREE(iter->name);
iter->payload = NULL;
if (!inside_table)
* Description: This module implements the hash table and allocation and
* deallocation of domains and connections
*
- * Copy: Copyright (C) 2005 Red Hat, Inc.
+ * Copy: Copyright (C) 2005, 2011 Red Hat, Inc.
*
* Author: Bjorn Reese <bjorn.reese@systematic.dk>
* Daniel Veillard <veillard@redhat.com>
* 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);
+typedef int (*virHashSearcher) (const void *payload, const char *name,
+ const void *data);
/*
* Constructor and destructor.
*/
-virHashTablePtr virHashCreate(int size);
-void virHashFree(virHashTablePtr table, virHashDeallocator f);
+virHashTablePtr virHashCreate(int size, virHashDeallocator f);
+void virHashFree(virHashTablePtr table);
int virHashSize(virHashTablePtr table);
/*
/*
* xm_internal.h: helper routines for dealing with inactive domains
*
- * Copyright (C) 2006-2007, 2009-2010 Red Hat, Inc.
+ * Copyright (C) 2006-2007, 2009-2011 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
priv->configDir = XM_CONFIG_DIR;
- priv->configCache = virHashCreate(50);
+ priv->configCache = virHashCreate(50, xenXMConfigFree);
if (!priv->configCache)
return (-1);
- priv->nameConfigMap = virHashCreate(50);
+ priv->nameConfigMap = virHashCreate(50, NULL);
if (!priv->nameConfigMap) {
- virHashFree(priv->configCache, NULL);
+ virHashFree(priv->configCache);
priv->configCache = NULL;
return (-1);
}
int xenXMClose(virConnectPtr conn) {
xenUnifiedPrivatePtr priv = conn->privateData;
- virHashFree(priv->nameConfigMap, NULL);
- virHashFree(priv->configCache, xenXMConfigFree);
+ virHashFree(priv->nameConfigMap);
+ virHashFree(priv->configCache);
return (0);
}
projects / thirdparty / libvirt.git / commitdiff
