qemuDomainObjPrivatePtr priv)
{
int ret = -1;
- char *alias = NULL;
- char *path = NULL;
+ VIR_AUTOFREE(char *) alias = NULL;
+ VIR_AUTOFREE(char *) path = NULL;
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
/* If the -object secret does not exist, then just return. This just
ret = 0;
cleanup:
- VIR_FREE(alias);
- VIR_FREE(path);
return ret;
}
virQEMUCapsPtr qemuCaps)
{
int ret = -1;
- char *devStr = NULL;
+ VIR_AUTOFREE(char *) devStr = NULL;
const char *contAlias = NULL;
bool contIsPHB = false;
int contTargetIndex = 0;
ret = 0;
cleanup:
- VIR_FREE(devStr);
return ret;
}
virJSONValuePtr *propsret)
{
int ret = -1;
- char *keyid = NULL;
+ VIR_AUTOFREE(char *) keyid = NULL;
if (!(keyid = qemuDomainGetMasterKeyAlias()))
return -1;
"s:iv", secinfo->s.aes.iv,
"s:format", "base64", NULL);
- VIR_FREE(keyid);
return ret;
}
bool ret = false;
if (virFileExists("/proc/sys/crypto/fips_enabled")) {
- char *buf = NULL;
+ VIR_AUTOFREE(char *) buf = NULL;
if (virFileReadAll("/proc/sys/crypto/fips_enabled", 10, &buf) < 0)
return ret;
if (STREQ(buf, "1\n"))
ret = true;
- VIR_FREE(buf);
}
return ret;
qemuBuildDriveSourcePR(virBufferPtr buf,
virDomainDiskDefPtr disk)
{
- char *alias = NULL;
+ VIR_AUTOFREE(char *) alias = NULL;
const char *defaultAlias = NULL;
if (!disk->src->pr)
virBufferAsprintf(buf, ",file.pr-manager=%s", alias ? alias : defaultAlias);
- VIR_FREE(alias);
return 0;
}
qemuDomainSecretInfoPtr secinfo = NULL;
qemuDomainSecretInfoPtr encinfo = NULL;
VIR_AUTOPTR(virJSONValue) srcprops = NULL;
- char *source = NULL;
+ VIR_AUTOFREE(char *) source = NULL;
bool rawluks = false;
int ret = -1;
ret = 0;
cleanup:
- VIR_FREE(source);
return ret;
}
goto error;
if (!qemuDiskBusNeedsDriveArg(disk->bus)) {
- char *drivealias = qemuAliasDiskDriveFromDisk(disk);
+ VIR_AUTOFREE(char *) drivealias = qemuAliasDiskDriveFromDisk(disk);
if (!drivealias)
goto error;
virBufferAddLit(&opt, "if=none");
virBufferAsprintf(&opt, ",id=%s", drivealias);
- VIR_FREE(drivealias);
} else {
int idx = virDiskNameToIndex(disk->dst);
VIR_AUTOCLEAN(virBuffer) opt = VIR_BUFFER_INITIALIZER;
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
const char *contAlias;
- char *backendAlias = NULL;
+ VIR_AUTOFREE(char *) backendAlias = NULL;
VIR_AUTOFREE(char *) scsiVPDDeviceId = NULL;
int controllerModel;
if (backendAlias)
virBufferAsprintf(&opt, ",drive=%s", backendAlias);
- VIR_FREE(backendAlias);
virBufferAsprintf(&opt, ",id=%s", disk->info.alias);
if (bootindex)
return virBufferContentAndReset(&opt);
error:
- VIR_FREE(backendAlias);
return NULL;
}
qemuCommandAddZPCIDevice(virCommandPtr cmd,
virDomainDeviceInfoPtr dev)
{
- char *devstr = NULL;
+ VIR_AUTOFREE(char *) devstr = NULL;
virCommandAddArg(cmd, "-device");
virCommandAddArg(cmd, devstr);
- VIR_FREE(devstr);
return 0;
}
bool hasfloppy = false;
unsigned int bootindex;
char driveLetter;
- char *backendAlias = NULL;
- char *backendStr = NULL;
- char *bootindexStr = NULL;
size_t i;
int ret = -1;
virBufferAddLit(&fdc_opts, "isa-fdc,");
for (i = 0; i < def->ndisks; i++) {
+ VIR_AUTOFREE(char *) backendAlias = NULL;
+ VIR_AUTOFREE(char *) backendStr = NULL;
+ VIR_AUTOFREE(char *) bootindexStr = NULL;
virDomainDiskDefPtr disk = def->disks[i];
if (disk->bus != VIR_DOMAIN_DISK_BUS_FDC)
virBufferStrcat(&fdc_opts, backendStr, ",", NULL);
virBufferStrcat(&fdc_opts, bootindexStr, ",", NULL);
}
-
- VIR_FREE(backendAlias);
- VIR_FREE(backendStr);
- VIR_FREE(bootindexStr);
}
if (explicitfdc && hasfloppy) {
ret = 0;
cleanup:
- VIR_FREE(backendAlias);
- VIR_FREE(backendStr);
- VIR_FREE(bootindexStr);
return ret;
}
virQEMUCapsPtr qemuCaps,
unsigned int bootindex)
{
- char *optstr;
+ VIR_AUTOFREE(char *) optstr = NULL;
if (qemuBuildDiskSourceCommandLine(cmd, disk, qemuCaps) < 0)
return -1;
qemuCaps)))
return -1;
virCommandAddArg(cmd, optstr);
- VIR_FREE(optstr);
}
}
const long system_page_size = virGetSystemPageSizeKB();
virDomainMemoryAccess memAccess = mem->access;
size_t i;
- char *memPath = NULL;
+ VIR_AUTOFREE(char *) memPath = NULL;
bool prealloc = false;
virBitmapPtr nodemask = NULL;
int ret = -1;
ret = -1;
cleanup:
- VIR_FREE(memPath);
return ret;
}
virBufferPtr buf)
{
VIR_AUTOPTR(virJSONValue) props = NULL;
- char *alias = NULL;
+ VIR_AUTOFREE(char *) alias = NULL;
int ret = -1;
int rc;
virDomainMemoryDef mem = { 0 };
ret = rc;
cleanup:
- VIR_FREE(alias);
return ret;
}
qemuDomainObjPrivatePtr priv)
{
VIR_AUTOPTR(virJSONValue) props = NULL;
- char *alias = NULL;
+ VIR_AUTOFREE(char *) alias = NULL;
int ret = -1;
if (!mem->info.alias) {
ret = 0;
cleanup:
- VIR_FREE(alias);
return ret;
}
virDomainNetType netType = virDomainNetGetActualType(net);
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
size_t i;
- char *addr = NULL;
char *ret = NULL;
if (net->script && netType != VIR_DOMAIN_NET_TYPE_ETHERNET) {
virBufferAddLit(&buf, "user,");
for (i = 0; i < net->guestIP.nips; i++) {
const virNetDevIPAddr *ip = net->guestIP.ips[i];
+ VIR_AUTOFREE(char *) addr = NULL;
const char *prefix = "";
if (!(addr = virSocketAddrFormat(&ip->address)))
if (ip->prefix)
virBufferAsprintf(&buf, "/%u", ip->prefix);
virBufferAddChar(&buf, ',');
- VIR_FREE(addr);
}
break;
ret = virBufferContentAndReset(&buf);
cleanup:
virObjectUnref(cfg);
- VIR_FREE(addr);
return ret;
}
virQEMUCapsPtr qemuCaps)
{
virDomainWatchdogDefPtr watchdog = def->watchdog;
- char *optstr;
+ VIR_AUTOFREE(char *) optstr = NULL;
const char *action;
int actualAction;
return -1;
virCommandAddArg(cmd, optstr);
- VIR_FREE(optstr);
/* qemu doesn't have a 'dump' action; we tell qemu to 'pause', then
libvirt listens for the watchdog event, and we perform the dump
return -1;
}
- char *optstr;
+ VIR_AUTOFREE(char *) optstr = NULL;
virCommandAddArg(cmd, "-global");
optstr = qemuBuildNVRAMDevStr(def->nvram);
if (!optstr)
return -1;
virCommandAddArg(cmd, optstr);
- VIR_FREE(optstr);
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("nvram device is only supported for PPC64"));
for (i = 0; i < def->ninputs; i++) {
virDomainInputDefPtr input = def->inputs[i];
- char *devstr = NULL;
+ VIR_AUTOFREE(char *) devstr = NULL;
if (qemuCommandAddExtDevice(cmd, &input->info) < 0)
return -1;
virCommandAddArg(cmd, "-device");
virCommandAddArg(cmd, devstr);
}
-
- VIR_FREE(devstr);
}
return 0;
for (i = 0; i < def->nsounds; i++) {
virDomainSoundDefPtr sound = def->sounds[i];
- char *str = NULL;
+ VIR_AUTOFREE(char *) str = NULL;
/* Sadly pcspk device doesn't use -device syntax. Fortunately
* we don't need to set any PCI address on it, so we don't
return -1;
virCommandAddArg(cmd, str);
- VIR_FREE(str);
if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6 ||
sound->model == VIR_DOMAIN_SOUND_MODEL_ICH9) {
char *codecstr = NULL;
size_t i;
for (i = 0; i < def->nvideos; i++) {
- char *str = NULL;
+ VIR_AUTOFREE(char *) str = NULL;
virDomainVideoDefPtr video = def->videos[i];
if (video->type == VIR_DOMAIN_VIDEO_TYPE_NONE)
return -1;
virCommandAddArg(cmd, str);
- VIR_FREE(str);
} else {
if (qemuBuildVgaVideoCommand(cmd, video, qemuCaps) < 0)
return -1;
return -1;
virCommandAddArg(cmd, str);
- VIR_FREE(str);
}
}
for (i = 0; i < def->nhubs; i++) {
virDomainHubDefPtr hub = def->hubs[i];
- char *optstr;
+ VIR_AUTOFREE(char *) optstr = NULL;
virCommandAddArg(cmd, "-device");
if (!(optstr = qemuBuildHubDevStr(def, hub, qemuCaps)))
return -1;
virCommandAddArg(cmd, optstr);
- VIR_FREE(optstr);
}
return 0;
{
char *ret = NULL;
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- char *netsource = NULL;
+ VIR_AUTOFREE(char *) netsource = NULL;
VIR_AUTOPTR(virJSONValue) srcprops = NULL;
virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
ret = virBufferContentAndReset(&buf);
cleanup:
- VIR_FREE(netsource);
return ret;
}
virQEMUCapsPtr qemuCaps)
{
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- char *source = NULL;
- char *drivealias = NULL;
+ VIR_AUTOFREE(char *) source = NULL;
+ VIR_AUTOFREE(char *) drivealias = NULL;
virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
goto error;
virBufferAsprintf(&buf, "file=/dev/%s,if=none,format=raw", source);
}
- VIR_FREE(source);
if (!(drivealias = qemuAliasFromHostdev(dev)))
goto error;
virBufferAsprintf(&buf, ",id=%s", drivealias);
- VIR_FREE(drivealias);
if (dev->readonly)
virBufferAddLit(&buf, ",readonly=on");
{
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int model = -1;
- char *driveAlias;
+ VIR_AUTOFREE(char *) driveAlias = NULL;
const char *contAlias;
model = qemuDomainFindSCSIControllerModel(def, dev->info);
if (!(driveAlias = qemuAliasFromHostdev(dev)))
goto error;
virBufferAsprintf(&buf, ",drive=%s,id=%s", driveAlias, dev->info->alias);
- VIR_FREE(driveAlias);
if (dev->info->bootIndex)
virBufferAsprintf(&buf, ",bootindex=%u", dev->info->bootIndex);
const char *appendarg, int appendval)
{
if (logManager) {
- char *fdset, *fdpath;
+ VIR_AUTOFREE(char *) fdset = NULL;
+ VIR_AUTOFREE(char *) fdpath = NULL;
int flags = 0;
int logfd;
virCommandAddArg(cmd, "-add-fd");
virCommandAddArg(cmd, fdset);
- VIR_FREE(fdset);
if (!(fdpath = qemuVirCommandGetDevSet(cmd, logfd)))
return -1;
virBufferAsprintf(buf, ",%s=%s,%s=on", filearg, fdpath, appendarg);
- VIR_FREE(fdpath);
} else {
virBufferAsprintf(buf, ",%s=", filearg);
virQEMUBuildBufferEscapeComma(buf, fileval);
qemuDomainChrSourcePrivatePtr chrSourcePriv = QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev);
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
bool telnet;
- char *charAlias = NULL;
+ VIR_AUTOFREE(char *) charAlias = NULL;
char *ret = NULL;
if (!(charAlias = qemuAliasChardevFromDevAlias(alias)))
qemuBuildChrChardevReconnectStr(&buf, &dev->data.tcp.reconnect);
if (dev->data.tcp.haveTLS == VIR_TRISTATE_BOOL_YES) {
- char *objalias = NULL;
+ VIR_AUTOFREE(char *) objalias = NULL;
const char *tlsCertEncSecAlias = NULL;
/* Add the secret object first if necessary. The
cfg->chardevTLSx509verify,
tlsCertEncSecAlias,
objalias, qemuCaps) < 0) {
- VIR_FREE(objalias);
goto cleanup;
}
virBufferAsprintf(&buf, ",tls-creds=%s", objalias);
- VIR_FREE(objalias);
}
break;
ret = virBufferContentAndReset(&buf);
cleanup:
- VIR_FREE(charAlias);
return ret;
}
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
char *ret = NULL;
- char *mdevPath = NULL;
+ VIR_AUTOFREE(char *) mdevPath = NULL;
const char *dev_str = NULL;
if (!(mdevPath = virMediatedDeviceGetSysfsPath(mdevsrc->uuidstr)))
ret = virBufferContentAndReset(&buf);
cleanup:
- VIR_FREE(mdevPath);
return ret;
}
for (i = 0; i < def->nhostdevs; i++) {
virDomainHostdevDefPtr hostdev = def->hostdevs[i];
virDomainHostdevSubsysPtr subsys = &hostdev->source.subsys;
- char *devstr;
+ VIR_AUTOFREE(char *) devstr = NULL;
if (hostdev->info->bootIndex) {
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
qemuBuildUSBHostdevDevStr(def, hostdev, qemuCaps)))
return -1;
virCommandAddArg(cmd, devstr);
- VIR_FREE(devstr);
}
/* PCI */
if (!devstr)
return -1;
virCommandAddArg(cmd, devstr);
- VIR_FREE(devstr);
}
/* SCSI */
if (virHostdevIsSCSIDevice(hostdev)) {
virDomainHostdevSubsysSCSIPtr scsisrc =
&hostdev->source.subsys.u.scsi;
- char *drvstr;
+ VIR_AUTOFREE(char *) drvstr = NULL;
if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc =
if (!(drvstr = qemuBuildSCSIHostdevDrvStr(hostdev, qemuCaps)))
return -1;
virCommandAddArg(cmd, drvstr);
- VIR_FREE(drvstr);
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildSCSIHostdevDevStr(def, hostdev)))
return -1;
virCommandAddArg(cmd, devstr);
- VIR_FREE(devstr);
}
/* SCSI_host */
subsys->type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST) {
if (hostdev->source.subsys.u.scsi_host.protocol ==
VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_HOST_PROTOCOL_TYPE_VHOST) {
- char *vhostfdName = NULL;
+ VIR_AUTOFREE(char *) vhostfdName = NULL;
int vhostfd = -1;
if (virSCSIVHostOpenVhostSCSI(&vhostfd) < 0)
if (!(devstr = qemuBuildSCSIVHostHostdevDevStr(def,
hostdev,
qemuCaps,
- vhostfdName))) {
- VIR_FREE(vhostfdName);
+ vhostfdName)))
return -1;
- }
- virCommandAddArg(cmd, devstr);
- VIR_FREE(vhostfdName);
- VIR_FREE(devstr);
+ virCommandAddArg(cmd, devstr);
}
}
qemuBuildHostdevMediatedDevStr(def, hostdev, qemuCaps)))
return -1;
virCommandAddArg(cmd, devstr);
- VIR_FREE(devstr);
}
}
virDomainDefPtr def,
qemuDomainObjPrivatePtr priv)
{
- char *chrdev;
+ VIR_AUTOFREE(char *) chrdev = NULL;
unsigned int cdevflags = QEMU_BUILD_CHARDEV_TCP_NOWAIT |
QEMU_BUILD_CHARDEV_UNIX_FD_PASS;
if (priv->chardevStdioLogd)
return -1;
virCommandAddArg(cmd, "-chardev");
virCommandAddArg(cmd, chrdev);
- VIR_FREE(chrdev);
virCommandAddArg(cmd, "-mon");
virCommandAddArg(cmd, "chardev=charmonitor,id=monitor,mode=control");
virQEMUCapsPtr qemuCaps,
virJSONValuePtr *props)
{
- char *objAlias = NULL;
- char *charBackendAlias = NULL;
+ VIR_AUTOFREE(char *) objAlias = NULL;
+ VIR_AUTOFREE(char *) charBackendAlias = NULL;
int ret = -1;
if (virAsprintf(&objAlias, "obj%s", rng->info.alias) < 0)
ret = 0;
cleanup:
- VIR_FREE(objAlias);
- VIR_FREE(charBackendAlias);
return ret;
}
virQEMUCapsPtr qemuCaps)
{
size_t i;
- char *rtcopt;
+ VIR_AUTOFREE(char *) rtcopt = NULL;
virCommandAddArg(cmd, "-rtc");
if (!(rtcopt = qemuBuildClockArgStr(&def->clock)))
return -1;
virCommandAddArg(cmd, rtcopt);
- VIR_FREE(rtcopt);
if (def->clock.offset == VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE &&
def->clock.data.timezone) {
virQEMUCapsPtr qemuCaps)
{
VIR_AUTOCLEAN(virBuffer) boot_buf = VIR_BUFFER_INITIALIZER;
- char *boot_opts_str = NULL;
+ VIR_AUTOFREE(char *) boot_opts_str = NULL;
if (def->os.bootmenu) {
if (def->os.bootmenu == VIR_TRISTATE_BOOL_YES)
virCommandAddArg(cmd, "-boot");
virCommandAddArg(cmd, boot_opts_str);
}
- VIR_FREE(boot_opts_str);
if (def->os.kernel)
virCommandAddArgList(cmd, "-kernel", def->os.kernel, NULL);
return 0;
error:
- VIR_FREE(boot_opts_str);
return -1;
}
virQEMUCapsPtr qemuCaps)
{
virArch hostarch = virArchFromHost();
- char *cpu = NULL, *cpu_flags = NULL;
+ VIR_AUTOFREE(char *) cpu = NULL;
+ VIR_AUTOFREE(char *) cpu_flags = NULL;
int ret = -1;
VIR_AUTOCLEAN(virBuffer) cpu_buf = VIR_BUFFER_INITIALIZER;
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
ret = 0;
cleanup:
- VIR_FREE(cpu);
- VIR_FREE(cpu_flags);
return ret;
}
qemuBuildSmpCommandLine(virCommandPtr cmd,
virDomainDefPtr def)
{
- char *smp;
+ char *smp = NULL;
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
unsigned int maxvcpus = virDomainDefGetVcpusMax(def);
unsigned int nvcpus = 0;
qemuDomainObjPrivatePtr priv)
{
const long system_page_size = virGetSystemPageSizeKB();
- char *mem_path = NULL;
+ VIR_AUTOFREE(char *) mem_path = NULL;
/* There are two cases where we want to put -mem-path onto
* the command line: First one is when there are no guest
}
virCommandAddArgList(cmd, "-mem-path", mem_path, NULL);
- VIR_FREE(mem_path);
return 0;
}
int **nicindexes)
{
int ret = -1;
- char *nic = NULL;
- char *host = NULL;
- char *chardev = NULL;
+ VIR_AUTOFREE(char *) nic = NULL;
+ VIR_AUTOFREE(char *) host = NULL;
+ VIR_AUTOFREE(char *) chardev = NULL;
int *tapfd = NULL;
size_t tapfdSize = 0;
int *vhostfd = NULL;
VIR_FREE(tapfdName);
VIR_FREE(vhostfd);
VIR_FREE(tapfd);
- VIR_FREE(chardev);
- VIR_FREE(host);
- VIR_FREE(nic);
return ret;
}
{
size_t i;
virDomainSmartcardDefPtr smartcard;
- char *devstr;
+ VIR_AUTOFREE(char *) devstr = NULL;
VIR_AUTOCLEAN(virBuffer) opt = VIR_BUFFER_INITIALIZER;
const char *database;
const char *contAlias = NULL;
}
virCommandAddArg(cmd, "-chardev");
virCommandAddArg(cmd, devstr);
- VIR_FREE(devstr);
virBufferAsprintf(&opt, "ccid-card-passthru,chardev=char%s",
smartcard->info.alias);
virJSONValuePtr
qemuBuildShmemBackendMemProps(virDomainShmemDefPtr shmem)
{
- char *mem_alias = NULL;
- char *mem_path = NULL;
+ VIR_AUTOFREE(char *) mem_alias = NULL;
+ VIR_AUTOFREE(char *) mem_path = NULL;
virJSONValuePtr ret = NULL;
if (virAsprintf(&mem_path, "/dev/shm/%s", shmem->name) < 0)
NULL);
cleanup:
- VIR_FREE(mem_alias);
- VIR_FREE(mem_path);
return ret;
}
virDomainChrDefPtr chr,
virQEMUCapsPtr qemuCaps)
{
- char *devstr = NULL;
+ VIR_AUTOFREE(char *) devstr = NULL;
if (qemuBuildChrDeviceStr(&devstr, def, chr, qemuCaps) < 0)
return -1;
virCommandAddArgList(cmd, "-device", devstr, NULL);
- VIR_FREE(devstr);
return 0;
}
for (i = 0; i < def->nserials; i++) {
virDomainChrDefPtr serial = def->serials[i];
- char *devstr;
+ VIR_AUTOFREE(char *) devstr = NULL;
if (serial->source->type == VIR_DOMAIN_CHR_TYPE_SPICEPORT && !havespice)
continue;
return -1;
virCommandAddArg(cmd, "-chardev");
virCommandAddArg(cmd, devstr);
- VIR_FREE(devstr);
/* If the device is not a platform device, build the devstr */
if (!qemuChrIsPlatformDevice(def, serial)) {
for (i = 0; i < def->nparallels; i++) {
virDomainChrDefPtr parallel = def->parallels[i];
- char *devstr;
+ VIR_AUTOFREE(char *) devstr = NULL;
if (!(devstr = qemuBuildChrChardevStr(logManager, secManager,
cmd, cfg, def,
return -1;
virCommandAddArg(cmd, "-chardev");
virCommandAddArg(cmd, devstr);
- VIR_FREE(devstr);
if (qemuBuildChrDeviceCommandLine(cmd, def, parallel,
qemuCaps) < 0)
{
const virDomainTPMDef *tpm = def->tpm;
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- char *cancel_path = NULL;
- char *devset = NULL;
- char *cancelset = NULL;
+ VIR_AUTOFREE(char *) cancel_path = NULL;
+ VIR_AUTOFREE(char *) devset = NULL;
+ VIR_AUTOFREE(char *) cancelset = NULL;
const char *tpmdev;
*tpmfd = -1;
virBufferAddLit(&buf, ",cancel-path=");
virQEMUBuildBufferEscapeComma(&buf, cancelset);
- VIR_FREE(devset);
- VIR_FREE(cancelset);
- VIR_FREE(cancel_path);
-
break;
case VIR_DOMAIN_TPM_TYPE_EMULATOR:
virBufferAddLit(&buf, ",chardev=chrtpm");
return virBufferContentAndReset(&buf);
error:
- VIR_FREE(devset);
- VIR_FREE(cancel_path);
return NULL;
}
virQEMUCapsPtr qemuCaps)
{
char *optstr;
- char *chardev = NULL;
+ VIR_AUTOFREE(char *) chardev = NULL;
int tpmfd = -1;
int cancelfd = -1;
char *fdset;
virCommandAddArgList(cmd, "-tpmdev", optstr, NULL);
VIR_FREE(optstr);
- if (chardev) {
+ if (chardev)
virCommandAddArgList(cmd, "-chardev", chardev, NULL);
- VIR_FREE(chardev);
- }
if (tpmfd >= 0) {
fdset = qemuVirCommandGetFDSet(cmd, tpmfd);
virJSONValuePtr
qemuBuildPRManagedManagerInfoProps(qemuDomainObjPrivatePtr priv)
{
- char *path = NULL;
+ VIR_AUTOFREE(char *) path = NULL;
virJSONValuePtr ret = NULL;
if (!(path = qemuDomainGetManagedPRSocketPath(priv)))
ret = qemuBuildPRManagerInfoPropsInternal(qemuDomainGetManagedPRAlias(),
path);
- VIR_FREE(path);
return ret;
}
virQEMUCapsPtr qemuCaps)
{
qemuDomainVsockPrivatePtr priv = (qemuDomainVsockPrivatePtr)vsock->privateData;
- char *devstr = NULL;
+ VIR_AUTOFREE(char *) devstr = NULL;
int ret = -1;
if (!(devstr = qemuBuildVsockDevStr(def, vsock, qemuCaps, "")))
ret = 0;
cleanup:
- VIR_FREE(devstr);
return ret;
}
virDomainChrDefPtr chr)
{
int ret = -1;
- char *addr = NULL;
+ VIR_AUTOFREE(char *) addr = NULL;
int port;
switch ((virDomainChrChannelTargetType)chr->targetType) {
ret = 0;
cleanup:
- VIR_FREE(addr);
return ret;
}
projects / libvirt.git / commitdiff