virObjectUnref(ch_driver->caps);
virObjectUnref(ch_driver->config);
virMutexDestroy(&ch_driver->lock);
- g_free(ch_driver);
- ch_driver = NULL;
+ g_clear_pointer(&ch_driver, g_free);
return 0;
}
if (virProcessSetAffinity(vm->pid, pcpumap, false) < 0)
goto endjob;
- virBitmapFree(def->cputune.emulatorpin);
- def->cputune.emulatorpin = NULL;
+ g_clear_pointer(&def->cputune.emulatorpin, virBitmapFree);
if (!(def->cputune.emulatorpin = virBitmapNewCopy(pcpumap)))
goto endjob;
vm->def->name, (int)vm->pid, (int)reason);
if (priv->monitor) {
- virCHMonitorClose(priv->monitor);
- priv->monitor = NULL;
+ g_clear_pointer(&priv->monitor, virCHMonitorClose);
}
retry:
if (!machines)
return;
for (i = 0; i < nmachines && machines[i]; i++) {
- virCapabilitiesFreeGuestMachine(machines[i]);
- machines[i] = NULL;
+ g_clear_pointer(&machines[i], virCapabilitiesFreeGuestMachine);
}
g_free(machines);
}
VIR_APPEND_ELEMENT(caps->host.memBW.nodes, caps->host.memBW.nnodes, node);
}
- virCapsHostMemBWNodeFree(node);
- node = NULL;
+ g_clear_pointer(&node, virCapsHostMemBWNodeFree);
}
if (virResctrlInfoGetMonitorPrefix(caps->host.resctrl, prefix,
VIR_APPEND_ELEMENT(caps->host.cache.banks, caps->host.cache.nbanks, bank);
}
- virCapsHostCacheBankFree(bank);
- bank = NULL;
+ g_clear_pointer(&bank, virCapsHostCacheBankFree);
}
if (rv < 0)
goto cleanup;
virDomainHostdevSubsysSCSIClear(virDomainHostdevSubsysSCSI *scsisrc)
{
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
- virObjectUnref(scsisrc->u.iscsi.src);
- scsisrc->u.iscsi.src = NULL;
+ g_clear_pointer(&scsisrc->u.iscsi.src, virObjectUnref);
} else {
VIR_FREE(scsisrc->u.host.adapter);
- virObjectUnref(scsisrc->u.host.src);
- scsisrc->u.host.src = NULL;
+ g_clear_pointer(&scsisrc->u.host.src, virObjectUnref);
}
}
return;
virObjectUnlock(*vm);
- virObjectUnref(*vm);
- *vm = NULL;
+ g_clear_pointer(vm, virObjectUnref);
}
nextBit = virBitmapNextSetBit(def->mem.hugepages[i].nodemask, 0);
if (nextBit < 0) {
- virBitmapFree(def->mem.hugepages[i].nodemask);
- def->mem.hugepages[i].nodemask = NULL;
+ g_clear_pointer(&def->mem.hugepages[i].nodemask,
+ virBitmapFree);
}
}
}
/* if the console source doesn't match */
if (!virDomainChrSourceDefIsEqual(def->serials[0]->source,
def->consoles[0]->source)) {
- virDomainChrDefFree(def->consoles[0]);
- def->consoles[0] = NULL;
+ g_clear_pointer(&def->consoles[0], virDomainChrDefFree);
}
}
vcpu = virDomainDefGetVcpu(def, i);
if (vcpu && !vcpu->online && vcpu->cpumask) {
- virBitmapFree(vcpu->cpumask);
- vcpu->cpumask = NULL;
+ g_clear_pointer(&vcpu->cpumask, virBitmapFree);
VIR_WARN("Ignoring unsupported vcpupin for offline vcpu '%zu'", i);
}
return def;
error:
- virDomainNetDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virDomainNetDefFree);
goto cleanup;
}
if (xmlopt && xmlopt->privateData.chrSourceNew &&
!(def->privateData = xmlopt->privateData.chrSourceNew())) {
- virObjectUnref(def);
- def = NULL;
+ g_clear_pointer(&def, virObjectUnref);
}
return def;
if (xmlopt && xmlopt->privateData.networkNew &&
!(def->privateData = xmlopt->privateData.networkNew())) {
- virDomainNetDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virDomainNetDefFree);
}
return def;
return def;
error:
- virDomainGraphicsDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virDomainGraphicsDefFree);
return NULL;
}
return def;
error:
- virDomainRNGDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virDomainRNGDefFree);
return NULL;
}
if (!def->vendor && !def->version &&
!def->date && !def->release) {
- virSysinfoBIOSDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoBIOSDefFree);
}
*bios = g_steal_pointer(&def);
if (!def->manufacturer && !def->product && !def->version &&
!def->serial && !def->uuid && !def->sku && !def->family) {
- virSysinfoSystemDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoSystemDefFree);
}
*sysdef = g_steal_pointer(&def);
if (!def->manufacturer && !def->version &&
!def->serial && !def->asset && !def->sku) {
- virSysinfoChassisDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoChassisDefFree);
}
*chassisdef = g_steal_pointer(&def);
return -1;
/* prepare to re-use portdef */
- virNetworkPortDefFree(portdef);
- portdef = NULL;
+ g_clear_pointer(&portdef, virNetworkPortDefFree);
if (!(port = virNetworkPortCreateXML(net, portxml, flags)))
return -1;
virStorageNetHostDefFree(src->nhosts, src->hosts);
src->nhosts = 0;
src->hosts = NULL;
- virStorageAuthDefFree(src->auth);
- src->auth = NULL;
+ g_clear_pointer(&src->auth, virStorageAuthDefFree);
switch ((virStoragePoolType) pooldef->type) {
case VIR_STORAGE_POOL_DIR:
{
VIR_FREE(def->name);
VIR_FREE(def->virtPortProfile);
- virNetDevBandwidthFree(def->bandwidth);
+ g_clear_pointer(&def->bandwidth, virNetDevBandwidthFree);
virNetDevVlanClear(&def->vlan);
- def->bandwidth = NULL;
}
/* setting nodeset when placement auto is invalid */
if (placement == VIR_DOMAIN_NUMATUNE_PLACEMENT_AUTO &&
numa->memory.nodeset) {
- virBitmapFree(numa->memory.nodeset);
- numa->memory.nodeset = NULL;
+ g_clear_pointer(&numa->memory.nodeset, virBitmapFree);
}
if (placement != -1)
return ret;
err_exit:
- virNWFilterRuleDefFree(ret);
- ret = NULL;
+ g_clear_pointer(&ret, virNWFilterRuleDefFree);
goto cleanup;
}
virDomainSnapshotDiskDefClear(virDomainSnapshotDiskDef *disk)
{
VIR_FREE(disk->name);
- virObjectUnref(disk->src);
- disk->src = NULL;
+ g_clear_pointer(&disk->src, virObjectUnref);
}
void
VIR_FREE(def->backingStoreRaw);
/* recursively free backing chain */
- virObjectUnref(def->backingStore);
- def->backingStore = NULL;
+ g_clear_pointer(&def->backingStore, virObjectUnref);
}
return;
virObjectUnlock(*obj);
- virObjectUnref(*obj);
- *obj = NULL;
+ g_clear_pointer(obj, virObjectUnref);
}
return;
virObjectUnlock(*obj);
- virObjectUnref(*obj);
- *obj = NULL;
+ g_clear_pointer(obj, virObjectUnref);
}
void
virNetworkObjUnrefMacMap(virNetworkObj *obj)
{
- virObjectUnref(obj->macmap);
- obj->macmap = NULL;
+ g_clear_pointer(&obj->macmap, virObjectUnref);
}
return;
virObjectUnlock(*obj);
- virObjectUnref(*obj);
- *obj = NULL;
+ g_clear_pointer(obj, virObjectUnref);
}
return;
virObjectUnlock(*obj);
- virObjectUnref(*obj);
- *obj = NULL;
+ g_clear_pointer(obj, virObjectUnref);
}
return;
virObjectUnlock(*obj);
- virObjectUnref(*obj);
- *obj = NULL;
+ g_clear_pointer(obj, virObjectUnref);
}
if (virSecretLoadValue(obj) < 0) {
virSecretObjListRemove(secrets, obj);
- virObjectUnref(obj);
- obj = NULL;
+ g_clear_pointer(&obj, virObjectUnref);
}
cleanup:
return;
virObjectUnlock(*obj);
- virObjectUnref(*obj);
- *obj = NULL;
+ g_clear_pointer(obj, virObjectUnref);
}
return;
virObjectUnlock(*obj);
- virObjectUnref(*obj);
- *obj = NULL;
+ g_clear_pointer(obj, virObjectUnref);
}
closeData->freeCallback = NULL;
closeData->opaque = NULL;
- virObjectUnref(closeData->conn);
- closeData->conn = NULL;
+ g_clear_pointer(&closeData->conn, virObjectUnref);
}
/**
if (cbdata->freeCallback)
cbdata->freeCallback(cbdata->opaque);
- virObjectUnref(cbdata->conn);
- cbdata->conn = NULL;
+ g_clear_pointer(&cbdata->conn, virObjectUnref);
cbdata->freeCallback = NULL;
cbdata->callback = NULL;
cbdata->opaque = NULL;
enumContext = wsmc_get_enum_context(response);
- ws_xml_destroy_doc(response);
- response = NULL;
+ g_clear_pointer(&response, ws_xml_destroy_doc);
while (enumContext != NULL && *enumContext != '\0') {
XML_TYPE_PTR data = NULL;
VIR_FREE(enumContext);
enumContext = wsmc_get_enum_context(response);
- ws_xml_destroy_doc(response);
- response = NULL;
+ g_clear_pointer(&response, ws_xml_destroy_doc);
}
*list = g_steal_pointer(&head);
return VIR_DRV_STATE_INIT_COMPLETE;
error:
- virObjectUnref(driver);
- driver = NULL;
+ g_clear_pointer(&driver, virObjectUnref);
return VIR_DRV_STATE_INIT_ERROR;
}
if (!driver)
return -1;
- virObjectUnref(driver);
- driver = NULL;
+ g_clear_pointer(&driver, virObjectUnref);
return 0;
}
goto cleanup;
if (!virConnectListAllInterfacesCheckACL(conn, def)) {
- ncf_if_free(iface);
- iface = NULL;
+ g_clear_pointer(&iface, ncf_if_free);
continue;
}
}
niface_objs++;
- ncf_if_free(iface);
- iface = NULL;
+ g_clear_pointer(&iface, ncf_if_free);
}
if (tmp_iface_objs) {
if (err &&
err->domain == VIR_FROM_QEMU &&
err->code != VIR_ERR_MIGRATE_FINISH_OK) {
- virFreeError(orig_err);
- orig_err = NULL;
+ g_clear_pointer(&orig_err, virFreeError);
}
}
}
for (i = 0; cpus && i < nr_nodes; i++)
VIR_FREE(cpus[i]);
if (caps->host.numa) {
- virCapabilitiesHostNUMAUnref(caps->host.numa);
- caps->host.numa = NULL;
+ g_clear_pointer(&caps->host.numa, virCapabilitiesHostNUMAUnref);
}
VIR_FREE(distances);
}
for (i = 0; i < nsocks; i++) {
virNetSocketRemoveIOCallback(socks[i]);
virNetSocketClose(socks[i]);
- virObjectUnref(socks[i]);
- socks[i] = NULL;
+ g_clear_pointer(&socks[i], virObjectUnref);
}
args->nsocks = 0;
VIR_FORCE_CLOSE(recvfd);
for (i = 0; i < nsocks; i++) {
virNetSocketUpdateIOCallback(socks[i], 0);
virNetSocketRemoveIOCallback(socks[i]);
- virNetSocketClose(socks[i]);
- socks[i] = NULL;
+ g_clear_pointer(&socks[i], virNetSocketClose);
}
args->nsocks = 0;
VIR_FORCE_CLOSE(recvfd);
if (virNetDaemonAddServer(lockd->dmn, srv) < 0)
goto error;
- virObjectUnref(srv);
- srv = NULL;
+ g_clear_pointer(&srv, virObjectUnref);
if (!(srv = virNetServerNew("admin", 1,
0, 0, 0, config->admin_max_clients,
if (virNetDaemonAddServer(lockd->dmn, srv) < 0)
goto error;
- virObjectUnref(srv);
- srv = NULL;
+ g_clear_pointer(&srv, virObjectUnref);
lockd->lockspaces = virHashNew(virLockDaemonLockSpaceDataFree);
if (!lock)
return;
- virLockManagerLockDaemonPrivateFree(lock->privateData);
- lock->privateData = NULL;
+ g_clear_pointer(&lock->privateData, virLockManagerLockDaemonPrivateFree);
}
if (virNetDaemonAddServer(logd->dmn, srv) < 0)
goto error;
- virObjectUnref(srv);
- srv = NULL;
+ g_clear_pointer(&srv, virObjectUnref);
if (!(srv = virNetServerNew("admin", 1,
0, 0, 0, config->admin_max_clients,
if (virNetDaemonAddServer(logd->dmn, srv) < 0)
goto error;
- virObjectUnref(srv);
- srv = NULL;
+ g_clear_pointer(&srv, virObjectUnref);
if (!(logd->handler = virLogHandlerNew(privileged,
config->max_size,
return ctrl;
error:
- virLXCControllerFree(ctrl);
- ctrl = NULL;
+ g_clear_pointer(&ctrl, virLXCControllerFree);
goto cleanup;
}
if (virNetServerAddService(srv, svc) < 0)
goto error;
- virObjectUnref(svc);
- svc = NULL;
+ g_clear_pointer(&svc, virObjectUnref);
if (!(ctrl->prog = virNetServerProgramNew(VIR_LXC_MONITOR_PROGRAM,
VIR_LXC_MONITOR_PROGRAM_VERSION,
error:
virObjectUnref(srv);
- virObjectUnref(ctrl->daemon);
- ctrl->daemon = NULL;
+ g_clear_pointer(&ctrl->daemon, virObjectUnref);
virObjectUnref(svc);
return -1;
}
cleanup:
if (ret != 0) {
VIR_FORCE_CLOSE(*ttyprimary);
- g_free(*ttyName);
- *ttyName = NULL;
+ g_clear_pointer(ttyName, g_free);
}
return ret;
lxcDomainInitctlCallback,
&data);
cleanup:
- g_free(data.st);
- data.st = NULL;
- g_free(data.st_valid);
- data.st_valid = NULL;
+ g_clear_pointer(&data.st, g_free);
+ g_clear_pointer(&data.st_valid, g_free);
return ret;
}
lxc_driver = g_new0(virLXCDriver, 1);
lxc_driver->lockFD = -1;
if (virMutexInit(&lxc_driver->lock) < 0) {
- g_free(lxc_driver);
- lxc_driver = NULL;
+ g_clear_pointer(&lxc_driver, g_free);
return VIR_DRV_STATE_INIT_ERROR;
}
virObjectUnref(lxc_driver->config);
virMutexDestroy(&lxc_driver->lock);
- g_free(lxc_driver);
- lxc_driver = NULL;
+ g_clear_pointer(&lxc_driver, g_free);
return 0;
}
{
virMutexLock(&fuse->lock);
fuse_unmount(fuse->mountpoint, fuse->ch);
- fuse_destroy(fuse->fuse);
- fuse->fuse = NULL;
+ g_clear_pointer(&fuse->fuse, fuse_destroy);
virMutexUnlock(&fuse->lock);
}
error:
for (i = 0; i < data->nips; i++)
g_free(data->ips[i]);
- g_free(data->ips);
- data->ips = NULL;
+ g_clear_pointer(&data->ips, g_free);
virDomainNetDefFree(net);
virDomainHostdevDefFree(hostdev);
return -1;
cleanup:
for (i = 0; i < networks.ndata; i++)
g_free(networks.parseData[i]);
- g_free(networks.parseData);
- networks.parseData = NULL;
+ g_clear_pointer(&networks.parseData, g_free);
return ret;
error:
lxcNetworkParseData *data = networks.parseData[i];
for (j = 0; j < data->nips; j++)
g_free(data->ips[j]);
- g_free(data->ips);
- data->ips = NULL;
+ g_clear_pointer(&data->ips, g_free);
}
goto cleanup;
}
size = size / 1024;
virDomainDefSetMemoryTotal(def, size);
def->mem.hard_limit = virMemoryLimitTruncate(size);
- g_free(value);
- value = NULL;
+ g_clear_pointer(&value, g_free);
}
if (virConfGetValueString(properties,
if (lxcConvertSize(value, &size) < 0)
return -1;
def->mem.soft_limit = virMemoryLimitTruncate(size / 1024);
- g_free(value);
- value = NULL;
+ g_clear_pointer(&value, g_free);
}
if (virConfGetValueString(properties,
if (virStrToLong_ull(value, NULL, 10, &def->cputune.shares) < 0)
goto error;
def->cputune.sharesSpecified = true;
- g_free(value);
- value = NULL;
+ g_clear_pointer(&value, g_free);
}
if (virConfGetValueString(properties, "lxc.cgroup.cpu.cfs_quota_us",
&value) > 0) {
if (virStrToLong_ll(value, NULL, 10, &def->cputune.quota) < 0)
goto error;
- g_free(value);
- value = NULL;
+ g_clear_pointer(&value, g_free);
}
if (virConfGetValueString(properties, "lxc.cgroup.cpu.cfs_period_us",
else if (arch == VIR_ARCH_NONE && STREQ(value, "amd64"))
arch = VIR_ARCH_X86_64;
vmdef->os.arch = arch;
- g_free(value);
- value = NULL;
+ g_clear_pointer(&value, g_free);
}
vmdef->os.init = g_strdup("/sbin/init");
/* Clear out dynamically assigned labels */
if (vm->def->nseclabels &&
vm->def->seclabels[0]->type == VIR_DOMAIN_SECLABEL_DYNAMIC) {
- g_free(vm->def->seclabels[0]->model);
- g_free(vm->def->seclabels[0]->label);
- g_free(vm->def->seclabels[0]->imagelabel);
- vm->def->seclabels[0]->model = NULL;
- vm->def->seclabels[0]->label = NULL;
- vm->def->seclabels[0]->imagelabel = NULL;
+ g_clear_pointer(&vm->def->seclabels[0]->model, g_free);
+ g_clear_pointer(&vm->def->seclabels[0]->label, g_free);
+ g_clear_pointer(&vm->def->seclabels[0]->imagelabel, g_free);
}
/* Stop autodestroy in case guest is restarted */
if (priv->monitor) {
virLXCMonitorClose(priv->monitor);
- virObjectUnref(priv->monitor);
- priv->monitor = NULL;
+ g_clear_pointer(&priv->monitor, virObjectUnref);
}
virPidFileDelete(cfg->stateDir, vm->def->name);
if (priv->cgroup) {
virCgroupRemove(priv->cgroup);
- virCgroupFree(priv->cgroup);
- priv->cgroup = NULL;
+ g_clear_pointer(&priv->cgroup, virCgroupFree);
}
/* Get machined to terminate the machine as it may not have cleaned it
* the bug we are working around here.
*/
virCgroupTerminateMachine(priv->machineName);
- g_free(priv->machineName);
- priv->machineName = NULL;
+ g_clear_pointer(&priv->machineName, g_free);
/* The "release" hook cleans up additional resources */
if (virHookPresent(VIR_HOOK_DRIVER_LXC)) {
size_t i;
for (i = 0; i < def->nnets; i++) {
- g_free(def->nets[i]->ifname_guest_actual);
- def->nets[i]->ifname_guest_actual = NULL;
+ g_clear_pointer(&def->nets[i]->ifname_guest_actual, g_free);
VIR_DEBUG("Cleared net names: %s", def->nets[i]->ifname_guest);
}
}
VIR_DEBUG("Setting up global firewall chains");
- virFreeError(errInitV4);
- errInitV4 = NULL;
- virFreeError(errInitV6);
- errInitV6 = NULL;
+ g_clear_pointer(&errInitV4, virFreeError);
+ g_clear_pointer(&errInitV6, virFreeError);
rc = iptablesSetupPrivateChains(VIR_FIREWALL_LAYER_IPV4);
if (rc < 0) {
}
if (++errcount > PCAP_READ_MAXERRS) {
- pcap_close(pcapConf[i].handle);
- pcapConf[i].handle = NULL;
+ g_clear_pointer(&pcapConf[i].handle, pcap_close);
/* protect req->binding->portdevname */
virNWFilterSnoopReqLock(req);
virNWFilterSnoopReqPut(req);
return 0;
}
- virNWFilterBindingDefFree(req->binding);
- req->binding = NULL;
+ g_clear_pointer(&req->binding, virNWFilterBindingDefFree);
} else {
req = virNWFilterSnoopReqNew(ifkey);
if (!req)
if (virNWFilterInstantiateFilter(driver, def) < 0) {
virNWFilterBindingObjListRemove(driver->bindings, obj);
- virObjectUnref(ret);
- ret = NULL;
+ g_clear_pointer(&ret, virObjectUnref);
goto cleanup;
}
virNWFilterBindingObjSave(obj, driver->bindingDir);
qemuAgentUnregister(qemuAgent *agent)
{
if (agent->watch) {
- g_source_destroy(agent->watch);
vir_g_source_unref(agent->watch, agent->context);
- agent->watch = NULL;
+ g_clear_pointer(&agent->watch, g_source_destroy);
}
}
if (agent->socket) {
qemuAgentUnregister(agent);
- g_object_unref(agent->socket);
- agent->socket = NULL;
+ g_clear_pointer(&agent->socket, g_object_unref);
agent->fd = -1;
}
qemuDomainEventEmitJobCompleted(priv->driver, vm);
}
- virDomainBackupDefFree(priv->backup);
- priv->backup = NULL;
+ g_clear_pointer(&priv->backup, virDomainBackupDefFree);
if (priv->job.asyncJob == QEMU_ASYNC_JOB_BACKUP)
qemuDomainObjEndAsyncJob(priv->driver, vm);
diskPriv = QEMU_DOMAIN_DISK_PRIVATE(job->disk);
if (job == diskPriv->blockjob) {
- virObjectUnref(diskPriv->blockjob);
- diskPriv->blockjob = NULL;
+ g_clear_pointer(&diskPriv->blockjob, virObjectUnref);
}
job->disk = NULL;
/* discard any detected backing store */
if (virStorageSourceIsBacking(n->backingStore) &&
n->backingStore->detected) {
- virObjectUnref(n->backingStore);
- n->backingStore = NULL;
+ g_clear_pointer(&n->backingStore, virObjectUnref);
break;
}
}
* Remove security driver metadata so that they are not leaked. */
qemuBlockRemoveImageMetadata(driver, vm, disk->dst, disk->mirror);
- virObjectUnref(disk->mirror);
- disk->mirror = NULL;
+ g_clear_pointer(&disk->mirror, virObjectUnref);
}
disk->mirrorState = VIR_DOMAIN_DISK_MIRROR_STATE_NONE;
disk->mirrorJob = VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN;
if (!virStorageSourceIsSameLocation(disk->src, cfgdisk->src))
return;
- virObjectUnref(cfgdisk->src->backingStore);
- cfgdisk->src->backingStore = NULL;
+ g_clear_pointer(&cfgdisk->src->backingStore, virObjectUnref);
}
if (job->data.commit.deleteCommittedImages)
qemuBlockJobDeleteImages(driver, vm, job->disk, job->data.commit.top);
- virObjectUnref(job->data.commit.top);
- job->data.commit.top = NULL;
+ g_clear_pointer(&job->data.commit.top, virObjectUnref);
if (cfgbaseparent) {
cfgbase = g_steal_pointer(&cfgbaseparent->backingStore);
if (job->data.commit.deleteCommittedImages)
qemuBlockJobDeleteImages(driver, vm, job->disk, job->data.commit.top);
- virObjectUnref(job->data.commit.top);
- job->data.commit.top = NULL;
+ g_clear_pointer(&job->data.commit.top, virObjectUnref);
/* the mirror element does not serve functional purpose for the commit job */
- virObjectUnref(job->disk->mirror);
- job->disk->mirror = NULL;
+ g_clear_pointer(&job->disk->mirror, virObjectUnref);
}
/* activeWrite bitmap is removed automatically here */
qemuBlockJobEventProcessConcludedRemoveChain(driver, vm, asyncJob, job->disk->mirror);
- virObjectUnref(job->disk->mirror);
- job->disk->mirror = NULL;
+ g_clear_pointer(&job->disk->mirror, virObjectUnref);
}
* not leaking security driver metadata is more important. */
qemuBlockRemoveImageMetadata(driver, vm, disk->dst, disk->mirror);
- virObjectUnref(disk->mirror);
- disk->mirror = NULL;
+ g_clear_pointer(&disk->mirror, virObjectUnref);
}
* it will handle further hotplug of the created volume and also that
* the 'chain' which was registered is under their control */
if (job->synchronous) {
- virObjectUnref(job->chain);
- job->chain = NULL;
+ g_clear_pointer(&job->chain, virObjectUnref);
return;
}
priv->spiceMigration = false;
priv->spiceMigrated = false;
priv->dumpCompleted = false;
- qemuMigrationParamsFree(priv->migParams);
- priv->migParams = NULL;
+ g_clear_pointer(&priv->migParams, qemuMigrationParamsFree);
}
void
qemuDomainObjPrivateDataClear(qemuDomainObjPrivate *priv)
{
- g_strfreev(priv->qemuDevices);
- priv->qemuDevices = NULL;
-
- virCgroupFree(priv->cgroup);
- priv->cgroup = NULL;
-
- virPerfFree(priv->perf);
- priv->perf = NULL;
+ g_clear_pointer(&priv->qemuDevices, g_strfreev);
+ g_clear_pointer(&priv->cgroup, virCgroupFree);
+ g_clear_pointer(&priv->perf, virPerfFree);
VIR_FREE(priv->machineName);
- virObjectUnref(priv->qemuCaps);
- priv->qemuCaps = NULL;
+ g_clear_pointer(&priv->qemuCaps, virObjectUnref);
VIR_FREE(priv->pidfile);
priv->memPrealloc = false;
/* remove automatic pinning data */
- virBitmapFree(priv->autoNodeset);
- priv->autoNodeset = NULL;
- virBitmapFree(priv->autoCpuset);
- priv->autoCpuset = NULL;
-
- /* remove address data */
- virDomainPCIAddressSetFree(priv->pciaddrs);
- priv->pciaddrs = NULL;
- virDomainUSBAddressSetFree(priv->usbaddrs);
- priv->usbaddrs = NULL;
-
- virCPUDefFree(priv->origCPU);
- priv->origCPU = NULL;
-
- /* clear previously used namespaces */
- virBitmapFree(priv->namespaces);
- priv->namespaces = NULL;
+ g_clear_pointer(&priv->autoNodeset, virBitmapFree);
+ g_clear_pointer(&priv->autoCpuset, virBitmapFree);
+ g_clear_pointer(&priv->pciaddrs, virDomainPCIAddressSetFree);
+ g_clear_pointer(&priv->usbaddrs, virDomainUSBAddressSetFree);
+ g_clear_pointer(&priv->origCPU, virCPUDefFree);
+ g_clear_pointer(&priv->namespaces, virBitmapFree);
priv->rememberOwner = false;
priv->reconnectBlockjobs = VIR_TRISTATE_BOOL_ABSENT;
priv->allowReboot = VIR_TRISTATE_BOOL_ABSENT;
- virBitmapFree(priv->migrationCaps);
- priv->migrationCaps = NULL;
+ g_clear_pointer(&priv->migrationCaps, virBitmapFree);
virHashRemoveAll(priv->blockjobs);
- virObjectUnref(priv->pflash0);
- priv->pflash0 = NULL;
- virObjectUnref(priv->pflash1);
- priv->pflash1 = NULL;
-
- virDomainBackupDefFree(priv->backup);
- priv->backup = NULL;
+ g_clear_pointer(&priv->pflash0, virObjectUnref);
+ g_clear_pointer(&priv->pflash1, virObjectUnref);
+ g_clear_pointer(&priv->backup, virDomainBackupDefFree);
/* reset node name allocator */
qemuDomainStorageIdReset(priv);
if (priv->namespaces &&
virBitmapIsAllClear(priv->namespaces)) {
- virBitmapFree(priv->namespaces);
- priv->namespaces = NULL;
+ g_clear_pointer(&priv->namespaces, virBitmapFree);
}
priv->rememberOwner = virXPathBoolean("count(./rememberOwner) > 0", ctxt);
return 0;
error:
- virBitmapFree(priv->namespaces);
- priv->namespaces = NULL;
- virObjectUnref(priv->monConfig);
- priv->monConfig = NULL;
- g_strfreev(priv->qemuDevices);
- priv->qemuDevices = NULL;
+ g_clear_pointer(&priv->namespaces, virBitmapFree);
+ g_clear_pointer(&priv->monConfig, virObjectUnref);
+ g_clear_pointer(&priv->qemuDevices, g_strfreev);
return -1;
}
if (virDomainAudioIsEqual(def->audios[0], audio)) {
virDomainAudioDefFree(def->audios[0]);
- g_free(def->audios);
+ g_clear_pointer(&def->audios, g_free);
def->naudios = 0;
- def->audios = NULL;
}
virDomainAudioDefFree(audio);
}
nbuses = addrs->nbuses;
- virDomainPCIAddressSetFree(addrs);
- addrs = NULL;
+ g_clear_pointer(&addrs, virDomainPCIAddressSetFree);
}
if (!(addrs = qemuDomainPCIAddressSetCreate(def, qemuCaps, nbuses, false)))
goto endjob;
} else {
if (priv->agent) {
- qemuAgentClose(priv->agent);
- priv->agent = NULL;
+ g_clear_pointer(&priv->agent, qemuAgentClose);
}
priv->agentError = false;
}
_("domain has no watchdog"));
return -1;
}
- virDomainWatchdogDefFree(vmdef->watchdog);
- vmdef->watchdog = NULL;
+ g_clear_pointer(&vmdef->watchdog, virDomainWatchdogDefFree);
break;
case VIR_DOMAIN_DEVICE_INPUT:
_("matching vsock device not found"));
return -1;
}
- virDomainVsockDefFree(vmdef->vsock);
- vmdef->vsock = NULL;
+ g_clear_pointer(&vmdef->vsock, virDomainVsockDefFree);
break;
case VIR_DOMAIN_DEVICE_VIDEO:
ignore_value(qemuDomainStorageSourceChainAccessRevoke(driver, vm, oldsrc));
/* media was changed, so we can remove the old media definition now */
- virObjectUnref(oldsrc);
- oldsrc = NULL;
+ g_clear_pointer(&oldsrc, virObjectUnref);
ret = 0;
if (diskPriv->blockjob) {
/* the block job keeps reference to the disk chain */
diskPriv->blockjob->disk = NULL;
- virObjectUnref(diskPriv->blockjob);
- diskPriv->blockjob = NULL;
+ g_clear_pointer(&diskPriv->blockjob, virObjectUnref);
} else {
if (!(diskBackend = qemuBlockStorageSourceChainDetachPrepareBlockdev(disk->src)))
goto cleanup;
watchdog->info.alias, vm, vm->def->name);
qemuDomainReleaseDeviceAddress(vm, &watchdog->info);
- virDomainWatchdogDefFree(vm->def->watchdog);
- vm->def->watchdog = NULL;
+ g_clear_pointer(&vm->def->watchdog, virDomainWatchdogDefFree);
return 0;
}
dev->info.alias, vm, vm->def->name);
qemuDomainReleaseDeviceAddress(vm, &dev->info);
- virDomainVsockDefFree(vm->def->vsock);
- vm->def->vsock = NULL;
+ g_clear_pointer(&vm->def->vsock, virDomainVsockDefFree);
return 0;
}
qemuBlockStorageSourceDetachOneBlockdev(driver, vm, asyncJob,
diskPriv->migrSource);
- virObjectUnref(diskPriv->migrSource);
- diskPriv->migrSource = NULL;
+ g_clear_pointer(&diskPriv->migrSource, virObjectUnref);
}
ret = failed ? -1 : 0;
abrt:
virErrorPreserveLast(&err);
if (err && err->code == VIR_ERR_OK) {
- virFreeError(err);
- err = NULL;
+ g_clear_pointer(&err, virFreeError);
}
virStreamAbort(data->st);
virErrorRestore(&err);
if (err &&
err->domain == VIR_FROM_QEMU &&
err->code != VIR_ERR_MIGRATE_FINISH_OK) {
- virFreeError(orig_err);
- orig_err = NULL;
+ g_clear_pointer(&orig_err, virFreeError);
}
}
}
qemuMonitorUnregister(qemuMonitor *mon)
{
if (mon->watch) {
- g_source_destroy(mon->watch);
vir_g_source_unref(mon->watch, mon->context);
- mon->watch = NULL;
+ g_clear_pointer(&mon->watch, g_source_destroy);
}
}
if (mon->socket) {
qemuMonitorUnregister(mon);
- g_object_unref(mon->socket);
- mon->socket = NULL;
+ g_clear_pointer(&mon->socket, g_object_unref);
mon->fd = -1;
}
VIR_FREE(cpus[i].qom_path);
VIR_FREE(cpus[i].alias);
VIR_FREE(cpus[i].type);
- virJSONValueFree(cpus[i].props);
- cpus[i].props = NULL;
+ g_clear_pointer(&cpus[i].props, virJSONValueFree);
}
}
if (priv->namespaces) {
ignore_value(virBitmapClearBit(priv->namespaces, ns));
if (virBitmapIsAllClear(priv->namespaces)) {
- virBitmapFree(priv->namespaces);
- priv->namespaces = NULL;
+ g_clear_pointer(&priv->namespaces, virBitmapFree);
}
}
}
priv->nbdPort = 0;
if (priv->agent) {
- qemuAgentClose(priv->agent);
- priv->agent = NULL;
+ g_clear_pointer(&priv->agent, qemuAgentClose);
}
priv->agentError = false;
if (priv->mon) {
- qemuMonitorClose(priv->mon);
- priv->mon = NULL;
+ g_clear_pointer(&priv->mon, qemuMonitorClose);
}
if (priv->monConfig) {
if (priv->monConfig->type == VIR_DOMAIN_CHR_TYPE_UNIX)
unlink(priv->monConfig->data.nix.path);
- virObjectUnref(priv->monConfig);
- priv->monConfig = NULL;
+ g_clear_pointer(&priv->monConfig, virObjectUnref);
}
qemuDomainObjStopWorker(vm);
for (i = 0; i < vm->ndeprecations; i++)
g_free(vm->deprecations[i]);
- g_free(vm->deprecations);
+ g_clear_pointer(&vm->deprecations, g_free);
vm->ndeprecations = 0;
- vm->deprecations = NULL;
vm->taint = 0;
vm->pid = -1;
virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason);
{
if (proc->mon) {
virObjectUnlock(proc->mon);
- qemuMonitorClose(proc->mon);
- proc->mon = NULL;
+ g_clear_pointer(&proc->mon, qemuMonitorClose);
}
if (proc->cmd) {
virCommandAbort(proc->cmd);
- virCommandFree(proc->cmd);
- proc->cmd = NULL;
+ g_clear_pointer(&proc->cmd, virCommandFree);
}
if (proc->monpath)
error:
if (*conn) {
- virConnectClose(*conn);
- *conn = NULL;
+ g_clear_pointer(conn, virConnectClose);
}
goto cleanup;
}
if (rv < 0) {
virNetMessageSaveError(rerr);
if (priv->conn) {
- virObjectUnref(priv->conn);
- priv->conn = NULL;
+ g_clear_pointer(&priv->conn, virObjectUnref);
}
}
virMutexUnlock(&priv->lock);
"client=%p auth=%d identity=%s",
client, REMOTE_AUTH_SASL, identity);
- virObjectUnref(priv->sasl);
- priv->sasl = NULL;
+ g_clear_pointer(&priv->sasl, virObjectUnref);
return 0;
}
goto error;
error:
- virObjectUnref(priv->sasl);
- priv->sasl = NULL;
+ g_clear_pointer(&priv->sasl, virObjectUnref);
virResetLastError();
virReportError(VIR_ERR_AUTH_FAILED, "%s",
_("authentication failed"));
goto error;
error:
- virObjectUnref(priv->sasl);
- priv->sasl = NULL;
+ g_clear_pointer(&priv->sasl, virObjectUnref);
virResetLastError();
virReportError(VIR_ERR_AUTH_FAILED, "%s",
_("authentication failed"));
virObjectUnref(priv->lxcProgram);
virObjectUnref(priv->qemuProgram);
virNetClientClose(priv->client);
- virObjectUnref(priv->client);
- priv->client = NULL;
- virObjectUnref(priv->closeCallback);
- priv->closeCallback = NULL;
- virObjectUnref(priv->tls);
- priv->tls = NULL;
+ g_clear_pointer(&priv->client, virObjectUnref);
+ g_clear_pointer(&priv->closeCallback, virObjectUnref);
+ g_clear_pointer(&priv->tls, virObjectUnref);
VIR_FREE(priv->hostname);
return VIR_DRV_OPEN_ERROR;
(xdrproc_t) xdr_void, (char *) NULL) == -1)
ret = -1;
- virObjectUnref(priv->tls);
- priv->tls = NULL;
+ g_clear_pointer(&priv->tls, virObjectUnref);
virNetClientSetCloseCallback(priv->client,
NULL,
priv->closeCallback, virObjectFreeCallback);
virNetClientClose(priv->client);
- virObjectUnref(priv->client);
- priv->client = NULL;
- virObjectUnref(priv->closeCallback);
- priv->closeCallback = NULL;
+ g_clear_pointer(&priv->client, virObjectUnref);
+ g_clear_pointer(&priv->closeCallback, virObjectUnref);
virObjectUnref(priv->remoteProgram);
virObjectUnref(priv->lxcProgram);
virObjectUnref(priv->qemuProgram);
/* See comment for remoteType. */
VIR_FREE(priv->type);
- virObjectUnref(priv->eventState);
- priv->eventState = NULL;
+ g_clear_pointer(&priv->eventState, virObjectUnref);
return ret;
}
if (proxy->sock) {
virNetSocketRemoveIOCallback(proxy->sock);
virNetSocketClose(proxy->sock);
- virObjectUnref(proxy->sock);
- proxy->sock = NULL;
+ g_clear_pointer(&proxy->sock, virObjectUnref);
}
VIR_FREE(proxy->sockToTerminal.data);
VIR_FREE(proxy->terminalToSock.data);
if (!client->sock)
return;
- virObjectUnref(client->sock);
- client->sock = NULL;
- virObjectUnref(client->tls);
- client->tls = NULL;
+ g_clear_pointer(&client->sock, virObjectUnref);
+ g_clear_pointer(&client->tls, virObjectUnref);
#if WITH_SASL
- virObjectUnref(client->sasl);
- client->sasl = NULL;
+ g_clear_pointer(&client->sasl, virObjectUnref);
#endif
ka = g_steal_pointer(&client->keepalive);
client->wantClose = false;
- virFreeError(client->error);
- client->error = NULL;
+ g_clear_pointer(&client->error, virFreeError);
if (ka || client->closeCb) {
virNetClientCloseFunc closeCb = client->closeCb;
return 0;
error:
- virObjectUnref(client->tls);
- client->tls = NULL;
+ g_clear_pointer(&client->tls, virObjectUnref);
virObjectUnlock(client);
return -1;
}
virNetSocketRemoveIOCallback(client->sock);
if (client->tls) {
- virObjectUnref(client->tls);
- client->tls = NULL;
+ g_clear_pointer(&client->tls, virObjectUnref);
}
client->wantClose = true;
}
if (client->sock) {
- virObjectUnref(client->sock);
- client->sock = NULL;
+ g_clear_pointer(&client->sock, virObjectUnref);
}
}
msg->header.type, msg->header.status, msg->header.serial);
if (virKeepAliveCheckMessage(client->keepalive, msg, &response)) {
- virNetMessageFree(msg);
+ g_clear_pointer(&msg, virNetMessageFree);
client->nrequests--;
- msg = NULL;
if (response &&
virNetServerClientSendMessageLocked(client, response) < 0)
while (filter) {
int ret = filter->func(client, msg, filter->opaque);
if (ret < 0) {
- virNetMessageFree(msg);
- msg = NULL;
+ g_clear_pointer(&msg, virNetMessageFree);
client->wantClose = true;
break;
}
*/
if (client->sasl) {
virNetSocketSetSASLSession(client->sock, client->sasl);
- virObjectUnref(client->sasl);
- client->sasl = NULL;
+ g_clear_pointer(&client->sasl, virObjectUnref);
}
#endif
cleanup:
if (ret != 0) {
- gnutls_x509_crt_deinit(cert);
- cert = NULL;
+ g_clear_pointer(&cert, gnutls_x509_crt_deinit);
}
VIR_FREE(buf);
return cert;
def = g_steal_pointer(&objDef);
} else {
virSecretObjListRemove(driver->secrets, obj);
- virObjectUnref(obj);
- obj = NULL;
+ g_clear_pointer(&obj, virObjectUnref);
}
cleanup:
virSecretObjDeleteData(obj);
virSecretObjListRemove(driver->secrets, obj);
- virObjectUnref(obj);
- obj = NULL;
+ g_clear_pointer(&obj, virObjectUnref);
ret = 0;
if (!sec_managers[i]->drv->domainGenSecurityLabel) {
virReportUnsupportedError();
- virSecurityLabelDefFree(seclabel);
- seclabel = NULL;
+ g_clear_pointer(&seclabel, virSecurityLabelDefFree);
} else {
/* The seclabel must be added to @vm prior calling domainGenSecurityLabel
* which may require seclabel to be presented already */
return 0;
error:
- selabel_close(data->label_handle);
- data->label_handle = NULL;
+ g_clear_pointer(&data->label_handle, selabel_close);
VIR_FREE(data->domain_context);
VIR_FREE(data->file_context);
VIR_FREE(data->content_context);
return 0;
error:
- selabel_close(data->label_handle);
- data->label_handle = NULL;
+ g_clear_pointer(&data->label_handle, selabel_close);
VIR_FREE(data->domain_context);
VIR_FREE(data->alt_domain_context);
VIR_FREE(data->file_context);
if (inq->device_type == SCSI_INQUIRY_PERIPHERAL_DEVICE_TYPE_DIRECT_ACCESS) {
struct scsi_readcapacity16 *rc16 = NULL;
- scsi_free_scsi_task(task);
- task = NULL;
+ g_clear_pointer(&task, scsi_free_scsi_task);
if (!(task = iscsi_readcapacity16_sync(iscsi, lun)) ||
task->status != SCSI_STATUS_GOOD) {
{
if (ptr->ioctx != NULL) {
VIR_DEBUG("Closing RADOS IoCTX");
- rados_ioctx_destroy(ptr->ioctx);
+ g_clear_pointer(&ptr->ioctx, rados_ioctx_destroy);
}
- ptr->ioctx = NULL;
if (ptr->cluster != NULL) {
VIR_DEBUG("Closing RADOS connection");
- rados_shutdown(ptr->cluster);
+ g_clear_pointer(&ptr->cluster, rados_shutdown);
}
- ptr->cluster = NULL;
VIR_DEBUG("RADOS connection existed for %ld seconds",
time(0) - ptr->starttime);
if (err == -2) {
/* Silently ignore non-regular files,
* eg 'lost+found', dangling symbolic link */
- virStorageVolDefFree(vol);
- vol = NULL;
+ g_clear_pointer(&vol, virStorageVolDefFree);
continue;
}
return -1;
return -1;
}
- virBitmapFree(meta->features);
- meta->features = NULL;
+ g_clear_pointer(&meta->features, virBitmapFree);
if (fileTypeInfo[meta->format].getFeatures != NULL &&
fileTypeInfo[meta->format].getFeatures(&meta->features, meta->format, buf, len) < 0)
return -1;
* also used in other places. For backing store detection the
* authentication data would be invalid anyways, so we clear it */
if (def->auth) {
- virStorageAuthDefFree(def->auth);
- def->auth = NULL;
+ g_clear_pointer(&def->auth, virStorageAuthDefFree);
}
}
/* Fake authentication. */
if (testConnectAuthenticate(conn, auth) < 0) {
- testDriverCloseInternal(conn->privateData);
- conn->privateData = NULL;
+ g_clear_pointer(&conn->privateData, testDriverCloseInternal);
return VIR_DRV_OPEN_ERROR;
}
static int
testConnectClose(virConnectPtr conn)
{
- testDriverCloseInternal(conn->privateData);
- conn->privateData = NULL;
+ g_clear_pointer(&conn->privateData, testDriverCloseInternal);
return 0;
}
if (toremove < *countptr) {
virReallocN(ptrptr, size, *countptr -= toremove);
} else {
- g_free(*((void **)ptrptr));
- *((void **)ptrptr) = NULL;
+ g_clear_pointer(((void **)ptrptr), g_free);
*countptr = 0;
}
}
if (!cval)
return 0;
- g_strfreev(*values);
- *values = NULL;
+ g_clear_pointer(values, g_strfreev);
switch (cval->type) {
case VIR_CONF_LIST:
return;
virSetError(*savederr);
- virFreeError(*savederr);
- *savederr = NULL;
+ g_clear_pointer(savederr, virFreeError);
errno = saved_errno;
}
VIR_DEBUG("Removed old handle source=%p", data->source);
g_source_destroy(data->source);
- vir_g_source_unref(data->source, NULL);
- data->source = NULL;
+ g_clear_pointer(&data->source, g_source_destroy);
data->events = 0;
}
data, watch, data->fd);
if (data->source != NULL) {
- g_source_destroy(data->source);
vir_g_source_unref(data->source, NULL);
- data->source = NULL;
+ g_clear_pointer(&data->source, g_source_destroy);
data->events = 0;
}
if (data->source == NULL)
goto cleanup;
- g_source_destroy(data->source);
vir_g_source_unref(data->source, NULL);
- data->source = NULL;
+ g_clear_pointer(&data->source, g_source_destroy);
}
cleanup:
data, timer);
if (data->source != NULL) {
- g_source_destroy(data->source);
vir_g_source_unref(data->source, NULL);
- data->source = NULL;
+ g_clear_pointer(&data->source, g_source_destroy);
}
/* since the actual timeout deletion is done asynchronously, a timeoutUpdate call may
void
virFileFreeACLs(void **acl)
{
- acl_free(*acl);
- *acl = NULL;
+ g_clear_pointer(acl, acl_free);
}
#else /* !defined(WITH_LIBACL) */
return NULL;
if (virFileCacheSave(cache, name, data) < 0) {
- virObjectUnref(data);
- data = NULL;
+ g_clear_pointer(&data, virObjectUnref);
}
}
if (*data) {
VIR_DEBUG("Caching data '%p' for '%s'", *data, name);
if (virHashAddEntry(cache->table, name, *data) < 0) {
- virObjectUnref(*data);
- *data = NULL;
+ g_clear_pointer(data, virObjectUnref);
}
}
}
g_dbus_connection_flush_sync(systemBus, NULL, NULL);
g_dbus_connection_close_sync(systemBus, NULL, NULL);
- g_object_unref(systemBus);
- systemBus = NULL;
+ g_clear_pointer(&systemBus, g_object_unref);
}
size_t i;
for (i = 0; i < list->count; i++) {
- virMediatedDeviceFree(list->devs[i]);
- list->devs[i] = NULL;
+ g_clear_pointer(&list->devs[i], virMediatedDeviceFree);
}
list->count = 0;
ret = 0;
cleanup:
if (ret < 0) {
- virNetDevRxFilterFree(fil);
- fil = NULL;
+ g_clear_pointer(&fil, virNetDevRxFilterFree);
}
*filter = fil;
virNetlinkShutdown(void)
{
if (placeholder_nlhandle) {
- virNetlinkFree(placeholder_nlhandle);
- placeholder_nlhandle = NULL;
+ g_clear_pointer(&placeholder_nlhandle, virNetlinkFree);
}
}
size_t i;
for (i = 0; i < list->count; i++) {
- virPCIDeviceFree(list->devs[i]);
- list->devs[i] = NULL;
+ g_clear_pointer(&list->devs[i], virPCIDeviceFree);
}
list->count = 0;
error:
VIR_FREE(schemata);
- virObjectUnref(*alloc);
- *alloc = NULL;
+ g_clear_pointer(alloc, virObjectUnref);
return -1;
}
cleanup:
if (ret < 0) {
- g_strfreev(*matches);
- *matches = NULL;
+ g_clear_pointer(matches, g_strfreev);
}
return ret;
}
if (!def->manufacturer && !def->product && !def->version &&
!def->serial && !def->uuid && !def->sku && !def->family) {
- virSysinfoSystemDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoSystemDefFree);
}
*sysdef = g_steal_pointer(&def);
if (!def->manufacturer && !def->product && !def->version &&
!def->serial && !def->uuid && !def->sku && !def->family) {
- virSysinfoSystemDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoSystemDefFree);
}
*sysdef = g_steal_pointer(&def);
if (!def->manufacturer && !def->product && !def->version &&
!def->serial && !def->uuid && !def->sku && !def->family) {
- virSysinfoSystemDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoSystemDefFree);
}
*sysdef = g_steal_pointer(&def);
if (!def->vendor && !def->version &&
!def->date && !def->release) {
- virSysinfoBIOSDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoBIOSDefFree);
}
*bios = g_steal_pointer(&def);
if (!def->manufacturer && !def->product && !def->version &&
!def->serial && !def->uuid && !def->sku && !def->family) {
- virSysinfoSystemDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoSystemDefFree);
}
*sysdef = g_steal_pointer(&def);
if (!def->manufacturer && !def->version &&
!def->serial && !def->asset && !def->sku) {
- virSysinfoChassisDefFree(def);
- def = NULL;
+ g_clear_pointer(&def, virSysinfoChassisDefFree);
}
*chassisdef = g_steal_pointer(&def);
return -1;
}
swtpmBinaries[i].path = g_steal_pointer(&path);
- virBitmapFree(swtpmBinaries[i].caps);
- swtpmBinaries[i].caps = NULL;
+ g_clear_pointer(&swtpmBinaries[i].caps, virBitmapFree);
}
}
cleanup:
if (hVBoxXPCOMC != NULL && result < 0) {
- dlclose(hVBoxXPCOMC);
- hVBoxXPCOMC = NULL;
+ g_clear_pointer(&hVBoxXPCOMC, dlclose);
}
VIR_FREE(name);
tmp = virStringReplace(newSnapshotPtr->storageController,
searchResultTab[it],
uuidReplacing);
- g_strfreev(searchResultTab);
- searchResultTab = NULL;
+ g_clear_pointer(&searchResultTab, g_strfreev);
VIR_FREE(newSnapshotPtr->storageController);
if (!tmp)
goto cleanup;
VIR_FREE(location);
VIR_FREE(tmp);
if (result < 0) {
- virVboxSnapshotConfHardDiskFree(hardDisk);
- hardDisk = NULL;
+ g_clear_pointer(&hardDisk, virVboxSnapshotConfHardDiskFree);
}
return hardDisk;
}
cleanup:
if (result < 0) {
- virVBoxSnapshotConfMediaRegistryFree(mediaRegistry);
- mediaRegistry = NULL;
+ g_clear_pointer(&mediaRegistry, virVBoxSnapshotConfMediaRegistryFree);
}
VIR_FREE(nodes);
return mediaRegistry;
cleanup:
if (result < 0) {
- virVBoxSnapshotConfSnapshotFree(snapshot);
- snapshot = NULL;
+ g_clear_pointer(&snapshot, virVBoxSnapshotConfSnapshotFree);
}
VIR_FREE(nodes);
VIR_FREE(uuid);
cleanup:
if (result < 0) {
xmlUnlinkNode(ret);
- xmlFreeNode(ret);
- ret = NULL;
+ g_clear_pointer(&ret, xmlFreeNode);
}
VIR_FREE(uuid);
return ret;
if (encoding == NULL || STRCASEEQ(encoding, "UTF-8")) {
/* nothing */
} else {
- virConfFree(conf);
- conf = NULL;
+ g_clear_pointer(&conf, virConfFree);
utf8 = virVMXConvertToUTF8(encoding, vmx);
failure:
VIR_FREE(listenAddr);
- virDomainGraphicsDefFree(*def);
- *def = NULL;
+ g_clear_pointer(def, virDomainGraphicsDefFree);
return -1;
}
cleanup:
if (result < 0) {
- virDomainDiskDefFree(*def);
- *def = NULL;
+ g_clear_pointer(def, virDomainDiskDefFree);
}
VIR_FREE(prefix);
return result;
ignore:
- virDomainDiskDefFree(*def);
- *def = NULL;
+ g_clear_pointer(def, virDomainDiskDefFree);
result = 0;
cleanup:
if (result < 0) {
- virDomainFSDefFree(*def);
- *def = NULL;
+ g_clear_pointer(def, virDomainFSDefFree);
}
VIR_FREE(hostPath);
cleanup:
if (result < 0) {
- virDomainNetDefFree(*def);
- *def = NULL;
+ g_clear_pointer(def, virDomainNetDefFree);
}
VIR_FREE(networkName);
cleanup:
if (result < 0) {
- virDomainChrDefFree(*def);
- *def = NULL;
+ g_clear_pointer(def, virDomainChrDefFree);
}
VIR_FREE(fileType);
cleanup:
if (result < 0) {
- virDomainChrDefFree(*def);
- *def = NULL;
+ g_clear_pointer(def, virDomainChrDefFree);
}
VIR_FREE(fileType);
cleanup:
if (result < 0) {
- virDomainVideoDefFree(*def);
- *def = NULL;
+ g_clear_pointer(def, virDomainVideoDefFree);
}
return result;
vzStateCleanup(void)
{
if (vz_driver_privileged) {
- virObjectUnref(vz_driver);
- vz_driver = NULL;
+ g_clear_pointer(&vz_driver, virObjectUnref);
if (vz_driver_lock_fd != -1)
virPidFileRelease(VZ_STATEDIR, "driver", vz_driver_lock_fd);
virMutexDestroy(&vz_driver_lock);
ret = PrlJob_GetResult(job, result);
if (PRL_FAILED(ret)) {
logPrlErrorHelper(ret, filename, funcname, linenr);
- PrlHandle_Free(*result);
- *result = NULL;
+ g_clear_pointer(result, PrlHandle_Free);
goto cleanup;
}
if (!outactual)
goto cleanup;
- virCommandFree(cmd);
- cmd = NULL;
+ g_clear_pointer(&cmd, virCommandFree);
if (STRNEQ(outactual, outexpect)) {
virTestDifference(stderr, outexpect, outactual);
goto cleanup;
}
- virCommandFree(cmd);
- cmd = NULL;
+ g_clear_pointer(&cmd, virCommandFree);
if (kill(pid, 0) != 0) {
printf("daemon should still be running\n");
goto cleanup;
if (baseline &&
(data->flags & VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES) &&
virCPUExpandFeatures(data->arch, baseline) < 0) {
- virCPUDefFree(baseline);
- baseline = NULL;
+ g_clear_pointer(&baseline, virCPUDefFree);
}
if (data->result < 0) {
if (err) {
virNetSocketRemoveIOCallback(sock);
virNetSocketClose(sock);
- virObjectUnref(test->client);
- test->client = NULL;
+ g_clear_pointer(&test->client, virObjectUnref);
} else {
events = VIR_EVENT_HANDLE_READABLE;
return srv;
error:
- virObjectUnref(srv);
- srv = NULL;
+ g_clear_pointer(&srv, virObjectUnref);
goto cleanup;
}
goto join;
}
- virObjectUnref(ssock);
- ssock = NULL;
+ g_clear_pointer(&ssock, virObjectUnref);
ret = 0;
if (!req->crt)
return;
- gnutls_x509_crt_deinit(req->crt);
- req->crt = NULL;
+ g_clear_pointer(&req->crt, gnutls_x509_crt_deinit);
if (getenv("VIRT_TEST_DEBUG_CERTS") == NULL)
unlink(req->filename);
return -1;
/* Different index, same value pointers */
- g_free(b->value);
+ g_clear_pointer(&b->value, g_free);
b->value = a->value;
if (virPCIVPDResourceCustomCompareIndex(b, a)) {
b->value = NULL;
dev = NULL;
}
- virObjectUnref(devlist);
- devlist = NULL;
+ g_clear_pointer(&devlist, virObjectUnref);
ndevs = virUSBDeviceListCount(list);
if (testCheckNdevs("After first loop", ndevs, EXPECTED_NDEVS_ONE) < 0)
}
virUSBDeviceListDel(list, dev);
- virUSBDeviceFree(dev);
- dev = NULL;
+ g_clear_pointer(&dev, virUSBDeviceFree);
if (testCheckNdevs("After deleting one",
virUSBDeviceListCount(list),
remove_entry:
/* the domain has to be removed as it failed one of the filters */
- virshDomainFree(list->domains[i]);
- list->domains[i] = NULL;
+ g_clear_pointer(&list->domains[i], virshDomainFree);
deleted++;
}
VIR_FREE(names[i]);
if (!success) {
- virshDomainListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshDomainListFree);
}
VIR_FREE(names);
/* remove current source */
xmlUnlinkNode(source);
- xmlFreeNode(source);
- source = NULL;
+ g_clear_pointer(&source, xmlFreeNode);
}
/* set the correct disk type */
VIR_FREE(inactiveNames);
if (!success) {
- virshInterfaceListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshInterfaceListFree);
}
return list;
VIR_FREE(names);
if (!success) {
- virshNetworkListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshNetworkListFree);
}
return list;
cleanup:
if (!success) {
- virshNetworkPortListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshNetworkPortListFree);
}
return list;
VIR_FREE(names);
if (!success) {
- virshNodeDeviceListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshNodeDeviceListFree);
}
return list;
VIR_FREE(names);
if (!success) {
- virshNWFilterListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshNWFilterListFree);
}
return list;
cleanup:
if (!success) {
- virshNWFilterBindingListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshNWFilterBindingListFree);
}
return list;
VIR_FREE(names[i]);
if (!success) {
- virshStoragePoolListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshStoragePoolListFree);
}
VIR_FREE(names);
}
if (!success) {
- virshSecretListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshSecretListFree);
}
return list;
STRNEQ_NULLABLE(fromname,
snaplist->snaps[i].parent)))) ||
(roots && snaplist->snaps[i].parent)) {
- virshDomainSnapshotFree(snaplist->snaps[i].snap);
- snaplist->snaps[i].snap = NULL;
+ g_clear_pointer(&snaplist->snaps[i].snap,
+ virshDomainSnapshotFree);
VIR_FREE(snaplist->snaps[i].parent);
deleted++;
}
for (i = 0; i < count; i++) {
if (i == start_index || !snaplist->snaps[i].parent) {
VIR_FREE(names[i]);
- virshDomainSnapshotFree(snaplist->snaps[i].snap);
- snaplist->snaps[i].snap = NULL;
+ g_clear_pointer(&snaplist->snaps[i].snap,
+ virshDomainSnapshotFree);
VIR_FREE(snaplist->snaps[i].parent);
deleted++;
} else if (STREQ(snaplist->snaps[i].parent, fromname)) {
if (!found_parent) {
changed = true;
VIR_FREE(names[i]);
- virshDomainSnapshotFree(snaplist->snaps[i].snap);
- snaplist->snaps[i].snap = NULL;
+ g_clear_pointer(&snaplist->snaps[i].snap,
+ virshDomainSnapshotFree);
VIR_FREE(snaplist->snaps[i].parent);
deleted++;
}
case 1:
break;
case 0:
- virshDomainSnapshotFree(snaplist->snaps[i].snap);
- snaplist->snaps[i].snap = NULL;
+ g_clear_pointer(&snaplist->snaps[i].snap,
+ virshDomainSnapshotFree);
VIR_FREE(snaplist->snaps[i].parent);
deleted++;
break;
VIR_FREE(names);
if (!success) {
- virshStorageVolListFree(list);
- list = NULL;
+ g_clear_pointer(&list, virshStorageVolListFree);
}
return list;
vshError(ctl, "%s",
_("Cannot setup keepalive on connection "
"as requested, disconnecting"));
- virConnectClose(c);
- c = NULL;
+ g_clear_pointer(&c, virConnectClose);
goto cleanup;
}
vshDebug(ctl, VSH_ERR_INFO, "%s",
void
vshResetLibvirtError(void)
{
- virFreeError(last_error);
- last_error = NULL;
+ g_clear_pointer(&last_error, virFreeError);
virResetLastError();
}
const vshCmdDef *cmd = NULL;
if (!partial) {
- vshCommandFree(ctl->cmd);
- ctl->cmd = NULL;
+ g_clear_pointer(&ctl->cmd, vshCommandFree);
}
while (1) {
first = NULL;
if (partial) {
- vshCommandFree(*partial);
- *partial = NULL;
+ g_clear_pointer(partial, vshCommandFree);
}
while (1) {
*partial = tmp;
} else {
- vshCommandFree(ctl->cmd);
- ctl->cmd = NULL;
+ g_clear_pointer(&ctl->cmd, vshCommandFree);
vshCommandOptFree(first);
}
VIR_FREE(tkdata);
const vshCmdOptDef *opt = NULL;
g_autofree char *line = g_strdup(rl_line_buffer);
- g_strfreev(list);
- list = NULL;
+ g_clear_pointer(&list, g_strfreev);
list_index = 0;
*(line + rl_point) = '\0';
cleanup:
if (!ret) {
- g_strfreev(list);
- list = NULL;
+ g_clear_pointer(&list, g_strfreev);
list_index = 0;
}