NuKVM/libvirt
3
0
Fork 0
mirror of https://github.com/libvirt/libvirt.git synced 2025-02-25 18:55:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

util: replace VIR_FREE with g_free in all vir*Free() functions

Browse Source 
Signed-off-by: Laine Stump <laine@redhat.com>
Reviewed-by: Daniel Henrique Barboza <danielhb413@gmail.com>
This commit is contained in:
Laine Stump 2021-02-03 14:32:34 -05:00
parent a3a88167e4
commit 238d96b8f1
41 changed files with 225 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/util/virarptable.c
View File

@ -172,9 +172,9 @@ virArpTableFree(virArpTablePtr table)
return; return;
for (i = 0; i < table->n; i++) { for (i = 0; i < table->n; i++) {
VIR_FREE(table->t[i].ipaddr); g_free(table->t[i].ipaddr);
VIR_FREE(table->t[i].mac); g_free(table->t[i].mac);
} }
VIR_FREE(table->t); g_free(table->t);
VIR_FREE(table); g_free(table);
} }

4
src/util/virauthconfig.c
View File

@ -88,8 +88,8 @@ void virAuthConfigFree(virAuthConfigPtr auth)
return; return;
g_key_file_free(auth->keyfile); g_key_file_free(auth->keyfile);
VIR_FREE(auth->path); g_free(auth->path);
VIR_FREE(auth); g_free(auth);
} }

4
src/util/virbitmap.c
View File

@ -94,8 +94,8 @@ void
virBitmapFree(virBitmapPtr bitmap) virBitmapFree(virBitmapPtr bitmap)
{ {
if (bitmap) { if (bitmap) {
VIR_FREE(bitmap->map); g_free(bitmap->map);
VIR_FREE(bitmap); g_free(bitmap);
} }
} }

12
src/util/vircgroup.c
View File

@ -3581,15 +3581,15 @@ virCgroupFree(virCgroupPtr group)
return; return;
for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) { for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
VIR_FREE(group->legacy[i].mountPoint); g_free(group->legacy[i].mountPoint);
VIR_FREE(group->legacy[i].linkPoint); g_free(group->legacy[i].linkPoint);
VIR_FREE(group->legacy[i].placement); g_free(group->legacy[i].placement);
} }
VIR_FREE(group->unified.mountPoint); g_free(group->unified.mountPoint);
VIR_FREE(group->unified.placement); g_free(group->unified.placement);
VIR_FREE(group); g_free(group);
} }

24
src/util/vircommand.c
View File

