goto cleanup;
}
- VIR_STEAL_PTR(*info, info_ret);
+ *info = g_steal_pointer(&info_ret);
ret = ndata;
cleanup:
goto cleanup;
}
- VIR_STEAL_PTR(*info, info_ret);
+ *info = g_steal_pointer(&info_ret);
ret = nfs;
cleanup:
iface->naddrs = addrs_count;
}
- VIR_STEAL_PTR(*ifaces, ifaces_ret);
+ *ifaces = g_steal_pointer(&ifaces_ret);
ret = ifaces_count;
cleanup:
&backingdata) < 0)
return -1;
- VIR_STEAL_PTR(data->backing, backingdata);
- VIR_STEAL_PTR(*nodenamedata, data);
+ data->backing = g_steal_pointer(&backingdata);
+ *nodenamedata = g_steal_pointer(&data);
return 0;
}
goto cleanup;
if (driveAlias) {
- VIR_STEAL_PTR(data->driveAlias, driveAlias);
+ data->driveAlias = g_steal_pointer(&driveAlias);
data->driveAdded = true;
} else {
data->formatNodeName = src->nodeformat;
goto cleanup;
}
- VIR_STEAL_PTR(ret, data);
+ ret = g_steal_pointer(&data);
cleanup:
VIR_FREE(driveAlias);
qemuBlockStorageSourceCreateAddBacking(backing, props, false) < 0)
return -1;
- VIR_STEAL_PTR(*retprops, props);
+ *retprops = g_steal_pointer(&props);
return 0;
}
return -1;
}
- VIR_STEAL_PTR(*luksProps, props);
+ *luksProps = g_steal_pointer(&props);
return 0;
}
NULL) < 0)
return -1;
- VIR_STEAL_PTR(*props, luksprops);
+ *props = g_steal_pointer(&luksprops);
return 0;
}
qemuBlockStorageSourceCreateAddEncryptionQcow(src, qcow2props) < 0)
return -1;
- VIR_STEAL_PTR(*props, qcow2props);
+ *props = g_steal_pointer(&qcow2props);
return 0;
}
qemuBlockStorageSourceCreateAddEncryptionQcow(src, qcowprops) < 0)
return -1;
- VIR_STEAL_PTR(*props, qcowprops);
+ *props = g_steal_pointer(&qcowprops);
return 0;
}
if (qemuBlockStorageSourceCreateAddBacking(backing, qedprops, true) < 0)
return -1;
- VIR_STEAL_PTR(*props, qedprops);
+ *props = g_steal_pointer(&qedprops);
return 0;
}
}
virObjectUnref(persistDisk->src);
- VIR_STEAL_PTR(persistDisk->src, copy);
+ persistDisk->src = g_steal_pointer(©);
}
* inherit the rest of the chain */
if (job->data.copy.shallownew &&
!virStorageSourceIsBacking(job->disk->mirror->backingStore))
- VIR_STEAL_PTR(job->disk->mirror->backingStore, job->disk->src->backingStore);
+ job->disk->mirror->backingStore = g_steal_pointer(&job->disk->src->backingStore);
qemuBlockJobRewriteConfigDiskSource(vm, job->disk, job->disk->mirror);
qemuBlockJobEventProcessConcludedRemoveChain(driver, vm, asyncJob, job->disk->src);
virObjectUnref(job->disk->src);
- VIR_STEAL_PTR(job->disk->src, job->disk->mirror);
+ job->disk->src = g_steal_pointer(&job->disk->mirror);
}
tmp->cbitpos = src->cbitpos;
tmp->reduced_phys_bits = src->reduced_phys_bits;
- VIR_STEAL_PTR(*dst, tmp);
+ *dst = g_steal_pointer(&tmp);
return 0;
}
goto cleanup;
}
- VIR_STEAL_PTR(*features, list);
+ *features = g_steal_pointer(&list);
if (migratable && !modelInfo->migratability)
ret = 1;
else
if (virCPUx86DataSetSignature(data, sigFamily, sigModel, sigStepping) < 0)
goto cleanup;
- VIR_STEAL_PTR(ret, data);
+ ret = g_steal_pointer(&data);
cleanup:
virCPUDataFree(data);
return -1;
}
- VIR_STEAL_PTR(qemuCaps->sevCapabilities, sev);
+ qemuCaps->sevCapabilities = g_steal_pointer(&sev);
return 0;
}
}
qemuCaps->version = major * 1000000 + minor * 1000 + micro;
- VIR_STEAL_PTR(qemuCaps->package, package);
+ qemuCaps->package = g_steal_pointer(&package);
qemuCaps->usedQMP = true;
if (virQEMUCapsInitQMPArch(qemuCaps, mon) < 0)
if (retMachine)
*retMachine = machine;
- VIR_STEAL_PTR(ret, qemuCaps);
+ ret = g_steal_pointer(&qemuCaps);
cleanup:
virObjectUnref(qemuCaps);
sev->cbitpos = cap->cbitpos;
sev->reduced_phys_bits = cap->reduced_phys_bits;
- VIR_STEAL_PTR(domCaps->sev, sev);
+ domCaps->sev = g_steal_pointer(&sev);
return 0;
}
virCgroupSetCpusetMems(data->emulatorCgroup, all_nodes_str) < 0)
goto cleanup;
- VIR_STEAL_PTR(*retData, data);
+ *retData = g_steal_pointer(&data);
ret = 0;
cleanup:
!(data->driveAlias = qemuAliasDiskDriveFromDisk(disk)))
return NULL;
- VIR_STEAL_PTR(ret, data);
+ ret = g_steal_pointer(&data);
return ret;
}
job->asyncJob = priv->job.asyncJob;
job->asyncOwner = priv->job.asyncOwner;
job->phase = priv->job.phase;
- VIR_STEAL_PTR(job->migParams, priv->job.migParams);
+ job->migParams = g_steal_pointer(&priv->job.migParams);
job->apiFlags = priv->job.apiFlags;
qemuDomainObjResetJob(priv);
}
if ((*secinfo)->type == VIR_DOMAIN_SECRET_INFO_TYPE_AES)
- VIR_STEAL_PTR((*secinfo)->s.aes.alias, *alias);
+ (*secinfo)->s.aes.alias = g_steal_pointer(&*alias);
return 0;
}
VIR_DOMAIN_DEF_PARSE_STATUS, xmlopt) < 0)
return -1;
- VIR_STEAL_PTR(diskPriv->migrSource, migrSource);
+ diskPriv->migrSource = g_steal_pointer(&migrSource);
return 0;
}
}
}
- VIR_STEAL_PTR(priv->qemuCaps, qemuCaps);
+ priv->qemuCaps = g_steal_pointer(&qemuCaps);
}
VIR_FREE(nodes);
if (qemuDomainObjPrivateXMLParseSlirpFeatures(nodes[i], ctxt, slirp) < 0)
goto error;
- VIR_STEAL_PTR(QEMU_DOMAIN_NETWORK_PRIVATE(dev.data.net)->slirp, slirp);
+ QEMU_DOMAIN_NETWORK_PRIVATE(dev.data.net)->slirp = g_steal_pointer(&slirp);
}
VIR_FREE(nodes);
if (nsdata->num_args > 0 || nsdata->num_env > 0 ||
nsdata->ncapsadd > 0 || nsdata->ncapsdel > 0)
- VIR_STEAL_PTR(*data, nsdata);
+ *data = g_steal_pointer(&nsdata);
ret = 0;
vcpupriv->node_id = info[i].node_id;
vcpupriv->vcpus = info[i].vcpus;
VIR_FREE(vcpupriv->type);
- VIR_STEAL_PTR(vcpupriv->type, info[i].type);
+ vcpupriv->type = g_steal_pointer(&info[i].type);
VIR_FREE(vcpupriv->alias);
- VIR_STEAL_PTR(vcpupriv->alias, info[i].alias);
+ vcpupriv->alias = g_steal_pointer(&info[i].alias);
virJSONValueFree(vcpupriv->props);
- VIR_STEAL_PTR(vcpupriv->props, info[i].props);
+ vcpupriv->props = g_steal_pointer(&info[i].props);
vcpupriv->enable_id = info[i].id;
vcpupriv->qemu_id = info[i].qemu_id;
}
VIR_FREE(devTmp);
VIR_FREE(target);
- VIR_STEAL_PTR(target, tmp);
+ target = g_steal_pointer(&tmp);
}
if (qemuDomainCreateDeviceRecursive(target, data,
}
VIR_FREE(fileTmp);
VIR_FREE(target);
- VIR_STEAL_PTR(target, tmp);
+ target = g_steal_pointer(&tmp);
}
data.target = target;
if (fixedCPU) {
virCPUDefFree(vm->def->cpu);
- VIR_STEAL_PTR(vm->def->cpu, fixedCPU);
+ vm->def->cpu = g_steal_pointer(&fixedCPU);
}
if (fixedOrig) {
virCPUDefFree(*origCPU);
- VIR_STEAL_PTR(*origCPU, fixedOrig);
+ *origCPU = g_steal_pointer(&fixedOrig);
}
ret = 0;
if (VIR_ALLOC(data) < 0)
return NULL;
- VIR_STEAL_PTR(data->xml, domXML);
+ data->xml = g_steal_pointer(&domXML);
if (cookieObj &&
!(data->cookie = virSaveCookieFormat((virObjectPtr) cookieObj,
virBitmapFree(map);
}
- VIR_STEAL_PTR(*info, info_ret);
+ *info = g_steal_pointer(&info_ret);
ret = niothreads;
endjob:
virFreeError(err);
/* use the user provided XML */
- VIR_STEAL_PTR(ret, newdef);
+ ret = g_steal_pointer(&newdef);
} else {
- VIR_STEAL_PTR(ret, newdef_migr);
+ ret = g_steal_pointer(&newdef_migr);
}
cleanup:
_("domain already has a watchdog"));
return -1;
}
- VIR_STEAL_PTR(vmdef->watchdog, dev->data.watchdog);
+ vmdef->watchdog = g_steal_pointer(&dev->data.watchdog);
break;
case VIR_DOMAIN_DEVICE_INPUT:
_("domain already has a vsock device"));
return -1;
}
- VIR_STEAL_PTR(vmdef->vsock, dev->data.vsock);
+ vmdef->vsock = g_steal_pointer(&dev->data.vsock);
break;
case VIR_DOMAIN_DEVICE_SOUND:
goto cleanup;
if (flags & VIR_MIGRATE_PEER2PEER)
- VIR_STEAL_PTR(dconnuri, uri);
+ dconnuri = g_steal_pointer(&uri);
/* Do not output cookies in v2 protocol, since the cookie
* length was not sufficiently large, causing failures
virCPUDefFreeModel(dst);
- VIR_STEAL_PTR(info, *src);
- VIR_STEAL_PTR(dst->model, info->name);
+ info = g_steal_pointer(&*src);
+ dst->model = g_steal_pointer(&info->name);
for (i = 0; i < info->nprops; i++) {
char *name = info->props[i].name;
goto cleanup;
}
- VIR_STEAL_PTR(ret, baseline);
+ ret = g_steal_pointer(&baseline);
cleanup:
qemuProcessQMPFree(proc);
return -1;
if (backingStoreStr != NULL) {
if (virStorageIsRelative(backingStoreStr))
- VIR_STEAL_PTR(dd->relPath, backingStoreStr);
+ dd->relPath = g_steal_pointer(&backingStoreStr);
else
VIR_FREE(backingStoreStr);
}
goto cleanup;
}
- VIR_STEAL_PTR(*rdata, data);
+ *rdata = g_steal_pointer(&data);
*rndata = ndata;
ret = 0;
/* the old disk image is now readonly */
dd->disk->src->readonly = true;
- VIR_STEAL_PTR(dd->disk->src->relPath, dd->relPath);
- VIR_STEAL_PTR(dd->src->backingStore, dd->disk->src);
- VIR_STEAL_PTR(dd->disk->src, dd->src);
+ dd->disk->src->relPath = g_steal_pointer(&dd->relPath);
+ dd->src->backingStore = g_steal_pointer(&dd->disk->src);
+ dd->disk->src = g_steal_pointer(&dd->src);
/* fix numbering of disks */
if (!blockdev)
qemuDomainSnapshotDiskUpdateSourceRenumber(dd->disk->src);
if (dd->persistdisk) {
- VIR_STEAL_PTR(dd->persistsrc->backingStore, dd->persistdisk->src);
- VIR_STEAL_PTR(dd->persistdisk->src, dd->persistsrc);
+ dd->persistsrc->backingStore = g_steal_pointer(&dd->persistdisk->src);
+ dd->persistdisk->src = g_steal_pointer(&dd->persistsrc);
}
}
if (!inactiveConfig)
goto endjob;
} else {
- VIR_STEAL_PTR(inactiveConfig, config);
+ inactiveConfig = g_steal_pointer(&config);
}
}
}
if (config) {
virCPUDefFree(priv->origCPU);
- VIR_STEAL_PTR(priv->origCPU, origCPU);
+ priv->origCPU = g_steal_pointer(&origCPU);
}
if (cookie && !cookie->slirpHelper)
/* Update vm in place to match changes. */
need_unlink = false;
virStorageFileDeinit(mirror);
- VIR_STEAL_PTR(disk->mirror, mirror);
+ disk->mirror = g_steal_pointer(&mirror);
disk->mirrorJob = VIR_DOMAIN_BLOCK_JOB_TYPE_COPY;
qemuBlockJobStarted(job, vm);
VIR_DOMAIN_DEF_PARSE_DISK_SOURCE)))
goto cleanup;
- VIR_STEAL_PTR(dest, diskdef->src);
+ dest = g_steal_pointer(&diskdef->src);
ret = qemuDomainBlockCopyCommon(vm, dom->conn, disk, dest, bandwidth,
granularity, buf_size, flags, false);
}
if (mirror) {
- VIR_STEAL_PTR(disk->mirror, mirror);
+ disk->mirror = g_steal_pointer(&mirror);
disk->mirrorJob = VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT;
}
qemuBlockJobStarted(job, vm);
return -1;
tmp->nparams = virTypedParamListStealParams(params, &tmp->params);
- VIR_STEAL_PTR(*record, tmp);
+ *record = g_steal_pointer(&tmp);
return 0;
}
VIR_FREE(leases);
}
- VIR_STEAL_PTR(*ifaces, ifaces_ret);
+ *ifaces = g_steal_pointer(&ifaces_ret);
rv = ifaces_count;
cleanup:
}
}
- VIR_STEAL_PTR(*ifaces, ifaces_ret);
+ *ifaces = g_steal_pointer(&ifaces_ret);
ret = ifaces_count;
cleanup:
sev->reduced_phys_bits) < 0)
goto cleanup;
- VIR_STEAL_PTR(*params, sevParams);
+ *params = g_steal_pointer(&sevParams);
*nparams = n;
return 0;
VIR_DEBUG("firmware description path '%s' supported interfaces: %s",
path, NULLSTR_MINUS(virBufferCurrentContent(&buf)));
- VIR_STEAL_PTR(fw->interfaces, interfaces);
+ fw->interfaces = g_steal_pointer(&interfaces);
fw->ninterfaces = ninterfaces;
return 0;
}
VIR_APPEND_ELEMENT_INPLACE(t->machines, t->nmachines, machineStr);
}
- VIR_STEAL_PTR(targets[i], t);
+ targets[i] = g_steal_pointer(&t);
}
- VIR_STEAL_PTR(fw->targets, targets);
+ fw->targets = g_steal_pointer(&targets);
fw->ntargets = ntargets;
ntargets = 0;
ret = 0;
features[i] = tmp;
}
- VIR_STEAL_PTR(fw->features, features);
+ fw->features = g_steal_pointer(&features);
fw->nfeatures = nfeatures;
return 0;
}
if (qemuFirmwareFeatureParse(path, doc, fw) < 0)
return NULL;
- VIR_STEAL_PTR(ret, fw);
+ ret = g_steal_pointer(&fw);
return ret;
}
flash.format) < 0)
return NULL;
- VIR_STEAL_PTR(ret, json);
+ ret = g_steal_pointer(&json);
return ret;
}
goto error;
}
- VIR_STEAL_PTR(*firmwaresRet, firmwares);
+ *firmwaresRet = g_steal_pointer(&firmwares);
if (pathsRet)
- VIR_STEAL_PTR(*pathsRet, paths);
+ *pathsRet = g_steal_pointer(&paths);
return npaths;
error:
goto cleanup;
}
- VIR_STEAL_PTR(vm->def->vsock, vsock);
+ vm->def->vsock = g_steal_pointer(&vsock);
ret = 0;
}
}
- VIR_STEAL_PTR(ret, map);
+ ret = g_steal_pointer(&map);
cleanup:
virBitmapFree(map);
if (qemuDomainObjExitMonitor(driver, vm) < 0 || mon_ret < 0)
return -1;
- VIR_STEAL_PTR(diskPriv->migrSource, copysrc);
+ diskPriv->migrSource = g_steal_pointer(©src);
return 0;
}
if (iothread) {
qemuMigrationIOThreadPtr io;
- VIR_STEAL_PTR(io, iothread);
+ io = g_steal_pointer(&iothread);
if (qemuMigrationSrcStopTunnel(io, false) < 0)
goto error;
}
VIR_MIGRATE_AUTO_CONVERGE);
VIR_DEBUG("Prepare3 %p", dconn);
- VIR_STEAL_PTR(cookiein, cookieout);
+ cookiein = g_steal_pointer(&cookieout);
cookieinlen = cookieoutlen;
cookieoutlen = 0;
if (flags & VIR_MIGRATE_TUNNELLED) {
VIR_DEBUG("Perform3 %p uri=%s", sconn, NULLSTR(uri));
qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_PERFORM3);
VIR_FREE(cookiein);
- VIR_STEAL_PTR(cookiein, cookieout);
+ cookiein = g_steal_pointer(&cookieout);
cookieinlen = cookieoutlen;
cookieoutlen = 0;
if (flags & VIR_MIGRATE_TUNNELLED) {
*/
VIR_DEBUG("Finish3 %p ret=%d", dconn, ret);
VIR_FREE(cookiein);
- VIR_STEAL_PTR(cookiein, cookieout);
+ cookiein = g_steal_pointer(&cookieout);
cookieinlen = cookieoutlen;
cookieoutlen = 0;
*/
VIR_DEBUG("Confirm3 %p cancelled=%d vm=%p", sconn, cancelled, vm);
VIR_FREE(cookiein);
- VIR_STEAL_PTR(cookiein, cookieout);
+ cookiein = g_steal_pointer(&cookieout);
cookieinlen = cookieoutlen;
cookieoutlen = 0;
ret = qemuMigrationSrcConfirmPhase(driver, vm,
if (dom) {
if (jobInfo) {
- VIR_STEAL_PTR(priv->job.completed, jobInfo);
+ priv->job.completed = g_steal_pointer(&jobInfo);
priv->job.completed->status = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
priv->job.completed->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION;
}
VIR_FREE(automatic);
}
- VIR_STEAL_PTR(ret, caps);
+ ret = g_steal_pointer(&caps);
cleanup:
qemuMigrationCookieCapsFree(caps);
break;
case QEMU_MIGRATION_PARAM_TYPE_STRING:
- VIR_STEAL_PTR(pv->value.s, value);
+ pv->value.s = g_steal_pointer(&value);
break;
}
VIR_FREE(value);
}
- VIR_STEAL_PTR(*migParams, params);
+ *migParams = g_steal_pointer(¶ms);
ret = 0;
cleanup:
vcpus[mastervcpu].thread_id = hotplugvcpus[i].thread_id;
vcpus[mastervcpu].node_id = hotplugvcpus[i].node_id;
vcpus[mastervcpu].vcpus = hotplugvcpus[i].vcpus;
- VIR_STEAL_PTR(vcpus[mastervcpu].qom_path, hotplugvcpus[i].qom_path);
- VIR_STEAL_PTR(vcpus[mastervcpu].alias, hotplugvcpus[i].alias);
- VIR_STEAL_PTR(vcpus[mastervcpu].type, hotplugvcpus[i].type);
- VIR_STEAL_PTR(vcpus[mastervcpu].props, hotplugvcpus[i].props);
+ vcpus[mastervcpu].qom_path = g_steal_pointer(&hotplugvcpus[i].qom_path);
+ vcpus[mastervcpu].alias = g_steal_pointer(&hotplugvcpus[i].alias);
+ vcpus[mastervcpu].type = g_steal_pointer(&hotplugvcpus[i].type);
+ vcpus[mastervcpu].props = g_steal_pointer(&hotplugvcpus[i].props);
vcpus[mastervcpu].id = hotplugvcpus[i].enable_id;
/* copy state information to slave vcpus */
if (rc < 0) {
if (!hotplug && rc == -2) {
- VIR_STEAL_PTR(*vcpus, info);
+ *vcpus = g_steal_pointer(&info);
ret = 0;
}
qemuMonitorGetCPUInfoLegacy(cpuentries, ncpuentries, info, maxvcpus);
}
- VIR_STEAL_PTR(*vcpus, info);
+ *vcpus = g_steal_pointer(&info);
ret = 0;
cleanup:
*props = NULL;
if (alias)
- VIR_STEAL_PTR(*alias, tmp);
+ *alias = g_steal_pointer(&tmp);
cleanup:
VIR_FREE(tmp);
if (qemuMonitorJSONGetPRManagerInfo(mon, info) < 0)
goto cleanup;
- VIR_STEAL_PTR(*retinfo, info);
+ *retinfo = g_steal_pointer(&info);
ret = 0;
cleanup:
virHashFree(info);
qemuMonitorJSONExtractCPUS390Info(entry, cpus + i);
}
- VIR_STEAL_PTR(*entries, cpus);
+ *entries = g_steal_pointer(&cpus);
*nentries = ncpus;
ret = 0;
goto cleanup;
}
- VIR_STEAL_PTR(*model_info, machine_model);
+ *model_info = g_steal_pointer(&machine_model);
ret = 0;
cleanup:
return -1;
}
- VIR_STEAL_PTR(*strList, list);
+ *strList = g_steal_pointer(&list);
return n;
}
capability->cbitpos = cbitpos;
capability->reduced_phys_bits = reduced_phys_bits;
- VIR_STEAL_PTR(*capabilities, capability);
+ *capabilities = g_steal_pointer(&capability);
ret = 1;
cleanup:
virJSONValueFree(cmd);
qemuMonitorJSONGetCPUDataDisabled(mon, translate, opaque, cpuDisabled) < 0)
goto cleanup;
- VIR_STEAL_PTR(*enabled, cpuEnabled);
+ *enabled = g_steal_pointer(&cpuEnabled);
if (disabled)
- VIR_STEAL_PTR(*disabled, cpuDisabled);
+ *disabled = g_steal_pointer(&cpuDisabled);
ret = 0;
qsort(info, ninfo, sizeof(*info), qemuMonitorQueryHotpluggableCpusEntrySort);
- VIR_STEAL_PTR(*entries, info);
+ *entries = g_steal_pointer(&info);
*nentries = ninfo;
ret = 0;
VIR_STRDUP(job->error, errmsg) < 0)
return NULL;
- VIR_STEAL_PTR(ret, job);
+ ret = g_steal_pointer(&job);
return ret;
}
processEvent->eventType = QEMU_PROCESS_EVENT_RDMA_GID_STATUS_CHANGED;
processEvent->vm = virObjectRef(vm);
- VIR_STEAL_PTR(processEvent->data, info);
+ processEvent->data = g_steal_pointer(&info);
if (virThreadPoolSendJob(driver->workerPool, 0, processEvent) < 0) {
qemuProcessEventFree(processEvent);
* get the original CPU via migration, restore, or snapshot revert.
*/
if (!priv->origCPU && !virCPUDefIsEqual(def->cpu, orig, false))
- VIR_STEAL_PTR(priv->origCPU, orig);
+ priv->origCPU = g_steal_pointer(&orig);
def->cpu->check = VIR_CPU_CHECK_FULL;
}
if (qemuDomainSetPrivatePaths(driver, vm) < 0)
goto stop;
- VIR_STEAL_PTR(priv->origCPU, origCPU);
+ priv->origCPU = g_steal_pointer(&origCPU);
}
ret = 0;
virBitmapIntersect(numadNodeset, hostMemoryNodeset);
- VIR_STEAL_PTR(priv->autoNodeset, numadNodeset);
+ priv->autoNodeset = g_steal_pointer(&numadNodeset);
ret = 0;
proc->runGid = runGid;
proc->forceTCG = forceTCG;
- VIR_STEAL_PTR(ret, proc);
+ ret = g_steal_pointer(&proc);
cleanup:
qemuProcessQMPFree(proc);
if (qemuVhostUserBinaryParse(path, doc, vu) < 0)
return NULL;
- VIR_STEAL_PTR(ret, vu);
+ ret = g_steal_pointer(&vu);
return ret;
}
goto error;
}
- VIR_STEAL_PTR(*vhostuserRet, vus);
+ *vhostuserRet = g_steal_pointer(&vus);
if (pathsRet)
- VIR_STEAL_PTR(*pathsRet, paths);
+ *pathsRet = g_steal_pointer(&paths);
return npaths;
error:
features[i] = tmp;
}
- VIR_STEAL_PTR(gpu->features, features);
+ gpu->features = g_steal_pointer(&features);
gpu->nfeatures = nfeatures;
return 0;
projects / libvirt.git / commitdiff