Remove unneeded, easy to remove goto labels (cleanup|error|done|...).
Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
Reviewed-by: Erik Skultety <eskultet@redhat.com>
if (hostarch == VIR_ARCH_AARCH64 && guestarch == VIR_ARCH_ARMV7L) {
archstr = virQEMUCapsArchToString(hostarch);
if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
- goto out;
+ return ret;
}
/* First attempt: try the guest architecture as it is */
archstr = virQEMUCapsArchToString(guestarch);
if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
- goto out;
+ return ret;
/* Second attempt: try looking up by target instead */
target = virQEMUCapsFindTarget(hostarch, guestarch);
if (target != guestarch) {
archstr = virQEMUCapsArchToString(target);
if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
- goto out;
+ return ret;
}
- out:
return ret;
}
qemuCaps->kvmSupportsNesting = virQEMUCapsKVMSupportsNesting();
}
- cleanup:
return qemuCaps;
error:
virObjectUnref(qemuCaps);
- qemuCaps = NULL;
- goto cleanup;
+ return NULL;
}
static void *
if (virQEMUCapsLoadCache(priv->hostArch, qemuCaps, filename) < 0)
goto error;
- cleanup:
return qemuCaps;
error:
virObjectUnref(qemuCaps);
- qemuCaps = NULL;
- goto cleanup;
+ return NULL;
}
disk->detect_zeroes);
if (qemuBuildDriveSourceStr(disk, qemuCaps, &opt) < 0)
- goto error;
+ return NULL;
if (!qemuDiskBusNeedsDriveArg(disk->bus)) {
g_autofree char *drivealias = qemuAliasDiskDriveFromDisk(disk);
if (!drivealias)
- goto error;
+ return NULL;
virBufferAddLit(&opt, "if=none");
virBufferAsprintf(&opt, ",id=%s", drivealias);
if (idx < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported disk type '%s'"), disk->dst);
- goto error;
+ return NULL;
}
/* if we are using -device this will be checked elsewhere */
if (qemuCheckDiskConfig(disk, qemuCaps) < 0)
- goto error;
+ return NULL;
virBufferAsprintf(&opt, "if=%s",
virDomainDiskQEMUBusTypeToString(disk->bus));
qemuBuildDiskThrottling(disk, &opt);
return virBufferContentAndReset(&opt);
-
- error:
- return NULL;
}
int controllerModel;
if (qemuCheckDiskConfig(disk, qemuCaps) < 0)
- goto error;
+ return NULL;
if (!qemuDomainCheckCCWS390AddressSupport(def, &disk->info, qemuCaps, disk->dst))
- goto error;
+ return NULL;
if (disk->iothread && !qemuCheckIOThreads(def, disk))
- goto error;
+ return NULL;
switch ((virDomainDiskBus) disk->bus) {
case VIR_DOMAIN_DISK_BUS_IDE:
if (disk->info.addr.drive.target != 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("target must be 0 for ide controller"));
- goto error;
+ return NULL;
}
if (disk->wwn &&
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Setting wwn for ide disk is not supported "
"by this QEMU"));
- goto error;
+ return NULL;
}
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
if (!(contAlias = virDomainControllerAliasFind(def,
VIR_DOMAIN_CONTROLLER_TYPE_IDE,
disk->info.addr.drive.controller)))
- goto error;
+ return NULL;
}
virBufferAsprintf(&opt, ",bus=%s.%d,unit=%d",
contAlias,
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support scsi-block for "
"lun passthrough"));
- goto error;
+ return NULL;
}
}
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Setting wwn for scsi disk is not supported "
"by this QEMU"));
- goto error;
+ return NULL;
}
/* Properties wwn, vendor and product were introduced in the
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Setting vendor or product for scsi disk is not "
"supported by this QEMU"));
- goto error;
+ return NULL;
}
controllerModel = qemuDomainFindSCSIControllerModel(def, &disk->info);
if (controllerModel < 0)
- goto error;
+ return NULL;
if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
virBufferAddLit(&opt, "scsi-block");
scsiVPDDeviceId = g_strdup(disk->serial);
} else {
if (!(scsiVPDDeviceId = qemuAliasDiskDriveFromDisk(disk)))
- goto error;
+ return NULL;
}
}
}
if (!(contAlias = virDomainControllerAliasFind(def, VIR_DOMAIN_CONTROLLER_TYPE_SCSI,
disk->info.addr.drive.controller)))
- goto error;
+ return NULL;
if (controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
if (disk->info.addr.drive.target != 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("target must be 0 for controller "
"model 'lsilogic'"));
- goto error;
+ return NULL;
}
virBufferAsprintf(&opt, ",bus=%s.%d,scsi-id=%d",
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support target "
"greater than 7"));
- goto error;
+ return NULL;
}
if (disk->info.addr.drive.bus != 0 &&
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU only supports both bus and "
"unit equal to 0"));
- goto error;
+ return NULL;
}
}
if (disk->info.addr.drive.bus != 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("bus must be 0 for ide controller"));
- goto error;
+ return NULL;
}
if (disk->info.addr.drive.target != 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("target must be 0 for ide controller"));
- goto error;
+ return NULL;
}
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
if (!(contAlias = virDomainControllerAliasFind(def,
VIR_DOMAIN_CONTROLLER_TYPE_SATA,
disk->info.addr.drive.controller)))
- goto error;
+ return NULL;
}
virBufferAsprintf(&opt, ",bus=%s.%d",
contAlias,
case VIR_DOMAIN_DISK_BUS_VIRTIO:
if (qemuBuildVirtioDevStr(&opt, "virtio-blk", qemuCaps,
VIR_DOMAIN_DEVICE_DISK, disk) < 0) {
- goto error;
+ return NULL;
}
if (disk->iothread)
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("num-queues property isn't supported by this "
"QEMU binary"));
- goto error;
+ return NULL;
}
virBufferAsprintf(&opt, ",num-queues=%u", disk->queues);
}
if (qemuBuildVirtioOptionsStr(&opt, disk->virtio, qemuCaps) < 0)
- goto error;
+ return NULL;
if (qemuBuildDeviceAddressStr(&opt, def, &disk->info, qemuCaps) < 0)
- goto error;
+ return NULL;
break;
case VIR_DOMAIN_DISK_BUS_USB:
disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("unexpected address type for usb disk"));
- goto error;
+ return NULL;
}
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support '-device "
"usb-storage'"));
- goto error;
+ return NULL;
}
virBufferAddLit(&opt, "usb-storage");
if (qemuBuildDeviceAddressStr(&opt, def, &disk->info, qemuCaps) < 0)
- goto error;
+ return NULL;
break;
case VIR_DOMAIN_DISK_BUS_FDC:
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported disk bus '%s' with device setup"), bus);
- goto error;
+ return NULL;
}
if (disk->src->shared &&
virBufferAddLit(&opt, ",share-rw=on");
if (qemuDomainDiskGetBackendAlias(disk, qemuCaps, &backendAlias) < 0)
- goto error;
+ return NULL;
if (backendAlias)
virBufferAsprintf(&opt, ",drive=%s", backendAlias);
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support setting the "
"removable flag of USB storage devices"));
- goto error;
+ return NULL;
}
}
}
if (qemuBuildDriveDevCacheStr(disk, &opt, qemuCaps) < 0)
- goto error;
+ return NULL;
qemuBuildDiskFrontendAttributes(disk, &opt);
qemuBuildDiskFrontendAttributeErrorPolicy(disk, &opt);
return virBufferContentAndReset(&opt);
-
- error:
- return NULL;
}
char *
if (virDomainNetIsVirtioModel(net)) {
if (qemuBuildVirtioDevStr(&buf, "virtio-net", qemuCaps,
VIR_DOMAIN_DEVICE_NET, net) < 0) {
- goto error;
+ return NULL;
}
usingVirtio = true;
*/
virReportEnumRangeError(virDomainNetVirtioTxModeType,
net->driver.virtio.txmode);
- goto error;
+ return NULL;
}
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio-net-pci 'tx' option not supported in this QEMU binary"));
- goto error;
+ return NULL;
}
}
if (usingVirtio) {
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_NET_RX_QUEUE_SIZE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio rx_queue_size option is not supported with this QEMU binary"));
- goto error;
+ return NULL;
}
virBufferAsprintf(&buf, ",rx_queue_size=%u", net->driver.virtio.rx_queue_size);
}
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_NET_TX_QUEUE_SIZE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio tx_queue_size option is not supported with this QEMU binary"));
- goto error;
+ return NULL;
}
virBufferAsprintf(&buf, ",tx_queue_size=%u", net->driver.virtio.tx_queue_size);
}
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_NET_HOST_MTU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("setting MTU is not supported with this QEMU binary"));
- goto error;
+ return NULL;
}
virBufferAsprintf(&buf, ",host_mtu=%u", net->mtu);
}
virMacAddrFormat(&net->mac, macaddr));
if (qemuBuildDeviceAddressStr(&buf, def, &net->info, qemuCaps) < 0)
- goto error;
+ return NULL;
if (qemuBuildRomStr(&buf, &net->info) < 0)
- goto error;
+ return NULL;
if (bootindex)
virBufferAsprintf(&buf, ",bootindex=%u", bootindex);
if (usingVirtio &&
qemuBuildVirtioOptionsStr(&buf, net->virtio, qemuCaps) < 0)
- goto error;
+ return NULL;
return virBufferContentAndReset(&buf);
-
- error:
- return NULL;
}
/* prefer the hard limit */
if (virMemoryLimitIsSet(def->mem.hard_limit)) {
memKB = def->mem.hard_limit;
- goto done;
+ return memKB << 10;
}
/* If the guest wants its memory to be locked, we need to raise the memory
if (usesVFIO || forceVFIO)
memKB = virDomainDefGetMemoryTotal(def) + 1024 * 1024;
- done:
return memKB << 10;
}
bool forceVFIO)
{
unsigned long long bytes = 0;
- int ret = -1;
bytes = qemuDomainGetMemLockLimitBytes(vm->def, forceVFIO);
/* Trying to set the memory locking limit to zero is a no-op */
if (virProcessSetMaxMemLock(vm->pid, bytes) < 0)
- goto out;
-
- ret = 0;
+ return -1;
- out:
- return ret;
+ return 0;
}
/* Only PCI host devices are subject to isolation */
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
- goto skip;
+ return 0;
}
hostAddr = &hostdev->source.subsys.u.pci.addr;
/* If a non-default isolation has already been assigned to the
* device, we can avoid looking up the information again */
if (info->isolationGroup > 0)
- goto skip;
+ return 0;
/* The isolation group depends on the IOMMU group assigned by the host */
tmp = virPCIDeviceAddressGetIOMMUGroupNum(hostAddr);
"%04x:%02x:%02x.%x, device won't be isolated",
hostAddr->domain, hostAddr->bus,
hostAddr->slot, hostAddr->function);
- goto skip;
+ return 0;
}
/* The isolation group for a host device is its IOMMU group,
* require us to isolate the guest device, so we can skip them */
if (iface->type != VIR_DOMAIN_NET_TYPE_NETWORK ||
virDomainNetResolveActualType(iface) != VIR_DOMAIN_NET_TYPE_HOSTDEV) {
- goto skip;
+ return 0;
}
/* If a non-default isolation has already been assigned to the
* device, we can avoid looking up the information again */
if (info->isolationGroup > 0)
- goto skip;
+ return 0;
/* Obtain a synthetic isolation group for the device, since at this
* point in time we don't have access to the IOMMU group of the host
"configured to use hostdev-backed network '%s', "
"device won't be isolated",
iface->data.network.name);
- goto skip;
+ return 0;
}
info->isolationGroup = tmp;
iface->data.network.name, info->isolationGroup);
}
- skip:
return 0;
}
continue;
if (qemuDomainPCIAddressReserveNextAddr(addrs, &cont->info) < 0)
- goto error;
+ return -1;
}
}
/* Only support VirtIO-9p-pci so far. If that changes,
* we might need to skip devices here */
if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->fss[i]->info) < 0)
- goto error;
+ return -1;
}
/* Network interfaces */
}
if (qemuDomainPCIAddressReserveNextAddr(addrs, &net->info) < 0)
- goto error;
+ return -1;
}
/* Sound cards */
}
if (qemuDomainPCIAddressReserveNextAddr(addrs, &sound->info) < 0)
- goto error;
+ return -1;
}
/* Device controllers (SCSI, USB, but not IDE, FDC or CCID) */
if (virDomainPCIAddressReserveAddr(addrs, &addr,
cont->info.pciConnectFlags,
cont->info.isolationGroup) < 0) {
- goto error;
+ return -1;
}
cont->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
if (virDomainPCIAddressReserveNextAddr(addrs, &cont->info,
cont->info.pciConnectFlags,
addr.function) < 0) {
- goto error;
+ return -1;
}
cont->info.addr.pci.multi = addr.multi;
}
} else {
if (qemuDomainPCIAddressReserveNextAddr(addrs, &cont->info) < 0)
- goto error;
+ return -1;
}
}
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("virtio disk cannot have an address of type '%s'"),
virDomainDeviceAddressTypeToString(def->disks[i]->info.type));
- goto error;
+ return -1;
}
if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->disks[i]->info) < 0)
- goto error;
+ return -1;
}
/* Host PCI devices */
if (qemuDomainPCIAddressReserveNextAddr(addrs,
def->hostdevs[i]->info) < 0)
- goto error;
+ return -1;
}
/* memballoon. the qemu driver only accepts virtio memballoon devices */
virDeviceInfoPCIAddressIsWanted(&def->memballoon->info)) {
if (qemuDomainPCIAddressReserveNextAddr(addrs,
&def->memballoon->info) < 0)
- goto error;
+ return -1;
}
/* the qemu driver only accepts virtio rng devices */
continue;
if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->rngs[i]->info) < 0)
- goto error;
+ return -1;
}
/* A watchdog - check if it is a PCI device */
def->watchdog->model == VIR_DOMAIN_WATCHDOG_MODEL_I6300ESB &&
virDeviceInfoPCIAddressIsWanted(&def->watchdog->info)) {
if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->watchdog->info) < 0)
- goto error;
+ return -1;
}
/* Video devices */
continue;
if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->videos[i]->info) < 0)
- goto error;
+ return -1;
}
/* Shared Memory */
continue;
if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->shmems[i]->info) < 0)
- goto error;
+ return -1;
}
for (i = 0; i < def->ninputs; i++) {
if (def->inputs[i]->bus != VIR_DOMAIN_INPUT_BUS_VIRTIO ||
continue;
if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->inputs[i]->info) < 0)
- goto error;
+ return -1;
}
for (i = 0; i < def->nparallels; i++) {
/* Nada - none are PCI based (yet) */
continue;
if (qemuDomainPCIAddressReserveNextAddr(addrs, &chr->info) < 0)
- goto error;
+ return -1;
}
for (i = 0; i < def->nchannels; i++) {
/* Nada - none are PCI based (yet) */
if (qemuDomainPCIAddressReserveNextAddr(addrs,
&def->vsock->info) < 0)
- goto error;
+ return -1;
}
return 0;
-
- error:
- return -1;
}
if (qemuDomainObjBeginAgentJob(driver, vm,
QEMU_AGENT_JOB_MODIFY) < 0)
- goto cleanup;
+ return -1;
if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
virReportError(VIR_ERR_OPERATION_INVALID,
endjob:
qemuDomainObjEndAgentJob(vm);
-
- cleanup:
return ret;
}
priv = vm->privateData;
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
- goto cleanup;
+ return -1;
if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
virReportError(VIR_ERR_OPERATION_INVALID,
endjob:
qemuDomainObjEndJob(driver, vm);
-
- cleanup:
return ret;
}
*ret_def = def;
*ret_data = data;
- cleanup:
return fd;
error:
virDomainDefFree(def);
virQEMUSaveDataFree(data);
VIR_FORCE_CLOSE(fd);
- goto cleanup;
+ return -1;
}
static int ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5) ATTRIBUTE_NONNULL(6)
{
virQEMUDriverPtr driver = dconn->privateData;
virDomainObjPtr vm;
- virDomainPtr dom = NULL;
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
virReportError(VIR_ERR_NO_DOMAIN,
_("no domain with matching name '%s'"), dname);
qemuMigrationDstErrorReport(driver, dname);
- goto cleanup;
+ return NULL;
}
if (virDomainMigrateFinish2EnsureACL(dconn, vm->def) < 0) {
virDomainObjEndAPI(&vm);
- goto cleanup;
+ return NULL;
}
/* Do not use cookies in v2 protocol, since the cookie
* length was not sufficiently large, causing failures
* migrating between old & new libvirtd
*/
- dom = qemuMigrationDstFinish(driver, dconn, vm,
- NULL, 0, NULL, NULL, /* No cookies */
- flags, retcode, false);
-
- cleanup:
- return dom;
+ return qemuMigrationDstFinish(driver, dconn, vm,
+ NULL, 0, NULL, NULL, /* No cookies */
+ flags, retcode, false);
}
unsigned *function)
{
virNodeDevCapsDefPtr cap;
- int ret = -1;
cap = def->caps;
while (cap) {
if (!cap) {
virReportError(VIR_ERR_INVALID_ARG,
_("device %s is not a PCI device"), def->name);
- goto out;
+ return -1;
}
- ret = 0;
- out:
- return ret;
+ return 0;
}
static int
virQEMUCapsPtr qemuCaps,
unsigned int flags)
{
- int ret = -1;
virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
if (!qemuHostdevPreparePCIDevicesCheckSupport(hostdevs, nhostdevs, qemuCaps))
- goto out;
+ return -1;
- ret = virHostdevPreparePCIDevices(hostdev_mgr, QEMU_DRIVER_NAME,
- name, uuid, hostdevs,
- nhostdevs, flags);
- out:
- return ret;
+ return virHostdevPreparePCIDevices(hostdev_mgr, QEMU_DRIVER_NAME,
+ name, uuid, hostdevs,
+ nhostdevs, flags);
}
int
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
if (qemuDomainAttachHostPCIDevice(driver, vm,
hostdev) < 0)
- goto error;
+ return -1;
break;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
if (qemuDomainAttachHostUSBDevice(driver, vm,
hostdev) < 0)
- goto error;
+ return -1;
break;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI:
if (qemuDomainAttachHostSCSIDevice(driver, vm,
hostdev) < 0)
- goto error;
+ return -1;
break;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST:
if (qemuDomainAttachSCSIVHostDevice(driver, vm, hostdev) < 0)
- goto error;
+ return -1;
break;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_MDEV:
if (qemuDomainAttachMediatedDevice(driver, vm, hostdev) < 0)
- goto error;
+ return -1;
break;
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("hotplug is not supported for hostdev subsys type '%s'"),
virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
- goto error;
+ return -1;
}
return 0;
-
- error:
- return -1;
}
VIR_FREE(interfaces);
- cleanup:
return optr;
error:
VIR_FREE(interfaces);
qemuMigrationCookieNetworkFree(optr);
- optr = NULL;
- goto cleanup;
+ return NULL;
}
VIR_XPATH_NODE_AUTORESTORE(ctxt);
if (!(ctxt->node = virXPathNode("./statistics", ctxt)))
- goto cleanup;
+ return NULL;
if (VIR_ALLOC(jobInfo) < 0)
- goto cleanup;
+ return NULL;
stats = &jobInfo->stats.mig;
jobInfo->status = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
virXPathInt("string(./" VIR_DOMAIN_JOB_AUTO_CONVERGE_THROTTLE "[1])",
ctxt, &stats->cpu_throttle_percentage);
- cleanup:
+
return jobInfo;
}
virReportError(VIR_ERR_INVALID_ARG,
_("Unsupported compression method '%s'"),
params[i].value.s);
- goto error;
+ return -1;
}
if (migParams->compMethods & (1ULL << method)) {
virReportError(VIR_ERR_INVALID_ARG,
_("Compression method '%s' is specified twice"),
params[i].value.s);
- goto error;
+ return -1;
}
migParams->compMethods |= 1ULL << method;
!(migParams->compMethods & (1ULL << QEMU_MIGRATION_COMPRESS_MT))) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("Turn multithread compression on to tune it"));
- goto error;
+ return -1;
}
if (migParams->params[QEMU_MIGRATION_PARAM_XBZRLE_CACHE_SIZE].set &&
!(migParams->compMethods & (1ULL << QEMU_MIGRATION_COMPRESS_XBZRLE))) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("Turn xbzrle compression on to tune it"));
- goto error;
+ return -1;
}
if (!migParams->compMethods && (flags & VIR_MIGRATE_COMPRESSED)) {
}
return 0;
-
- error:
- return -1;
}
projects / thirdparty / libvirt.git / commitdiff