@ -3028,25 +3028,25 @@ virCommandFree(virCommandPtr cmd)
VIR_FORCE_CLOSE(cmd->passfd[i].fd); VIR_FORCE_CLOSE(cmd->passfd[i].fd);
} }
cmd->npassfd = 0; cmd->npassfd = 0;
VIR_FREE(cmd->passfd); g_free(cmd->passfd);
if (cmd->asyncioThread) { if (cmd->asyncioThread) {
virThreadJoin(cmd->asyncioThread); virThreadJoin(cmd->asyncioThread);
VIR_FREE(cmd->asyncioThread); g_free(cmd->asyncioThread);
} }
VIR_FREE(cmd->inbuf); g_free(cmd->inbuf);
VIR_FORCE_CLOSE(cmd->outfd); VIR_FORCE_CLOSE(cmd->outfd);
VIR_FORCE_CLOSE(cmd->errfd); VIR_FORCE_CLOSE(cmd->errfd);
for (i = 0; i < cmd->nargs; i++) for (i = 0; i < cmd->nargs; i++)
VIR_FREE(cmd->args[i]); g_free(cmd->args[i]);
VIR_FREE(cmd->args); g_free(cmd->args);
for (i = 0; i < cmd->nenv; i++) for (i = 0; i < cmd->nenv; i++)
VIR_FREE(cmd->env[i]); g_free(cmd->env[i]);
VIR_FREE(cmd->env); g_free(cmd->env);
VIR_FREE(cmd->pwd); g_free(cmd->pwd);
if (cmd->handshake) { if (cmd->handshake) {
/* The other 2 fds in these arrays are closed /* The other 2 fds in these arrays are closed
@ -3056,21 +3056,21 @@ virCommandFree(virCommandPtr cmd)
VIR_FORCE_CLOSE(cmd->handshakeNotify[1]); VIR_FORCE_CLOSE(cmd->handshakeNotify[1]);
} }
VIR_FREE(cmd->pidfile); g_free(cmd->pidfile);
if (cmd->reap) if (cmd->reap)
virCommandAbort(cmd); virCommandAbort(cmd);
#if defined(WITH_SECDRIVER_SELINUX) #if defined(WITH_SECDRIVER_SELINUX)
VIR_FREE(cmd->seLinuxLabel); g_free(cmd->seLinuxLabel);
#endif #endif
#if defined(WITH_SECDRIVER_APPARMOR) #if defined(WITH_SECDRIVER_APPARMOR)
VIR_FREE(cmd->appArmorProfile); g_free(cmd->appArmorProfile);
#endif #endif
virCommandFreeSendBuffers(cmd); virCommandFreeSendBuffers(cmd);
VIR_FREE(cmd); g_free(cmd);
} }
/** /**

10
src/util/virconf.c
View File

@ -788,15 +788,15 @@ virConfFree(virConfPtr conf)
tmp = conf->entries; tmp = conf->entries;
while (tmp) { while (tmp) {
virConfEntryPtr next; virConfEntryPtr next;
VIR_FREE(tmp->name); g_free(tmp->name);
virConfFreeValue(tmp->value); virConfFreeValue(tmp->value);
VIR_FREE(tmp->comment); g_free(tmp->comment);
next = tmp->next; next = tmp->next;
VIR_FREE(tmp); g_free(tmp);
tmp = next; tmp = next;
} }
VIR_FREE(conf->filename); g_free(conf->filename);
VIR_FREE(conf); g_free(conf);
return 0; return 0;
} }

16
src/util/virdnsmasq.c
View File

@ -75,14 +75,14 @@ addnhostsFree(dnsmasqAddnHostsfile *addnhostsfile)
for (i = 0; i < addnhostsfile->nhosts; i++) for (i = 0; i < addnhostsfile->nhosts; i++)
addnhostFree(&addnhostsfile->hosts[i]); addnhostFree(&addnhostsfile->hosts[i]);
VIR_FREE(addnhostsfile->hosts); g_free(addnhostsfile->hosts);
addnhostsfile->nhosts = 0; addnhostsfile->nhosts = 0;
} }
VIR_FREE(addnhostsfile->path); g_free(addnhostsfile->path);
VIR_FREE(addnhostsfile); g_free(addnhostsfile);
} }
static int static int
@ -272,14 +272,14 @@ hostsfileFree(dnsmasqHostsfile *hostsfile)
for (i = 0; i < hostsfile->nhosts; i++) for (i = 0; i < hostsfile->nhosts; i++)
dhcphostFree(&hostsfile->hosts[i]); dhcphostFree(&hostsfile->hosts[i]);
VIR_FREE(hostsfile->hosts); g_free(hostsfile->hosts);
hostsfile->nhosts = 0; hostsfile->nhosts = 0;
} }
VIR_FREE(hostsfile->path); g_free(hostsfile->path);
VIR_FREE(hostsfile); g_free(hostsfile);
} }
/* Note: There are many additional dhcp-host specifications /* Note: There are many additional dhcp-host specifications
@ -465,14 +465,14 @@ dnsmasqContextFree(dnsmasqContext *ctx)
if (!ctx) if (!ctx)
return; return;
VIR_FREE(ctx->config_dir); g_free(ctx->config_dir);
if (ctx->hostsfile) if (ctx->hostsfile)
hostsfileFree(ctx->hostsfile); hostsfileFree(ctx->hostsfile);
if (ctx->addnhostsfile) if (ctx->addnhostsfile)
addnhostsFree(ctx->addnhostsfile); addnhostsFree(ctx->addnhostsfile);
VIR_FREE(ctx); g_free(ctx);
} }
/** /**

4
src/util/virebtables.c
View File

@ -73,8 +73,8 @@ ebtablesContextFree(ebtablesContext *ctx)
{ {
if (!ctx) if (!ctx)
return; return;
VIR_FREE(ctx->chain); g_free(ctx->chain);
VIR_FREE(ctx); g_free(ctx);
} }

10
src/util/virfdstream.c
View File

@ -198,14 +198,14 @@ virFDStreamMsgFree(virFDStreamMsgPtr msg)
switch (msg->type) { switch (msg->type) {
case VIR_FDSTREAM_MSG_TYPE_DATA: case VIR_FDSTREAM_MSG_TYPE_DATA:
VIR_FREE(msg->stream.data.buf); g_free(msg->stream.data.buf);
break; break;
case VIR_FDSTREAM_MSG_TYPE_HOLE: case VIR_FDSTREAM_MSG_TYPE_HOLE:
/* nada */ /* nada */
break; break;
} }
VIR_FREE(msg); g_free(msg);
} }
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virFDStreamMsg, virFDStreamMsgFree); G_DEFINE_AUTOPTR_CLEANUP_FUNC(virFDStreamMsg, virFDStreamMsgFree);
@ -413,9 +413,9 @@ virFDStreamThreadDataFree(virFDStreamThreadDataPtr data)
return; return;
virObjectUnref(data->st); virObjectUnref(data->st);
VIR_FREE(data->fdinname); g_free(data->fdinname);
VIR_FREE(data->fdoutname); g_free(data->fdoutname);
VIR_FREE(data); g_free(data);
} }

4
src/util/virfile.c
View File

@ -382,9 +382,9 @@ virFileWrapperFdFree(virFileWrapperFdPtr wfd)
if (!wfd) if (!wfd)
return; return;
VIR_FREE(wfd->err_msg); g_free(wfd->err_msg);
virCommandFree(wfd->cmd); virCommandFree(wfd->cmd);
VIR_FREE(wfd); g_free(wfd);
} }

16
src/util/virfirewall.c
View File

@ -196,9 +196,9 @@ virFirewallRuleFree(virFirewallRulePtr rule)
return; return;
for (i = 0; i < rule->argsLen; i++) for (i = 0; i < rule->argsLen; i++)
VIR_FREE(rule->args[i]); g_free(rule->args[i]);
VIR_FREE(rule->args); g_free(rule->args);
VIR_FREE(rule); g_free(rule);
} }
@ -212,13 +212,13 @@ virFirewallGroupFree(virFirewallGroupPtr group)
for (i = 0; i < group->naction; i++) for (i = 0; i < group->naction; i++)
virFirewallRuleFree(group->action[i]); virFirewallRuleFree(group->action[i]);
VIR_FREE(group->action); g_free(group->action);
for (i = 0; i < group->nrollback; i++) for (i = 0; i < group->nrollback; i++)
virFirewallRuleFree(group->rollback[i]); virFirewallRuleFree(group->rollback[i]);
VIR_FREE(group->rollback); g_free(group->rollback);
VIR_FREE(group); g_free(group);
} }
@ -237,9 +237,9 @@ void virFirewallFree(virFirewallPtr firewall)
for (i = 0; i < firewall->ngroups; i++) for (i = 0; i < firewall->ngroups; i++)
virFirewallGroupFree(firewall->groups[i]); virFirewallGroupFree(firewall->groups[i]);
VIR_FREE(firewall->groups); g_free(firewall->groups);
VIR_FREE(firewall); g_free(firewall);
} }
#define VIR_FIREWALL_RETURN_IF_ERROR(firewall) \ #define VIR_FIREWALL_RETURN_IF_ERROR(firewall) \

8
src/util/virfirmware.c
View File

@ -37,9 +37,9 @@ virFirmwareFree(virFirmwarePtr firmware)
if (!firmware) if (!firmware)
return; return;
VIR_FREE(firmware->name); g_free(firmware->name);
VIR_FREE(firmware->nvram); g_free(firmware->nvram);
VIR_FREE(firmware); g_free(firmware);
} }
@ -51,7 +51,7 @@ virFirmwareFreeList(virFirmwarePtr *firmwares, size_t nfirmwares)
for (i = 0; i < nfirmwares; i++) for (i = 0; i < nfirmwares; i++)
virFirmwareFree(firmwares[i]); virFirmwareFree(firmwares[i]);
VIR_FREE(firmwares); g_free(firmwares);
} }

12
src/util/virjson.c
View File

@ -398,28 +398,28 @@ virJSONValueFree(virJSONValuePtr value)
switch ((virJSONType) value->type) { switch ((virJSONType) value->type) {
case VIR_JSON_TYPE_OBJECT: case VIR_JSON_TYPE_OBJECT:
for (i = 0; i < value->data.object.npairs; i++) { for (i = 0; i < value->data.object.npairs; i++) {
VIR_FREE(value->data.object.pairs[i].key); g_free(value->data.object.pairs[i].key);
virJSONValueFree(value->data.object.pairs[i].value); virJSONValueFree(value->data.object.pairs[i].value);
} }
VIR_FREE(value->data.object.pairs); g_free(value->data.object.pairs);
break; break;
case VIR_JSON_TYPE_ARRAY: case VIR_JSON_TYPE_ARRAY:
for (i = 0; i < value->data.array.nvalues; i++) for (i = 0; i < value->data.array.nvalues; i++)
virJSONValueFree(value->data.array.values[i]); virJSONValueFree(value->data.array.values[i]);
VIR_FREE(value->data.array.values); g_free(value->data.array.values);
break; break;
case VIR_JSON_TYPE_STRING: case VIR_JSON_TYPE_STRING:
VIR_FREE(value->data.string); g_free(value->data.string);
break; break;
case VIR_JSON_TYPE_NUMBER: case VIR_JSON_TYPE_NUMBER:
VIR_FREE(value->data.number); g_free(value->data.number);
break; break;
case VIR_JSON_TYPE_BOOLEAN: case VIR_JSON_TYPE_BOOLEAN:
case VIR_JSON_TYPE_NULL: case VIR_JSON_TYPE_NULL:
break; break;
} }
VIR_FREE(value); g_free(value);
} }

12
src/util/virlockspace.c
View File

@ -102,11 +102,11 @@ static void virLockSpaceResourceFree(virLockSpaceResourcePtr res)
} }
} }
VIR_FREE(res->owners); g_free(res->owners);
VIR_FORCE_CLOSE(res->fd); VIR_FORCE_CLOSE(res->fd);
VIR_FREE(res->path); g_free(res->path);
VIR_FREE(res->name); g_free(res->name);
VIR_FREE(res); g_free(res);
} }
@ -499,9 +499,9 @@ void virLockSpaceFree(virLockSpacePtr lockspace)
return; return;
virHashFree(lockspace->resources); virHashFree(lockspace->resources);
VIR_FREE(lockspace->dir); g_free(lockspace->dir);
virMutexDestroy(&lockspace->lock); virMutexDestroy(&lockspace->lock);
VIR_FREE(lockspace); g_free(lockspace);
} }

12
src/util/virlog.c
View File

@ -339,8 +339,8 @@ virLogFilterFree(virLogFilterPtr filter)
if (!filter) if (!filter)
return; return;
VIR_FREE(filter->match); g_free(filter->match);
VIR_FREE(filter); g_free(filter);
} }
@ -361,7 +361,7 @@ virLogFilterListFree(virLogFilterPtr *list, int count)
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
virLogFilterFree(list[i]); virLogFilterFree(list[i]);
VIR_FREE(list); g_free(list);
} }
@ -387,8 +387,8 @@ virLogOutputFree(virLogOutputPtr output)
if (output->c) if (output->c)
output->c(output->data); output->c(output->data);
VIR_FREE(output->name); g_free(output->name);
VIR_FREE(output); g_free(output);
} }
@ -410,7 +410,7 @@ virLogOutputListFree(virLogOutputPtr *list, int count)
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
virLogOutputFree(list[i]); virLogOutputFree(list[i]);
VIR_FREE(list); g_free(list);
} }

2
src/util/virmacaddr.c
View File

@ -250,5 +250,5 @@ virMacAddrIsBroadcastRaw(const unsigned char s[VIR_MAC_BUFLEN])
void void
virMacAddrFree(virMacAddrPtr addr) virMacAddrFree(virMacAddrPtr addr)
{ {
VIR_FREE(addr); g_free(addr);
} }

16
src/util/virmdev.c
View File

@ -183,10 +183,10 @@ virMediatedDeviceFree(virMediatedDevicePtr dev)
{ {
if (!dev) if (!dev)
return; return;
VIR_FREE(dev->path); g_free(dev->path);
VIR_FREE(dev->used_by_drvname); g_free(dev->used_by_drvname);
VIR_FREE(dev->used_by_domname); g_free(dev->used_by_domname);
VIR_FREE(dev); g_free(dev);
} }
@ -476,10 +476,10 @@ virMediatedDeviceTypeFree(virMediatedDeviceTypePtr type)
if (!type) if (!type)
return; return;
VIR_FREE(type->id); g_free(type->id);
VIR_FREE(type->name); g_free(type->name);
VIR_FREE(type->device_api); g_free(type->device_api);
VIR_FREE(type); g_free(type);
} }

12
src/util/virnetdev.c
View File

@ -127,7 +127,7 @@ struct _virNetDevMcastEntry {
static void static void
virNetDevMcastEntryFree(virNetDevMcastEntryPtr entry) virNetDevMcastEntryFree(virNetDevMcastEntryPtr entry)
{ {
VIR_FREE(entry); g_free(entry);
} }
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetDevMcastEntry, virNetDevMcastEntryFree); G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNetDevMcastEntry, virNetDevMcastEntryFree);
@ -2868,11 +2868,11 @@ void
virNetDevRxFilterFree(virNetDevRxFilterPtr filter) virNetDevRxFilterFree(virNetDevRxFilterPtr filter)
{ {
if (filter) { if (filter) {
VIR_FREE(filter->name); g_free(filter->name);
VIR_FREE(filter->unicast.table); g_free(filter->unicast.table);
VIR_FREE(filter->multicast.table); g_free(filter->multicast.table);
VIR_FREE(filter->vlan.table); g_free(filter->vlan.table);
VIR_FREE(filter); g_free(filter);
} }
} }

6
src/util/virnetdevbandwidth.c
View File

@ -34,9 +34,9 @@ virNetDevBandwidthFree(virNetDevBandwidthPtr def)
if (!def) if (!def)
return; return;
VIR_FREE(def->in); g_free(def->in);
VIR_FREE(def->out); g_free(def->out);
VIR_FREE(def); g_free(def);
} }
static void static void

6
src/util/virnetdevip.c
View File

@ -775,8 +775,8 @@ virNetDevIPRouteFree(virNetDevIPRoutePtr def)
{ {
if (!def) if (!def)
return; return;
VIR_FREE(def->family); g_free(def->family);
VIR_FREE(def); g_free(def);
} }
virSocketAddrPtr virSocketAddrPtr
@ -913,5 +913,5 @@ virNetDevIPInfoAddToDev(const char *ifname,
void void
virNetDevIPAddrFree(virNetDevIPAddrPtr ip) virNetDevIPAddrFree(virNetDevIPAddrPtr ip)
{ {
VIR_FREE(ip); g_free(ip);
} }

8
src/util/virnetdevmacvlan.c
View File

@ -563,11 +563,11 @@ static void
virNetlinkCallbackDataFree(virNetlinkCallbackDataPtr calld) virNetlinkCallbackDataFree(virNetlinkCallbackDataPtr calld)
{ {
if (calld) { if (calld) {
VIR_FREE(calld->cr_ifname); g_free(calld->cr_ifname);
VIR_FREE(calld->virtPortProfile); g_free(calld->virtPortProfile);
VIR_FREE(calld->linkdev); g_free(calld->linkdev);
} }
VIR_FREE(calld); g_free(calld);
} }
/** /**

2
src/util/virnetdevvlan.c
View File

@ -39,7 +39,7 @@ virNetDevVlanFree(virNetDevVlanPtr vlan)
{ {
if (vlan) if (vlan)
virNetDevVlanClear(vlan); virNetDevVlanClear(vlan);
VIR_FREE(vlan); g_free(vlan);
} }
int int

2
src/util/virnvme.c
View File

@ -86,7 +86,7 @@ virNVMeDeviceFree(virNVMeDevicePtr dev)
return; return;
virNVMeDeviceUsedByClear(dev); virNVMeDeviceUsedByClear(dev);
VIR_FREE(dev); g_free(dev);
} }

2
src/util/virobject.c
View File

@ -632,7 +632,7 @@ virObjectListFree(void *list)
for (next = (void **) list; *next; next++) for (next = (void **) list; *next; next++)
virObjectUnref(*next); virObjectUnref(*next);
VIR_FREE(list); g_free(list);
} }

18
src/util/virpci.c
View File

@ -1520,11 +1520,11 @@ virPCIDeviceFree(virPCIDevicePtr dev)
if (!dev) if (!dev)
return; return;
VIR_DEBUG("%s %s: freeing", dev->id, dev->name); VIR_DEBUG("%s %s: freeing", dev->id, dev->name);
VIR_FREE(dev->name); g_free(dev->name);
VIR_FREE(dev->path); g_free(dev->path);
VIR_FREE(dev->used_by_drvname); g_free(dev->used_by_drvname);
VIR_FREE(dev->used_by_domname); g_free(dev->used_by_domname);
VIR_FREE(dev); g_free(dev);
} }
/** /**
@ -2819,13 +2819,13 @@ virPCIEDeviceInfoFree(virPCIEDeviceInfoPtr dev)
if (!dev) if (!dev)
return; return;
VIR_FREE(dev->link_cap); g_free(dev->link_cap);
VIR_FREE(dev->link_sta); g_free(dev->link_sta);
VIR_FREE(dev); g_free(dev);
} }
void void
virPCIDeviceAddressFree(virPCIDeviceAddressPtr address) virPCIDeviceAddressFree(virPCIDeviceAddressPtr address)
{ {
VIR_FREE(address); g_free(address);
} }

2
src/util/virperf.c
View File

@ -394,5 +394,5 @@ virPerfFree(virPerfPtr perf)
virPerfEventDisable(perf, i); virPerfEventDisable(perf, i);
} }
VIR_FREE(perf); g_free(perf);
} }

4
src/util/virportallocator.c
View File

@ -117,8 +117,8 @@ virPortAllocatorRangeFree(virPortAllocatorRangePtr range)
if (!range) if (!range)
return; return;
VIR_FREE(range->name); g_free(range->name);
VIR_FREE(range); g_free(range);
} }
static int static int

6
src/util/virresctrl.c
View File

@ -232,7 +232,7 @@ virResctrlInfoMonFree(virResctrlInfoMonPtr mon)
return; return;
g_strfreev(mon->features); g_strfreev(mon->features);
VIR_FREE(mon); g_free(mon);
} }
@ -2752,6 +2752,6 @@ virResctrlMonitorStatsFree(virResctrlMonitorStatsPtr stat)
return; return;
g_strfreev(stat->features); g_strfreev(stat->features);
VIR_FREE(stat->vals); g_free(stat->vals);
VIR_FREE(stat); g_free(stat);
} }

14
src/util/virrotatingfile.c
View File

@ -80,7 +80,7 @@ virRotatingFileWriterEntryFree(virRotatingFileWriterEntryPtr entry)
return; return;
VIR_FORCE_CLOSE(entry->fd); VIR_FORCE_CLOSE(entry->fd);
VIR_FREE(entry); g_free(entry);
} }
@ -90,9 +90,9 @@ virRotatingFileReaderEntryFree(virRotatingFileReaderEntryPtr entry)
if (!entry) if (!entry)
return; return;
VIR_FREE(entry->path); g_free(entry->path);
VIR_FORCE_CLOSE(entry->fd); VIR_FORCE_CLOSE(entry->fd);
VIR_FREE(entry); g_free(entry);
} }
@ -610,8 +610,8 @@ virRotatingFileWriterFree(virRotatingFileWriterPtr file)
return; return;
virRotatingFileWriterEntryFree(file->entry); virRotatingFileWriterEntryFree(file->entry);
VIR_FREE(file->basepath); g_free(file->basepath);
VIR_FREE(file); g_free(file);
} }
@ -631,6 +631,6 @@ virRotatingFileReaderFree(virRotatingFileReaderPtr file)
for (i = 0; i < file->nentries; i++) for (i = 0; i < file->nentries; i++)
virRotatingFileReaderEntryFree(file->entries[i]); virRotatingFileReaderEntryFree(file->entries[i]);
VIR_FREE(file->entries); g_free(file->entries);
VIR_FREE(file); g_free(file);
} }

16
src/util/virscsi.c
View File

@ -222,9 +222,9 @@ virSCSIDeviceNew(const char *sysfs_prefix,
static void static void
virSCSIDeviceUsedByInfoFree(virUsedByInfoPtr used_by) virSCSIDeviceUsedByInfoFree(virUsedByInfoPtr used_by)
{ {
VIR_FREE(used_by->drvname); g_free(used_by->drvname);
VIR_FREE(used_by->domname); g_free(used_by->domname);
VIR_FREE(used_by); g_free(used_by);
} }
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virUsedByInfo, virSCSIDeviceUsedByInfoFree); G_DEFINE_AUTOPTR_CLEANUP_FUNC(virUsedByInfo, virSCSIDeviceUsedByInfoFree);
@ -236,13 +236,13 @@ virSCSIDeviceFree(virSCSIDevicePtr dev)
if (!dev) if (!dev)
return; return;
VIR_FREE(dev->id); g_free(dev->id);
VIR_FREE(dev->name); g_free(dev->name);
VIR_FREE(dev->sg_path); g_free(dev->sg_path);
for (i = 0; i < dev->n_used_by; i++) for (i = 0; i < dev->n_used_by; i++)
virSCSIDeviceUsedByInfoFree(dev->used_by[i]); virSCSIDeviceUsedByInfoFree(dev->used_by[i]);
VIR_FREE(dev->used_by); g_free(dev->used_by);
VIR_FREE(dev); g_free(dev);
} }
int int

10
src/util/virscsivhost.c
View File

@ -268,9 +268,9 @@ virSCSIVHostDeviceFree(virSCSIVHostDevicePtr dev)
if (!dev) if (!dev)
return; return;
VIR_DEBUG("%s: freeing", dev->name); VIR_DEBUG("%s: freeing", dev->name);
VIR_FREE(dev->name); g_free(dev->name);
VIR_FREE(dev->path); g_free(dev->path);
VIR_FREE(dev->used_by_drvname); g_free(dev->used_by_drvname);
VIR_FREE(dev->used_by_domname); g_free(dev->used_by_domname);
VIR_FREE(dev); g_free(dev);
} }

16
src/util/virseclabel.c
View File

@ -34,11 +34,11 @@ virSecurityLabelDefFree(virSecurityLabelDefPtr def)
{ {
if (!def) if (!def)
return; return;
VIR_FREE(def->model); g_free(def->model);
VIR_FREE(def->label); g_free(def->label);
VIR_FREE(def->imagelabel); g_free(def->imagelabel);
VIR_FREE(def->baselabel); g_free(def->baselabel);
VIR_FREE(def); g_free(def);
} }
@ -47,9 +47,9 @@ virSecurityDeviceLabelDefFree(virSecurityDeviceLabelDefPtr def)
{ {
if (!def) if (!def)
return; return;
VIR_FREE(def->model); g_free(def->model);
VIR_FREE(def->label); g_free(def->label);
VIR_FREE(def); g_free(def);
} }

2
src/util/virsocketaddr.c
View File

@ -1307,5 +1307,5 @@ virSocketAddrPTRDomain(const virSocketAddr *addr,
void void
virSocketAddrFree(virSocketAddrPtr addr) virSocketAddrFree(virSocketAddrPtr addr)
{ {
VIR_FREE(addr); g_free(addr);
} }

96
src/util/virsysinfo.c
View File

@ -68,11 +68,11 @@ void virSysinfoBIOSDefFree(virSysinfoBIOSDefPtr def)
if (def == NULL) if (def == NULL)
return; return;
VIR_FREE(def->vendor); g_free(def->vendor);
VIR_FREE(def->version); g_free(def->version);
VIR_FREE(def->date); g_free(def->date);
VIR_FREE(def->release); g_free(def->release);
VIR_FREE(def); g_free(def);
} }
void virSysinfoSystemDefFree(virSysinfoSystemDefPtr def) void virSysinfoSystemDefFree(virSysinfoSystemDefPtr def)
@ -80,14 +80,14 @@ void virSysinfoSystemDefFree(virSysinfoSystemDefPtr def)
if (def == NULL) if (def == NULL)
return; return;
VIR_FREE(def->manufacturer); g_free(def->manufacturer);
VIR_FREE(def->product); g_free(def->product);
VIR_FREE(def->version); g_free(def->version);
VIR_FREE(def->serial); g_free(def->serial);
VIR_FREE(def->uuid); g_free(def->uuid);
VIR_FREE(def->sku); g_free(def->sku);
VIR_FREE(def->family); g_free(def->family);
VIR_FREE(def); g_free(def);
} }
void virSysinfoBaseBoardDefClear(virSysinfoBaseBoardDefPtr def) void virSysinfoBaseBoardDefClear(virSysinfoBaseBoardDefPtr def)
@ -109,12 +109,12 @@ void virSysinfoChassisDefFree(virSysinfoChassisDefPtr def)
if (def == NULL) if (def == NULL)
return; return;
VIR_FREE(def->manufacturer); g_free(def->manufacturer);
VIR_FREE(def->version); g_free(def->version);
VIR_FREE(def->serial); g_free(def->serial);
VIR_FREE(def->asset); g_free(def->asset);
VIR_FREE(def->sku); g_free(def->sku);
VIR_FREE(def); g_free(def);
} }
@ -126,10 +126,10 @@ void virSysinfoOEMStringsDefFree(virSysinfoOEMStringsDefPtr def)
return; return;
for (i = 0; i < def->nvalues; i++) for (i = 0; i < def->nvalues; i++)
VIR_FREE(def->values[i]); g_free(def->values[i]);
VIR_FREE(def->values); g_free(def->values);
VIR_FREE(def); g_free(def);
} }
@ -164,45 +164,45 @@ void virSysinfoDefFree(virSysinfoDefPtr def)
for (i = 0; i < def->nbaseBoard; i++) for (i = 0; i < def->nbaseBoard; i++)
virSysinfoBaseBoardDefClear(def->baseBoard + i); virSysinfoBaseBoardDefClear(def->baseBoard + i);
VIR_FREE(def->baseBoard); g_free(def->baseBoard);
virSysinfoChassisDefFree(def->chassis); virSysinfoChassisDefFree(def->chassis);
for (i = 0; i < def->nprocessor; i++) { for (i = 0; i < def->nprocessor; i++) {
VIR_FREE(def->processor[i].processor_socket_destination); g_free(def->processor[i].processor_socket_destination);
VIR_FREE(def->processor[i].processor_type); g_free(def->processor[i].processor_type);
VIR_FREE(def->processor[i].processor_family); g_free(def->processor[i].processor_family);
VIR_FREE(def->processor[i].processor_manufacturer); g_free(def->processor[i].processor_manufacturer);
VIR_FREE(def->processor[i].processor_signature); g_free(def->processor[i].processor_signature);
VIR_FREE(def->processor[i].processor_version); g_free(def->processor[i].processor_version);
VIR_FREE(def->processor[i].processor_external_clock); g_free(def->processor[i].processor_external_clock);
VIR_FREE(def->processor[i].processor_max_speed); g_free(def->processor[i].processor_max_speed);
VIR_FREE(def->processor[i].processor_status); g_free(def->processor[i].processor_status);
VIR_FREE(def->processor[i].processor_serial_number); g_free(def->processor[i].processor_serial_number);
VIR_FREE(def->processor[i].processor_part_number); g_free(def->processor[i].processor_part_number);
} }
VIR_FREE(def->processor); g_free(def->processor);
for (i = 0; i < def->nmemory; i++) { for (i = 0; i < def->nmemory; i++) {
VIR_FREE(def->memory[i].memory_size); g_free(def->memory[i].memory_size);
VIR_FREE(def->memory[i].memory_form_factor); g_free(def->memory[i].memory_form_factor);
VIR_FREE(def->memory[i].memory_locator); g_free(def->memory[i].memory_locator);
VIR_FREE(def->memory[i].memory_bank_locator); g_free(def->memory[i].memory_bank_locator);
VIR_FREE(def->memory[i].memory_type); g_free(def->memory[i].memory_type);
VIR_FREE(def->memory[i].memory_type_detail); g_free(def->memory[i].memory_type_detail);
VIR_FREE(def->memory[i].memory_speed); g_free(def->memory[i].memory_speed);
VIR_FREE(def->memory[i].memory_manufacturer); g_free(def->memory[i].memory_manufacturer);
VIR_FREE(def->memory[i].memory_serial_number); g_free(def->memory[i].memory_serial_number);
VIR_FREE(def->memory[i].memory_part_number); g_free(def->memory[i].memory_part_number);
} }
VIR_FREE(def->memory); g_free(def->memory);
virSysinfoOEMStringsDefFree(def->oemStrings); virSysinfoOEMStringsDefFree(def->oemStrings);
for (i = 0; i < def->nfw_cfgs; i++) for (i = 0; i < def->nfw_cfgs; i++)
virSysinfoFWCfgDefClear(&def->fw_cfgs[i]); virSysinfoFWCfgDefClear(&def->fw_cfgs[i]);
VIR_FREE(def->fw_cfgs); g_free(def->fw_cfgs);
VIR_FREE(def); g_free(def);
} }

6
src/util/virsystemd.c
View File

@ -640,8 +640,8 @@ virSystemdActivationEntryFree(void *data)
VIR_FORCE_CLOSE(ent->fds[i]); VIR_FORCE_CLOSE(ent->fds[i]);
} }
VIR_FREE(ent->fds); g_free(ent->fds);
VIR_FREE(ent); g_free(ent);
} }
@ -1048,5 +1048,5 @@ virSystemdActivationFree(virSystemdActivationPtr act)
virHashFree(act->fds); virHashFree(act->fds);
VIR_FREE(act); g_free(act);
} }

6
src/util/virthreadpool.c
View File

@ -305,14 +305,14 @@ void virThreadPoolFree(virThreadPoolPtr pool)
virMutexLock(&pool->mutex); virMutexLock(&pool->mutex);
virThreadPoolDrainLocked(pool); virThreadPoolDrainLocked(pool);
VIR_FREE(pool->workers); g_free(pool->workers);
virMutexUnlock(&pool->mutex); virMutexUnlock(&pool->mutex);
virMutexDestroy(&pool->mutex); virMutexDestroy(&pool->mutex);
virCondDestroy(&pool->quit_cond); virCondDestroy(&pool->quit_cond);
virCondDestroy(&pool->cond); virCondDestroy(&pool->cond);
VIR_FREE(pool->prioWorkers); g_free(pool->prioWorkers);
virCondDestroy(&pool->prioCond); virCondDestroy(&pool->prioCond);
VIR_FREE(pool); g_free(pool);
} }

2
src/util/virtypedparam-public.c
View File

@ -880,5 +880,5 @@ virTypedParamsFree(virTypedParameterPtr params,
int nparams) int nparams)
{ {
virTypedParamsClear(params, nparams); virTypedParamsClear(params, nparams);
VIR_FREE(params); g_free(params);
} }

8
src/util/virtypedparam.c
View File

@ -485,11 +485,11 @@ virTypedParamsRemoteFree(virTypedParameterRemotePtr remote_params_val,
return; return;
for (i = 0; i < remote_params_len; i++) { for (i = 0; i < remote_params_len; i++) {
VIR_FREE(remote_params_val[i].field); g_free(remote_params_val[i].field);
if (remote_params_val[i].value.type == VIR_TYPED_PARAM_STRING) if (remote_params_val[i].value.type == VIR_TYPED_PARAM_STRING)
VIR_FREE(remote_params_val[i].value.remote_typed_param_value.s); g_free(remote_params_val[i].value.remote_typed_param_value.s);
} }
VIR_FREE(remote_params_val); g_free(remote_params_val);
} }
@ -724,7 +724,7 @@ virTypedParamListFree(virTypedParamListPtr list)
return; return;
virTypedParamsFree(list->par, list->npar); virTypedParamsFree(list->par, list->npar);
VIR_FREE(list); g_free(list);
} }

20
src/util/viruri.c
View File

@ -279,20 +279,20 @@ void virURIFree(virURIPtr uri)
if (!uri) if (!uri)
return; return;
VIR_FREE(uri->scheme); g_free(uri->scheme);
VIR_FREE(uri->server); g_free(uri->server);
VIR_FREE(uri->user); g_free(uri->user);
VIR_FREE(uri->path); g_free(uri->path);
VIR_FREE(uri->query); g_free(uri->query);
VIR_FREE(uri->fragment); g_free(uri->fragment);
for (i = 0; i < uri->paramsCount; i++) { for (i = 0; i < uri->paramsCount; i++) {
VIR_FREE(uri->params[i].name); g_free(uri->params[i].name);
VIR_FREE(uri->params[i].value); g_free(uri->params[i].value);
} }
VIR_FREE(uri->params); g_free(uri->params);
VIR_FREE(uri); g_free(uri);
} }

8
src/util/virusb.c
View File

@ -354,10 +354,10 @@ virUSBDeviceFree(virUSBDevicePtr dev)
if (!dev) if (!dev)
return; return;
VIR_DEBUG("%s %s: freeing", dev->id, dev->name); VIR_DEBUG("%s %s: freeing", dev->id, dev->name);
VIR_FREE(dev->path); g_free(dev->path);
VIR_FREE(dev->used_by_drvname); g_free(dev->used_by_drvname);
VIR_FREE(dev->used_by_domname); g_free(dev->used_by_domname);
VIR_FREE(dev); g_free(dev);
} }
int int

4
src/util/virxml.c
View File

@ -1312,12 +1312,12 @@ virXMLValidatorFree(virXMLValidatorPtr validator)
if (!validator) if (!validator)
return; return;
VIR_FREE(validator->schemafile); g_free(validator->schemafile);
virBufferFreeAndReset(&validator->buf); virBufferFreeAndReset(&validator->buf);
xmlRelaxNGFreeParserCtxt(validator->rngParser); xmlRelaxNGFreeParserCtxt(validator->rngParser);
xmlRelaxNGFreeValidCtxt(validator->rngValid); xmlRelaxNGFreeValidCtxt(validator->rngValid);
xmlRelaxNGFree(validator->rng); xmlRelaxNGFree(validator->rng);
VIR_FREE(validator); g_free(validator);
} }