return monfd;
-error:
+ error:
VIR_FORCE_CLOSE(monfd);
return -1;
}
return monfd;
-error:
+ error:
VIR_FORCE_CLOSE(monfd);
return -1;
}
_("Unknown JSON reply '%s'"), line);
}
-cleanup:
+ cleanup:
virJSONValueFree(obj);
return ret;
}
return mon;
-cleanup:
+ cleanup:
/* We don't want the 'destroy' callback invoked during
* cleanup from construction failure, because that can
* give a double-unref on virDomainObjPtr in the caller,
ret = 0;
-cleanup:
+ cleanup:
mon->msg = NULL;
qemuAgentUpdateWatch(mon);
}
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(sync_msg.rxObject);
VIR_FREE(sync_msg.txBuffer);
return ret;
}
}
-cleanup:
+ cleanup:
VIR_FREE(cmdstr);
VIR_FREE(msg.txBuffer);
return obj;
-error:
+ error:
virJSONValueFree(obj);
virJSONValueFree(jargs);
va_end(args);
_("malformed return value"));
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
_("malformed return value"));
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = -1;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = ndata;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
_("malformed return value"));
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
virJSONValueFree(cpu);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(output);
virCommandFree(cmd);
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(output);
virCommandFree(cmd);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(binary);
VIR_FREE(kvmbin);
virObjectUnref(qemubinCaps);
return ret;
-error:
+ error:
virCapabilitiesFreeMachines(machines, nmachines);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
cpuDataFree(data);
return ret;
-error:
+ error:
virCPUDefFree(cpu);
goto cleanup;
}
return caps;
-error:
+ error:
virObjectUnref(caps);
return NULL;
}
return 0;
-fail:
+ fail:
p = strchr(help, '\n');
if (!p)
p = strchr(help, '\0');
_("cannot parse %s version number in '%.*s'"),
qemu, (int) (p - help), help);
-cleanup:
+ cleanup:
return -1;
}
*types = typelist;
ret = ntypelist;
-cleanup:
+ cleanup:
if (ret < 0)
virQEMUCapsFreeStringList(ntypelist, typelist);
return ret;
*props = proplist;
ret = nproplist;
-cleanup:
+ cleanup:
if (ret < 0)
virQEMUCapsFreeStringList(nproplist, proplist);
return ret;
ret = virQEMUCapsParseDeviceStr(qemuCaps, output);
-cleanup:
+ cleanup:
VIR_FREE(output);
virCommandFree(cmd);
return ret;
return qemuCaps;
-error:
+ error:
virObjectUnref(qemuCaps);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return 0;
-error:
+ error:
virCapabilitiesFreeMachines(*machines, *nmachines);
*nmachines = 0;
*machines = NULL;
ret = 0;
-cleanup:
+ cleanup:
for (i = 0; i < nmachines; i++)
qemuMonitorMachineInfoFree(machines[i]);
VIR_FREE(machines);
VIR_FREE(nodes);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(str);
VIR_FREE(nodes);
xmlXPathFreeContext(ctxt);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(help);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(archstr);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(package);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
if (mon)
virObjectUnlock(mon);
qemuMonitorClose(mon);
return qemuCaps;
-error:
+ error:
virObjectUnref(qemuCaps);
qemuCaps = NULL;
return NULL;
return cache;
-error:
+ error:
virQEMUCapsCacheFree(cache);
return NULL;
}
}
ret = 0;
-cleanup:
+ cleanup:
virPCIDeviceFree(pci);
virUSBDeviceFree(usb);
virSCSIDeviceFree(scsi);
}
ret = 0;
-cleanup:
+ cleanup:
virPCIDeviceFree(pci);
VIR_FREE(path);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(mem_mask);
VIR_FREE(cpu_mask);
return ret;
goto cleanup;
}
-done:
+ done:
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
&priv->cgroup) < 0)
goto cleanup;
-done:
+ done:
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(caps);
return ret;
}
return 0;
-error:
+ error:
if (period) {
virErrorPtr saved = virSaveLastError();
ignore_value(virCgroupSetCpuCfsPeriod(cgroup, old_period));
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(new_cpus);
return ret;
}
return 0;
-cleanup:
+ cleanup:
if (cgroup_vcpu) {
virCgroupRemove(cgroup_vcpu);
virCgroupFree(&cgroup_vcpu);
virBitmapFree(cpumap);
return 0;
-cleanup:
+ cleanup:
virBitmapFree(cpumap);
if (cgroup_emulator) {
virObjectUnref(cfg);
return rc;
-error:
+ error:
ignore_value(virNetDevMacVLanDeleteWithVPortProfile(
res_ifname, &net->mac,
virDomainNetGetActualDirectDev(net),
*tapfd = -1;
}
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FORCE_CLOSE(pair[0]);
return *tapfd < 0 ? -1 : 0;
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0) {
size_t i;
for (i = 0; i < *tapfdSize && tapfd[i] >= 0; i++)
virDomainAuditNetDevice(def, net, "/dev/vhost-net", *vhostfdSize);
return 0;
-error:
+ error:
while (i--)
VIR_FORCE_CLOSE(vhostfd[i]);
}
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(addr);
return ret;
}
addrs->next.assigned = 0;
return addrs;
-error:
+ error:
qemuDomainCCWAddressSetFree(addrs);
return NULL;
}
}
ret = 0;
-cleanup:
+ cleanup:
qemuDomainCCWAddressSetFree(addrs);
return ret;
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
qemuDomainPCIAddressSetFree(addrs);
return ret;
return addrs;
-error:
+ error:
qemuDomainPCIAddressSetFree(addrs);
return NULL;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(addrStr);
return ret;
}
ret = qemuDomainPCIAddressReserveNextSlot(addrs, dev, flags);
}
-cleanup:
+ cleanup:
VIR_FREE(addrStr);
return ret;
}
addrs->buses[addr->bus].slots[addr->slot] = 0;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(addrStr);
return ret;
}
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("No more available PCI slots"));
-error:
+ error:
VIR_FREE(addrStr);
return -1;
-success:
+ success:
VIR_DEBUG("Found free PCI slot %.4x:%.2x:%.2x",
a.domain, a.bus, a.slot);
*next_addr = a;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(addrStr);
return ret;
}
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(addrStr);
return ret;
}
return 0;
-error:
+ error:
return -1;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(devStr);
return ret;
}
secret = base64;
}
-cleanup:
+ cleanup:
virObjectUnref(sec);
return secret;
}
return 0;
-error:
+ error:
VIR_FREE(disk->src.hosts[disk->src.nhosts-1].port);
VIR_FREE(disk->src.hosts[disk->src.nhosts-1].name);
return -1;
VIR_FREE(options);
return 0;
-error:
+ error:
VIR_FREE(options);
return -1;
}
def->src.nhosts = 1;
ret = 0;
-cleanup:
+ cleanup:
virURIFree(uri);
return ret;
-error:
+ error:
virDomainDiskHostDefClear(def->src.hosts);
VIR_FREE(def->src.hosts);
goto cleanup;
disk->src.hosts = h;
return 0;
-error:
+ error:
virDomainDiskHostDefClear(h);
VIR_FREE(h);
return -1;
goto cleanup;
}
-cleanup:
+ cleanup:
virBufferFreeAndReset(&buf);
virURIFree(uri);
secret,
source);
-cleanup:
+ cleanup:
VIR_FREE(secret);
return ret;
}
return virBufferContentAndReset(&opt);
-error:
+ error:
VIR_FREE(source);
virBufferFreeAndReset(&opt);
return NULL;
return virBufferContentAndReset(&opt);
-error:
+ error:
virBufferFreeAndReset(&opt);
return NULL;
}
return virBufferContentAndReset(&opt);
-error:
+ error:
virBufferFreeAndReset(&opt);
return NULL;
}
return virBufferContentAndReset(&opt);
-error:
+ error:
virBufferFreeAndReset(&opt);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
VIR_FREE(sg);
return virBufferContentAndReset(&buf);
-error:
+ error:
VIR_FREE(sg);
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
ret = 0;
-cleanup:
+ cleanup:
virBufferFreeAndReset(&buf);
VIR_FREE(backend);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virBufferFreeAndReset(&buf);
return ret;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(compare_msg);
cpuDataFree(data);
virCPUDefFree(guest);
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cpumask);
virBufferFreeAndReset(&buf);
return ret;
return 0;
-error:
+ error:
VIR_FREE(netAddr);
virBufferFreeAndReset(&opt);
return -1;
return 0;
-error:
+ error:
VIR_FREE(netAddr);
virBufferFreeAndReset(&opt);
return -1;
}
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0)
virDomainConfNWFilterTeardown(net);
for (i = 0; tapfd && i < tapfdSize && tapfd[i] >= 0; i++) {
virObjectUnref(cfg);
return cmd;
-error:
+ error:
virObjectUnref(cfg);
/* free up any resources in the network driver
* but don't overwrite the original error */
*deviceStr = virBufferContentAndReset(&cmd);
return 0;
-error:
+ error:
virBufferFreeAndReset(&cmd);
return -1;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(addr);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
return 0;
-error:
+ error:
VIR_FREE(progenv);
VIR_FREE(progargv);
virStringFreeList(arglist);
*retnkeywords = keywordCount;
return 0;
-error:
+ error:
for (i = 0; i < keywordCount; i++) {
VIR_FREE(keywords[i]);
VIR_FREE(values[i]);
/* fall through to "cleanup" */
}
-cleanup:
+ cleanup:
for (i = 0; i < nkeywords; i++) {
VIR_FREE(keywords[i]);
VIR_FREE(values[i]);
VIR_FREE(values);
return def;
-error:
+ error:
virDomainDiskDefFree(def);
def = NULL;
goto cleanup;
if (genmac)
virDomainNetGenerateMAC(xmlopt, &def->mac);
-cleanup:
+ cleanup:
for (i = 0; i < nkeywords; i++) {
VIR_FREE(keywords[i]);
VIR_FREE(values[i]);
return 0;
-error:
+ error:
return -1;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(model);
virStringFreeList(tokens);
virStringFreeList(hv_tokens);
return ret;
-syntax:
+ syntax:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unknown CPU syntax '%s'"), val);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
for (i = 0; i < nkws; i++) {
VIR_FREE(kws[i]);
VIR_FREE(vals[i]);
return ret;
-syntax:
+ syntax:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse CPU topology '%s'"), val);
-error:
+ error:
ret = -1;
goto cleanup;
}
return def;
-error:
+ error:
virDomainDiskDefFree(disk);
qemuDomainCmdlineDefFree(cmd);
virDomainDefFree(def);
def = qemuParseCommandLine(qemuCaps, xmlopt, progenv, progargv,
pidfile, monConfig, monJSON);
-cleanup:
+ cleanup:
virStringFreeList(progargv);
virStringFreeList(progenv);
ret = nstr-1;
*list = str;
-cleanup:
+ cleanup:
if (ret < 0)
virStringFreeList(str);
VIR_FREE(data);
VIR_FREE(def->emulator);
def->emulator = emulator;
-cleanup:
+ cleanup:
VIR_FREE(exepath);
virStringFreeList(progargv);
virStringFreeList(progenv);
return cfg;
-error:
+ error:
virObjectUnref(cfg);
return NULL;
}
ret = 0;
-cleanup:
+ cleanup:
virConfFree(conf);
return ret;
}
virObjectUnref(cfg);
return caps;
-error:
+ error:
VIR_FREE(sec_managers);
virObjectUnref(caps);
virObjectUnref(cfg);
}
ret = -1;
-cleanup:
+ cleanup:
VIR_FREE(sysfs_path);
VIR_FREE(key);
return ret;
return ret;
-cleanup:
+ cleanup:
qemuSharedDeviceEntryFree(ret, NULL);
return NULL;
}
}
ret = 0;
-cleanup:
+ cleanup:
qemuDriverUnlock(driver);
VIR_FREE(dev_name);
VIR_FREE(dev_path);
}
ret = 0;
-cleanup:
+ cleanup:
qemuDriverUnlock(driver);
VIR_FREE(dev_name);
VIR_FREE(dev_path);
virSetDeviceUnprivSGIO(path, NULL, val) < 0)
ret = -1;
-cleanup:
+ cleanup:
VIR_FREE(sysfs_path);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virStringFreeList(tokens);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0)
savedError = virSaveLastError();
if (pool)
return priv;
-error:
+ error:
VIR_FREE(priv);
return NULL;
}
return 0;
-error:
+ error:
virDomainChrSourceDefFree(priv->monConfig);
priv->monConfig = NULL;
VIR_FREE(nodes);
return 0;
-error:
+ error:
VIR_FREE(nodes);
qemuDomainDefNamespaceFree(cmd);
return -1;
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
virObjectRef(obj);
-retry:
+ retry:
if (cfg->maxQueuedJobs &&
priv->jobs_queued > cfg->maxQueuedJobs) {
goto error;
virObjectUnref(cfg);
return 0;
-error:
+ error:
VIR_WARN("Cannot start job (%s, %s) for domain %s;"
" current job is (%s, %s) owned by (%llu, %llu)",
qemuDomainJobTypeToString(job),
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
-cleanup:
+ cleanup:
VIR_FREE(xml);
virObjectUnref(caps);
return ret;
ret = virDomainDefFormatInternal(def, flags, buf);
-cleanup:
+ cleanup:
def->cpu = def_cpu;
virCPUDefFree(cpu);
if (controllers) {
goto cleanup;
}
-cleanup:
+ cleanup:
VIR_FREE(logfile);
return fd;
}
ret = 0;
-cleanup:
+ cleanup:
va_end(argptr);
if (fd != logFD)
ret = virXMLSaveFile(snapFile, NULL, "snapshot-edit", newxml);
-cleanup:
+ cleanup:
VIR_FREE(snapFile);
VIR_FREE(snapDir);
VIR_FREE(newxml);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(snapFile);
virObjectUnref(cfg);
return ret;
if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
VIR_WARN("Failed to save status on vm %s", vm->def->name);
-cleanup:
+ cleanup:
virObjectUnref(cfg);
}
return 0;
-error:
+ error:
return -1;
}
ret = 0;
-error:
+ error:
return ret;
}
if (!disk->backingChain)
ret = -1;
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
ret = virDomainDefCheckABIStability(migratableDefSrc, migratableDefDst);
-cleanup:
+ cleanup:
virDomainDefFree(migratableDefSrc);
virDomainDefFree(migratableDefDst);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(cfg);
virObjectUnref(cfg);
return 0;
-error:
+ error:
VIR_ERROR(_("Failed to initialize security drivers"));
virObjectUnref(stack);
virObjectUnref(mgr);
virResetLastError();
ret = 0;
-cleanup:
+ cleanup:
if (dir)
closedir(dir);
VIR_FREE(snapDir);
virNWFilterRegisterCallbackDriver(&qemuCallbackDriver);
return 0;
-error:
+ error:
virObjectUnref(conn);
VIR_FREE(driverConf);
VIR_FREE(membase);
caps, qemu_driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
qemuNotifyLoadDomain, qemu_driver);
-cleanup:
+ cleanup:
virObjectUnref(cfg);
virObjectUnref(caps);
return 0;
conn->privateData = qemu_driver;
ret = VIR_DRV_OPEN_SUCCESS;
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
* that 4 should be used as the maximum number of cpus */
ret = 4;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(fd);
return ret;
}
virReportOOMError();
virObjectUnref(caps);
-cleanup:
+ cleanup:
return xml;
}
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) dom->id = vm->def->id;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return dom;
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) dom->id = vm->def->id;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return dom;
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) dom->id = vm->def->id;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return dom;
ret = virDomainObjIsActive(obj);
-cleanup:
+ cleanup:
if (obj)
virObjectUnlock(obj);
return ret;
ret = obj->persistent;
-cleanup:
+ cleanup:
if (obj)
virObjectUnlock(obj);
return ret;
ret = obj->updated;
-cleanup:
+ cleanup:
if (obj)
virObjectUnlock(obj);
return ret;
*version = qemuVersion;
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(caps);
return ret;
}
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
virDomainDefFree(def);
if (vm)
virObjectUnlock(vm);
goto endjob;
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
goto endjob;
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (event)
qemuDomainObjExitMonitor(driver, vm);
}
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
qemuDomainSetFakeReboot(driver, vm, isReboot);
}
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
priv->fakeReboot = false;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
}
ret = 0;
-endjob:
+ endjob:
if (vm && !qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (event)
ignore_value(VIR_STRDUP(type, vm->def->os.type));
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return type;
ret = vm->def->mem.max_balloon;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
}
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
}
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
ret = qemuMonitorInjectNMI(priv->mon);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = qemuMonitorSendKey(priv->mon, holdtime, keycodes, nkeycodes);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
info->nrVirtCpu = vm->def->vcpus;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
*state = virDomainObjGetState(vm, reason);
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
_("failed to write xml to '%s'"), path);
goto endjob;
}
-endjob:
+ endjob:
return ret;
}
bypass_security = true;
}
}
-cleanup:
+ cleanup:
if (needUnlink)
*needUnlink = need_unlink;
if (bypassSecurityDriver)
*bypassSecurityDriver = bypass_security;
return fd;
-error:
+ error:
virReportSystemError(-fd, oflags & O_CREAT
? _("Failed to create file '%s'")
: _("Failed to open file '%s'"),
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(fd);
virFileWrapperFdFree(wrapperFd);
VIR_FREE(xml);
vm = NULL;
}
-endjob:
+ endjob:
if (vm) {
if (ret != 0) {
if (was_running && virDomainObjIsActive(vm)) {
vm = NULL;
}
-cleanup:
+ cleanup:
VIR_FREE(xml);
if (event)
qemuDomainEventQueue(driver, event);
dxml, flags);
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(cfg);
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
VIR_FREE(name);
vm->hasManagedSave = virFileExists(name);
ret = 0;
-cleanup:
+ cleanup:
virObjectUnlock(vm);
VIR_FREE(name);
return ret;
ret = vm->hasManagedSave;
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return ret;
}
vm->hasManagedSave = false;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(name);
virObjectUnlock(vm);
return ret;
ret = qemuMonitorDumpToFd(priv->mon, fd, dumpformat);
-cleanup:
+ cleanup:
qemuDomainObjExitMonitor(driver, vm);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(fd);
if (ret != 0)
unlink(path);
goto cleanup;
}
}
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
paused = true;
-endjob:
+ endjob:
if ((ret == 0) && (flags & VIR_DUMP_CRASH)) {
qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_CRASHED, 0);
virDomainAuditStop(vm, "crashed");
vm = NULL;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (event)
ignore_value(VIR_STRDUP(ret, "image/x-portable-pixmap"));
-endjob:
+ endjob:
VIR_FORCE_CLOSE(tmp_fd);
if (unlink_tmp)
unlink(tmp);
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(cfg);
goto cleanup;
}
-endjob:
+ endjob:
/* Safe to ignore value since ref count was incremented in
* qemuProcessHandleWatchdog().
*/
ignore_value(qemuDomainObjEndAsyncJob(driver, vm));
-cleanup:
+ cleanup:
virObjectUnref(cfg);
}
virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("Dump failed"));
-endjob:
+ endjob:
/* Safe to ignore value since ref count was incremented in
* qemuProcessHandleGuestPanic().
*/
ignore_value(qemuDomainObjEndAsyncJob(driver, vm));
-cleanup:
+ cleanup:
VIR_FREE(dumpfile);
virObjectUnref(cfg);
return ret;
break;
}
-cleanup:
+ cleanup:
virObjectUnref(cfg);
}
priv->vcpupids = cpupids;
cpupids = NULL;
-cleanup:
+ cleanup:
qemuDomainObjExitMonitor(driver, vm);
vm->def->vcpus = vcpus;
VIR_FREE(cpupids);
virCgroupFree(&cgroup_vcpu);
return ret;
-unsupported:
+ unsupported:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot change vcpu count of this domain"));
goto cleanup;
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
ret = 0;
-cleanup:
+ cleanup:
if (cgroup_vcpu)
virCgroupFree(&cgroup_vcpu);
if (vm)
}
ret = ncpumaps;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
ret = 0;
-cleanup:
+ cleanup:
if (cgroup_emulator)
virCgroupFree(&cgroup_emulator);
virBitmapFree(pcpumap);
ret = 1;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
}
ret = maxinfo;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ncpuinfo = qemuAgentGetVCPUs(priv->agent, &cpuinfo);
qemuDomainObjExitAgent(vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
VIR_FREE(mgrs);
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
}
strcpy(secmodel->doi, p);
-cleanup:
+ cleanup:
virObjectUnref(caps);
return ret;
}
return fd;
-error:
+ error:
virDomainDefFree(def);
VIR_FREE(xml);
VIR_FORCE_CLOSE(fd);
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(errbuf);
if (virSecurityManagerRestoreSavedStateLabel(driver->securityManager,
vm = NULL;
}
-cleanup:
+ cleanup:
virDomainDefFree(def);
VIR_FORCE_CLOSE(fd);
virFileWrapperFdFree(wrapperFd);
ret = qemuDomainDefFormatXML(driver, def, flags);
-cleanup:
+ cleanup:
virDomainDefFree(def);
VIR_FORCE_CLOSE(fd);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virDomainDefFree(def);
VIR_FORCE_CLOSE(fd);
VIR_FREE(xml);
if (virFileWrapperFdClose(wrapperFd) < 0)
VIR_WARN("Failed to close %s", path);
-cleanup:
+ cleanup:
virDomainDefFree(def);
VIR_FORCE_CLOSE(fd);
virFileWrapperFdFree(wrapperFd);
err = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm)) {
vm = NULL;
goto cleanup;
ret = qemuDomainFormatXML(driver, vm, flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
xml = qemuDomainDefFormatXML(driver, def, VIR_DOMAIN_XML_INACTIVE);
-cleanup:
+ cleanup:
virDomainDefFree(def);
virObjectUnref(caps);
return xml;
ret = virCommandToString(cmd);
-cleanup:
+ cleanup:
virObjectUnref(qemuCaps);
virCommandFree(cmd);
virConnectListDefinedDomainsCheckACL,
conn);
-cleanup:
+ cleanup:
return ret;
}
virConnectNumOfDefinedDomainsCheckACL,
conn);
-cleanup:
+ cleanup:
return ret;
}
}
}
-cleanup:
+ cleanup:
VIR_FREE(managed_save);
return ret;
}
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virNWFilterUnlockFilterUpdates();
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) dom->id = vm->def->id;
-cleanup:
+ cleanup:
virDomainDefFree(oldDef);
virDomainDefFree(def);
if (vm)
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(name);
if (vm)
virObjectUnlock(vm);
VIR_WARN("Failed to teardown cgroup for disk path %s",
NULLSTR(virDomainDiskGetSource(disk)));
-end:
+ end:
virObjectUnref(caps);
virDomainDeviceDefFree(dev_copy);
return ret;
}
}
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
virObjectUnref(qemuCaps);
virDomainDefFree(vmdef);
if (dev != dev_copy)
}
}
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
virObjectUnref(qemuCaps);
virDomainDefFree(vmdef);
if (dev != dev_copy)
}
}
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
virObjectUnref(qemuCaps);
virDomainDefFree(vmdef);
if (dev != dev_copy)
*autostart = vm->autostart;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(configFile);
VIR_FREE(autostartLink);
if (vm)
ignore_value(VIR_STRDUP(ret, "posix"));
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(cfg);
return 0;
-error:
+ error:
virReportError(VIR_ERR_INVALID_ARG,
_("unable to parse blkio device '%s' '%s'"),
type, blkioDeviceStr);
-cleanup:
+ cleanup:
virBlkioDeviceArrayClear(result, ndevices);
VIR_FREE(result);
return -1;
ret = -1;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
*nparams = QEMU_NB_BLKIO_PARAM;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
ret = 0;
-cleanup:
+ cleanup:
virObjectUnlock(vm);
virObjectUnref(caps);
virObjectUnref(cfg);
}
}
-out:
+ out:
if (QEMU_NB_MEM_PARAM < *nparams)
*nparams = QEMU_NB_MEM_PARAM;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
*nparams = QEMU_NB_NUMA_PARAM;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(nodeset);
if (vm)
virObjectUnlock(vm);
return 0;
-cleanup:
+ cleanup:
virCgroupFree(&cgroup_vcpu);
return -1;
}
virCgroupFree(&cgroup_emulator);
return 0;
-cleanup:
+ cleanup:
virCgroupFree(&cgroup_emulator);
return -1;
}
ret = 0;
-cleanup:
+ cleanup:
virDomainDefFree(vmdef);
if (vm)
virObjectUnlock(vm);
if (rc < 0)
goto cleanup;
-out:
+ out:
ret = 0;
-cleanup:
+ cleanup:
virCgroupFree(&cgroup_vcpu);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCgroupFree(&cgroup_emulator);
return ret;
}
goto cleanup;
}
-out:
+ out:
if (virTypedParameterAssign(¶ms[0], VIR_DOMAIN_SCHEDULER_CPU_SHARES,
VIR_TYPED_PARAM_ULLONG, shares) < 0)
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
&stats->errs);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
*nparams = tmp;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
virReportError(VIR_ERR_INVALID_ARG,
_("invalid path, '%s' is not a known interface"), path);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virNetDevBandwidthFree(bandwidth);
virNetDevBandwidthFree(newBandwidth);
if (vm)
*nparams = QEMU_NB_BANDWIDTH_PARAM;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(fd);
if (vm)
virObjectUnlock(vm);
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(fd);
if (tmp)
unlink(tmp);
ret = 0;
}
-cleanup:
+ cleanup:
VIR_FREE(alias);
virStorageFileFreeMetadata(meta);
VIR_FORCE_CLOSE(fd);
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
callback, opaque, freecb, &ret) < 0)
ret = -1;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
NULL, 0, NULL, NULL, /* No cookies in v2 */
st, &def, origname, flags);
-cleanup:
+ cleanup:
VIR_FREE(origname);
virDomainDefFree(def);
return ret;
uri_in, uri_out,
&def, origname, NULL, flags);
-cleanup:
+ cleanup:
VIR_FREE(origname);
virDomainDefFree(def);
return ret;
NULL, NULL, /* No output cookies in v2 */
flags, dname, resource, false);
-cleanup:
+ cleanup:
return ret;
}
NULL, 0, NULL, NULL, /* No cookies */
flags, retcode, false);
-cleanup:
+ cleanup:
return dom;
}
uri_in, uri_out,
&def, origname, NULL, flags);
-cleanup:
+ cleanup:
VIR_FREE(origname);
virDomainDefFree(def);
return ret;
uri_in, uri_out,
&def, origname, listenAddress, flags);
-cleanup:
+ cleanup:
VIR_FREE(origname);
virDomainDefFree(def);
virObjectUnref(cfg);
cookieout, cookieoutlen,
st, &def, origname, flags);
-cleanup:
+ cleanup:
VIR_FREE(origname);
virDomainDefFree(def);
return ret;
cookieout, cookieoutlen,
st, &def, origname, flags);
-cleanup:
+ cleanup:
VIR_FREE(origname);
virDomainDefFree(def);
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
}
ret = virHostdevPCINodeDeviceDetach(hostdev_mgr, pci);
-cleanup:
+ cleanup:
virPCIDeviceFree(pci);
virNodeDeviceDefFree(def);
VIR_FREE(xml);
ret = virHostdevPCINodeDeviceReAttach(hostdev_mgr, pci);
virPCIDeviceFree(pci);
-cleanup:
+ cleanup:
virNodeDeviceDefFree(def);
VIR_FREE(xml);
return ret;
ret = virHostdevPCINodeDeviceReset(hostdev_mgr, pci);
virPCIDeviceFree(pci);
-cleanup:
+ cleanup:
virNodeDeviceDefFree(def);
VIR_FREE(xml);
return ret;
ret = cpuCompareXML(caps->host.cpu, xmlDesc);
}
-cleanup:
+ cleanup:
virObjectUnref(caps);
return ret;
}
cpu = cpuBaselineXML(xmlCPUs, ncpus, NULL, 0, flags);
-cleanup:
+ cleanup:
return cpu;
}
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
*nparams = npar;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (ret < 0)
ret = qemuMonitorMigrateCancel(priv->mon);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = qemuMonitorSetMigrationDowntime(priv->mon, downtime);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
if (ret == 0)
priv->migMaxBandwidth = bandwidth;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
} else {
ret = 0;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
*bandwidth = priv->migMaxBandwidth;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
-cleanup:
+ cleanup:
disk->src.path = origsrc;
disk->src.format = origformat;
disk->backingChain = origchain;
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
/* unlink images if creation has failed */
vm = NULL;
}
-cleanup:
+ cleanup:
if (resume && virDomainObjIsActive(vm) &&
qemuProcessStartCPUs(driver, vm, conn,
VIR_DOMAIN_RUNNING_UNPAUSED,
}
}
-endjob:
+ endjob:
if (vm && !qemuDomainObjEndJob(driver, vm)) {
/* Only possible if a transient vm quit while our locks were down,
* in which case we don't want to save snapshot metadata. */
ret = 0;
-cleanup:
+ cleanup:
virStorageFileFree(snapfile);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
persistHosts = NULL;
}
-cleanup:
+ cleanup:
if (need_unlink && virStorageFileUnlink(snapfile))
VIR_WARN("unable to unlink just-created %s", source);
virStorageFileFree(snapfile);
origdisk->src.hosts);
}
-cleanup:
+ cleanup:
virStorageFileFree(diskfile);
VIR_FREE(source);
VIR_FREE(persistSource);
}
}
-cleanup:
+ cleanup:
if (ret == 0 || !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0 ||
ret = 0;
-endjob:
+ endjob:
if (resume && vm && virDomainObjIsActive(vm) &&
qemuProcessStartCPUs(driver, vm, conn,
VIR_DOMAIN_RUNNING_UNPAUSED,
ret = -1;
}
-cleanup:
+ cleanup:
VIR_FREE(xml);
virObjectUnref(cfg);
if (memory_unlink && ret < 0)
*/
snapshot = virGetDomainSnapshot(domain, snap->def->name);
-cleanup:
+ cleanup:
if (vm) {
if (snapshot && !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)) {
if (qemuDomainSnapshotWriteMetadata(vm, snap,
n = virDomainSnapshotObjListGetNames(vm->snapshots, NULL, names, nameslen,
flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return n;
n = virDomainSnapshotObjListNum(vm->snapshots, NULL, flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return n;
n = virDomainListSnapshots(vm->snapshots, NULL, domain, snaps, flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return n;
n = virDomainSnapshotObjListGetNames(vm->snapshots, snap, names, nameslen,
flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return n;
n = virDomainSnapshotObjListNum(vm->snapshots, snap, flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return n;
n = virDomainListSnapshots(vm->snapshots, snap, snapshot->domain, snaps,
flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return n;
snapshot = virGetDomainSnapshot(domain, snap->def->name);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return snapshot;
ret = (vm->current_snapshot != NULL);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
parent = virGetDomainSnapshot(snapshot->domain, snap->def->parent);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return parent;
snapshot = virGetDomainSnapshot(domain, vm->current_snapshot->def->name);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return snapshot;
xml = virDomainSnapshotDefFormat(uuidstr, snap->def, flags, 0);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return xml;
ret = (vm->current_snapshot &&
STREQ(snapshot->name, vm->current_snapshot->def->name));
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
* that, then we would have a reason to return 0 here. */
ret = 1;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
-endjob:
+ endjob:
if (vm && !qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm && ret == 0) {
if (qemuDomainSnapshotWriteMetadata(vm, snap,
cfg->snapshotDir) < 0)
ret = qemuDomainSnapshotDiscard(driver, vm, snap, true, metadata_only);
}
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(cfg);
ret = qemuMonitorArbitraryCommand(priv->mon, cmd, result, hmp);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm)) {
vm = NULL;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
virDomainDefFree(def);
virDomainChrSourceDefFree(monConfig);
if (vm)
ret = -1;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = -1;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
return NULL;
}
-cleanup:
+ cleanup:
if (!ret) {
virReportError(VIR_ERR_INVALID_ARG,
"%s", _("No device found for specified path"));
disk->mirrorFormat = VIR_STORAGE_FILE_NONE;
disk->mirroring = false;
-cleanup:
+ cleanup:
if (resume && virDomainObjIsActive(vm) &&
qemuProcessStartCPUs(driver, vm, conn,
VIR_DOMAIN_RUNNING_UNPAUSED,
}
}
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm)) {
vm = NULL;
goto cleanup;
}
-cleanup:
+ cleanup:
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
disk->mirror = mirror;
mirror = NULL;
-endjob:
+ endjob:
if (need_unlink && unlink(dest))
VIR_WARN("unable to unlink just-created %s", dest);
if (ret < 0 && disk)
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
base ? base : base_canon, bandwidth);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (ret < 0 && clean_access) {
/* Revert access to read-only, if possible. */
qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon,
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
}
}
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
*nparams = QEMU_NB_BLOCK_IO_TUNE_PARAM;
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
ret = n;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virHashFree(table);
ret = virDomainObjSetMetadata(vm, type, metadata, key, uri, caps,
driver->xmlopt, cfg->configDir, flags);
-cleanup:
+ cleanup:
virObjectUnlock(vm);
virObjectUnref(caps);
virObjectUnref(cfg);
ret = virDomainObjGetMetadata(vm, type, uri, caps, driver->xmlopt, flags);
-cleanup:
+ cleanup:
virObjectUnlock(vm);
virObjectUnref(caps);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCgroupFree(&group_vcpu);
VIR_FREE(buf);
return ret;
}
rv = param_idx + 1;
-cleanup:
+ cleanup:
VIR_FREE(sum_cpu_time);
VIR_FREE(buf);
return rv;
else
ret = qemuDomainGetPercpuStats(vm, params, nparams,
start_cpu, ncpus);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = qemuAgentSuspend(priv->agent, target);
qemuDomainObjExitAgent(vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = qemuMonitorSystemWakeup(priv->mon);
qemuDomainObjExitMonitor(driver, vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = virDomainObjListExport(driver->domains, conn, domains,
virConnectListAllDomainsCheckACL, flags);
-cleanup:
+ cleanup:
return ret;
}
if (ret < 0)
VIR_FREE(result);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return result;
&ret) < 0)
ret = -1;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = qemuAgentFSTrim(priv->agent, minimum);
qemuDomainObjExitAgent(vm);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = true;
-cleanup:
+ cleanup:
if (iommuDir)
closedir(iommuDir);
ret = true;
# endif
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(kvmfd);
return ret;
ret = virHostdevPreparePCIDevices(hostdev_mgr, QEMU_DRIVER_NAME,
name, uuid, hostdevs,
nhostdevs, flags);
-out:
+ out:
return ret;
}
src, format);
qemuDomainObjExitMonitor(driver, vm);
}
-audit:
+ audit:
if (src)
virDomainAuditDisk(vm, virDomainDiskGetSource(origdisk),
src, "update", ret >= 0);
virDomainDiskDefFree(disk);
-cleanup:
+ cleanup:
VIR_FREE(driveAlias);
virObjectUnref(cfg);
return ret;
-error:
+ error:
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on new media %s", src);
ret = 0;
-cleanup:
+ cleanup:
virHashFree(table);
return ret;
}
virDomainDiskInsertPreAlloced(vm->def, disk);
-cleanup:
+ cleanup:
VIR_FREE(devstr);
VIR_FREE(drivestr);
virObjectUnref(cfg);
return ret;
-error:
+ error:
if (releaseaddr)
qemuDomainReleaseDeviceAddress(vm, &disk->info, src);
virDomainControllerInsertPreAlloced(vm->def, controller);
}
-cleanup:
+ cleanup:
if (ret != 0 && releaseaddr)
qemuDomainReleaseDeviceAddress(vm, &controller->info, NULL);
virDomainDiskInsertPreAlloced(vm->def, disk);
-cleanup:
+ cleanup:
VIR_FREE(devstr);
VIR_FREE(drivestr);
virObjectUnref(cfg);
return ret;
-error:
+ error:
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on %s", src);
virDomainDiskInsertPreAlloced(vm->def, disk);
-cleanup:
+ cleanup:
VIR_FREE(devstr);
VIR_FREE(drivestr);
virObjectUnref(cfg);
return ret;
-error:
+ error:
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0)
VIR_WARN("Unable to restore security label on %s", src);
NULLSTR(src));
}
-end:
+ end:
if (ret != 0)
ignore_value(qemuRemoveSharedDevice(driver, dev, vm->def->name));
virObjectUnref(caps);
ret = 0;
-cleanup:
+ cleanup:
if (!ret) {
vm->def->nets[vm->def->nnets++] = net;
} else {
return ret;
-try_remove:
+ try_remove:
if (!virDomainObjIsActive(vm))
goto cleanup;
return 0;
-error:
+ error:
if (teardowncgroup && qemuTeardownHostdevCgroup(vm, hostdev) < 0)
VIR_WARN("Unable to remove host device cgroup ACL on hotplug fail");
if (teardownlabel &&
VIR_FREE(configfd_name);
VIR_FORCE_CLOSE(configfd);
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return -1;
}
return 0;
-error:
+ error:
VIR_FREE(devstr);
return -1;
qemuDomainObjExitMonitor(driver, vm);
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0 && need_remove)
qemuDomainChrRemove(vmdef, chr);
VIR_FREE(charAlias);
vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0) {
if (teardowncgroup && qemuTeardownHostdevCgroup(vm, hostdev) < 0)
VIR_WARN("Unable to remove host device cgroup ACL on hotplug fail");
vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0) {
qemuDomainReAttachHostSCSIDevices(driver, vm->def->name, &hostdev, 1);
if (teardowncgroup && qemuTeardownHostdevCgroup(vm, hostdev) < 0)
return 0;
-error:
+ error:
return -1;
}
virDomainNetGetActualType(net));
}
-cleanup:
+ cleanup:
return brname;
}
}
/* caller will replace entire olddev with newdev in domain nets list */
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(oldbridge);
VIR_FREE(newbridge);
return ret;
/* modify the device configuration */
dev->linkstate = linkstate;
-cleanup:
+ cleanup:
qemuDomainObjExitMonitor(driver, vm);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
/* When we get here, we will be in one of these two states:
*
* 1) newdev has been moved into the domain's list of nets and
break;
}
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
qemuDomainRemoveDiskDevice(driver, vm, detach);
ret = 0;
-cleanup:
+ cleanup:
qemuDomainResetDeviceRemoval(vm);
VIR_FREE(drivestr);
return ret;
qemuDomainRemoveDiskDevice(driver, vm, detach);
ret = 0;
-cleanup:
+ cleanup:
qemuDomainResetDeviceRemoval(vm);
VIR_FREE(drivestr);
return ret;
ret = 0;
-cleanup:
+ cleanup:
qemuDomainResetDeviceRemoval(vm);
return ret;
}
}
qemuDomainObjExitMonitor(driver, vm);
-cleanup:
+ cleanup:
VIR_FREE(drvstr);
VIR_FREE(devstr);
return ret;
ret = 0;
-cleanup:
+ cleanup:
qemuDomainResetDeviceRemoval(vm);
VIR_FREE(hostnet_name);
return ret;
}
}
-end_job:
+ end_job:
qemuDomainObjExitMonitor(driver, vm);
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
virDomainLeaseInsertPreAlloced(vm->def, lease);
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
qemuDomainRemoveChrDevice(driver, vm, tmpChr);
ret = 0;
-cleanup:
+ cleanup:
qemuDomainResetDeviceRemoval(vm);
VIR_FREE(devstr);
VIR_FREE(charAlias);
return subject;
-error:
+ error:
VIR_FREE(certfile);
VIR_FREE(pemdata);
return NULL;
virObjectUnref(cfg);
return mig;
-error:
+ error:
qemuMigrationCookieGraphicsFree(mig);
virObjectUnref(cfg);
return NULL;
}
return mig;
-error:
+ error:
qemuMigrationCookieNetworkFree(mig);
return NULL;
}
return mig;
-error:
+ error:
qemuMigrationCookieFree(mig);
return NULL;
}
return grap;
-error:
+ error:
qemuMigrationCookieGraphicsFree(grap);
return NULL;
}
VIR_FREE(interfaces);
-cleanup:
+ cleanup:
ctxt->node = save_ctxt;
return optr;
-error:
+ error:
VIR_FREE(interfaces);
qemuMigrationCookieNetworkFree(optr);
optr = NULL;
virObjectUnref(caps);
return 0;
-error:
+ error:
VIR_FREE(tmp);
VIR_FREE(nodes);
virObjectUnref(caps);
ret = qemuMigrationCookieXMLParse(mig, driver, doc, ctxt, flags);
-cleanup:
+ cleanup:
xmlXPathFreeContext(ctxt);
xmlFreeDoc(doc);
return mig;
-error:
+ error:
qemuMigrationCookieFree(mig);
return NULL;
}
priv->nbdPort = port;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(diskAlias);
if (ret < 0)
virPortAllocatorRelease(driver->remotePorts, port);
QEMU_MONITOR_MIGRATE_NON_SHARED_INC);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(diskAlias);
VIR_FREE(nbd_dest);
VIR_FREE(hoststr);
return ret;
-error:
+ error:
/* don't overwrite any errors */
err = virSaveLastError();
/* cancel any outstanding jobs */
qemuDomainObjExitMonitor(driver, vm);
}
-cleanup:
+ cleanup:
VIR_FREE(diskAlias);
return;
}
priv->mon,
QEMU_MONITOR_MIGRATION_CAPS_XBZRLE);
-cleanup:
+ cleanup:
qemuDomainObjExitMonitor(driver, vm);
return ret;
}
priv->mon,
QEMU_MONITOR_MIGRATION_CAPS_AUTO_CONVERGE);
-cleanup:
+ cleanup:
qemuDomainObjExitMonitor(driver, vm);
return ret;
}
virObjectLock(vm);
}
-cleanup:
+ cleanup:
if (priv->job.info.type == VIR_DOMAIN_JOB_COMPLETED)
return 0;
else
return -1;
-cancel:
+ cancel:
if (virDomainObjIsActive(vm)) {
if (qemuDomainObjEnterMonitorAsync(driver, vm,
priv->job.asyncJob) == 0) {
qemuDomainObjExitMonitor(driver, vm);
}
-cleanup:
+ cleanup:
virURIFree(uri);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
;
}
-cleanup:
+ cleanup:
return vm;
}
rv = qemuDomainDefFormatLive(driver, vm->def, false, true);
}
-cleanup:
+ cleanup:
qemuMigrationCookieFree(mig);
virObjectUnref(caps);
virDomainDefFree(def);
goto endjob;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return xml;
-endjob:
+ endjob:
if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) {
if (qemuMigrationJobFinish(driver, vm) == 0)
vm = NULL;
VIR_DEBUG("Received no lockstate");
}
-done:
+ done:
if (flags & VIR_MIGRATE_OFFLINE)
cookieFlags = 0;
else
priv->migrationPort = port;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(migrateFrom);
VIR_FREE(xmlout);
VIR_FORCE_CLOSE(dataFD[0]);
virObjectUnref(caps);
return ret;
-stop:
+ stop:
virDomainAuditStart(vm, "migrated", false);
qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED, 0);
-endjob:
+ endjob:
if (!qemuMigrationJobFinish(driver, vm)) {
vm = NULL;
}
ret = qemuMigrationPrepareAny(driver, dconn, cookiein, cookieinlen,
cookieout, cookieoutlen, def, origname,
NULL, port, autoPort, listenAddress, flags);
-cleanup:
+ cleanup:
virURIFree(uri);
VIR_FREE(hostname);
if (ret != 0) {
}
}
-cleanup:
+ cleanup:
virObjectUnref(caps);
if (def && origname)
*origname = name;
}
}
-done:
+ done:
qemuMigrationCookieFree(mig);
rv = 0;
-cleanup:
+ cleanup:
if (event)
qemuDomainEventQueue(driver, event);
virObjectUnref(cfg);
vm = NULL;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(cfg);
return;
-abrt:
+ abrt:
err = virSaveLastError();
if (err && err->code == VIR_ERR_OK) {
virFreeError(err);
virFreeError(err);
}
-error:
+ error:
virCopyLastError(&data->err);
virResetLastError();
VIR_FREE(buffer);
return io;
-error:
+ error:
VIR_FORCE_CLOSE(wakeupFD[0]);
VIR_FORCE_CLOSE(wakeupFD[1]);
VIR_FREE(io);
rv = 0;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(io->wakeupSendFD);
VIR_FORCE_CLOSE(io->wakeupRecvFD);
VIR_FREE(io);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(port);
if (ret < 0)
VIR_FORCE_CLOSE(spec->dest.fd.qemu);
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0 && !orig_err)
orig_err = virSaveLastError();
return ret;
-cancel:
+ cancel:
orig_err = virSaveLastError();
if (virDomainObjIsActive(vm)) {
cookieoutlen, flags, resource, &spec, dconn,
graphicsuri);
-cleanup:
+ cleanup:
if (spec.destType == MIGRATION_DEST_FD) {
VIR_FORCE_CLOSE(spec.dest.fd.qemu);
VIR_FORCE_CLOSE(spec.dest.fd.local);
*/
cancelled = ret < 0;
-finish:
+ finish:
/* In version 2 of the migration protocol, we pass the
* status code from the sender to the destination host,
* so it can do any cleanup if the migration failed.
if (cancelled && ddomain)
VIR_ERROR(_("finish step ignored that migration was cancelled"));
-cleanup:
+ cleanup:
if (ddomain) {
virObjectUnref(ddomain);
ret = 0;
*/
cancelled = ret < 0;
-finish:
+ finish:
/*
* The status code from the source is passed to the destination.
* The dest can cleanup in the source indicated it failed to
dconnuri, flags, dname, resource);
}
-cleanup:
+ cleanup:
orig_err = virSaveLastError();
qemuDomainObjEnterRemote(vm);
virObjectUnref(dconn);
VIR_DOMAIN_EVENT_STOPPED_MIGRATED);
}
-endjob:
+ endjob:
if (ret < 0)
orig_err = virSaveLastError();
virFreeError(orig_err);
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (event)
qemuMigrationCleanup) < 0)
goto endjob;
-endjob:
+ endjob:
if (ret < 0)
hasrefs = qemuMigrationJobFinish(driver, vm);
else
vm = NULL;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (event)
return 0;
-err_exit:
+ err_exit:
for (i = 0; last_good_net != -1 && i < last_good_net; i++) {
net = def->nets[i];
if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_DIRECT) {
if (qemuMigrationBakeCookie(mig, driver, vm, cookieout, cookieoutlen, 0) < 0)
VIR_WARN("Unable to encode migration cookie");
-endjob:
+ endjob:
if (qemuMigrationJobFinish(driver, vm) == 0) {
vm = NULL;
} else if (!vm->persistent && !virDomainObjIsActive(vm)) {
vm = NULL;
}
-cleanup:
+ cleanup:
virPortAllocatorRelease(driver->migrationPorts, port);
if (vm) {
VIR_FREE(priv->origname);
ret = 0;
-cleanup:
+ cleanup:
/* Restore max migration bandwidth */
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
qemuMonitorSetMigrationSpeed(priv->mon, saveMigBandwidth);
return monfd;
-error:
+ error:
VIR_FORCE_CLOSE(monfd);
return -1;
}
if ((len = qemuProcessReadLog(mon->logfd, logbuf, 4096 - 1, 0, true)) <= 0)
goto error;
-cleanup:
+ cleanup:
errno = orig_errno;
VIR_FORCE_CLOSE(mon->logfd);
return logbuf;
-error:
+ error:
VIR_FREE(logbuf);
goto cleanup;
}
return mon;
-cleanup:
+ cleanup:
/* We don't want the 'destroy' callback invoked during
* cleanup from construction failure, because that can
* give a double-unref on virDomainObjPtr in the caller,
ret = 0;
-cleanup:
+ cleanup:
mon->msg = NULL;
qemuMonitorUpdateWatch(mon);
}
}
-cleanup:
+ cleanup:
for (i = 0; i < npaths; i++)
qemuMonitorJSONListPathFree(paths[i]);
VIR_FREE(paths);
ret = qemuMonitorTextCommandWithFd(mon, cmd, scm_fd, reply);
}
-cleanup:
+ cleanup:
VIR_FREE(json_cmd);
return ret;
}
ret = 0;
}
-cleanup:
+ cleanup:
return ret;
}
else
ret = qemuMonitorTextMigrate(mon, flags, dest);
-cleanup:
+ cleanup:
VIR_FREE(argstr);
VIR_FREE(dest);
return ret;
else
ret = qemuMonitorTextMigrate(mon, flags, dest);
-cleanup:
+ cleanup:
VIR_FREE(safe_target);
VIR_FREE(argstr);
VIR_FREE(dest);
else
ret = qemuMonitorTextCloseFileHandle(mon, fdname);
-cleanup:
+ cleanup:
if (error) {
virSetError(error);
virFreeError(error);
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
_("remove fd requires JSON monitor"));
-cleanup:
+ cleanup:
if (error) {
virSetError(error);
virFreeError(error);
else
ret = qemuMonitorTextAddHostNetwork(mon, netstr);
-cleanup:
+ cleanup:
if (ret < 0) {
while (i--) {
if (qemuMonitorCloseFileHandle(mon, tapfdName[i]) < 0)
else
ret = qemuMonitorTextAddNetdev(mon, netdevstr);
-cleanup:
+ cleanup:
if (ret < 0) {
while (i--) {
if (qemuMonitorCloseFileHandle(mon, tapfdName[i]) < 0)
_("Unknown JSON reply '%s'"), line);
}
-cleanup:
+ cleanup:
virJSONValueFree(obj);
return ret;
}
}
}
-cleanup:
+ cleanup:
VIR_FREE(id);
VIR_FREE(cmdstr);
VIR_FREE(msg.txBuffer);
return obj;
-error:
+ error:
virJSONValueFree(obj);
virJSONValueFree(jargs);
va_end(args);
qemuFreeKeywords(nkeywords, keywords, values);
return ret;
-error:
+ error:
qemuFreeKeywords(nkeywords, keywords, values);
virJSONValueFree(ret);
return NULL;
break;
}
-out:
+ out:
qemuMonitorEmitBlockJob(mon, device, type, event);
}
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
threads = NULL;
ret = ncpus;
-cleanup:
+ cleanup:
VIR_FREE(threads);
return ret;
}
*virtType = VIR_DOMAIN_VIRT_KVM;
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
}
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
VIR_DOMAIN_MEMORY_STAT_AVAILABLE, 1024);
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
*nparams = num;
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = qemuMonitorJSONCheckError(cmd, reply);
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = qemuMonitorJSONCheckError(cmd, reply);
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = qemuMonitorJSONCheckError(cmd, reply);
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = 1;
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
if (ret == 0)
ret = 1;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
-fallback:
+ fallback:
VIR_DEBUG("no QMP support for cpu_set, trying HMP");
ret = qemuMonitorTextSetCPU(mon, cpu, online);
goto cleanup;
}
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = 0;
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
}
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
-error:
+ error:
/* Best effort cleanup - kill the entire fdset (even if it has
* earlier successful fd registrations), since we don't know which
* fd qemu got, and don't want to leave the fd leaked in qemu. */
if (ret == 0)
ret = qemuMonitorJSONCheckError(cmd, reply);
-cleanup:
+ cleanup:
virJSONValueFree(args);
virJSONValueFree(cmd);
virJSONValueFree(reply);
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
if (ret == 0)
ret = qemuMonitorJSONCheckError(cmd, reply);
-cleanup:
+ cleanup:
virJSONValueFree(args);
virJSONValueFree(cmd);
virJSONValueFree(reply);
ret = qemuMonitorJSONCheckError(cmd, reply);
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
goto cleanup;
ret = qemuMonitorJSONCheckError(cmd, reply);
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = qemuMonitorJSONCheckError(cmd, reply);
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
actions->protect = protect;
goto cleanup;
ret = qemuMonitorJSONCheckError(cmd, reply);
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
goto cleanup;
ret = qemuMonitorJSONCheckError(cmd, reply);
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
ret = qemuMonitorJSONCheckError(cmd, reply);
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = qemuMonitorJSONCheckError(cmd, reply);
}
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
virJSONValueFree(keys);
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
#undef GET_THROTTLE_STATS
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = n;
*machines = infolist;
-cleanup:
+ cleanup:
if (ret < 0 && infolist) {
for (i = 0; i < n; i++)
qemuMonitorMachineInfoFree(infolist[i]);
ret = n;
*cpus = cpulist;
-cleanup:
+ cleanup:
if (ret < 0)
virStringFreeList(cpulist);
virJSONValueFree(cmd);
ret = n;
*commands = commandlist;
-cleanup:
+ cleanup:
if (ret < 0)
virStringFreeList(commandlist);
virJSONValueFree(cmd);
ret = n;
*events = eventlist;
-cleanup:
+ cleanup:
if (ret < 0)
virStringFreeList(eventlist);
virJSONValueFree(cmd);
ret = n;
*params = paramlist;
-cleanup:
+ cleanup:
/* If we failed before getting the JSON array of options, we (try)
* to cache an empty array to speed up the next failure. */
if (!qemuMonitorGetOptions(mon))
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = n;
*types = typelist;
-cleanup:
+ cleanup:
if (ret < 0)
virStringFreeList(typelist);
virJSONValueFree(cmd);
ret = n;
*paths = pathlist;
-cleanup:
+ cleanup:
if (ret < 0 && pathlist) {
for (i = 0; i < n; i++)
qemuMonitorJSONListPathFree(pathlist[i]);
}
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
if ((ret = qemuMonitorJSONCommand(mon, cmd, &reply)) == 0)
ret = qemuMonitorJSONCheckError(cmd, reply);
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
ret = n;
*props = proplist;
-cleanup:
+ cleanup:
if (ret < 0)
virStringFreeList(proplist);
virJSONValueFree(cmd);
ignore_value(VIR_STRDUP(ret, arch));
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = qemuMonitorJSONCheckError(cmd, reply);
-cleanup:
+ cleanup:
virJSONValueFree(caps);
virJSONValueFree(cap);
virJSONValueFree(cmd);
goto error;
return addr;
-error:
+ error:
virJSONValueFree(data);
virJSONValueFree(addr);
return NULL;
goto error;
return addr;
-error:
+ error:
virReportOOMError();
virJSONValueFree(data);
virJSONValueFree(addr);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(port_str);
virJSONValueFree(reply);
virJSONValueFree(cmd);
ret = n;
*array = list;
-cleanup:
+ cleanup:
if (ret < 0)
virStringFreeList(list);
virJSONValueFree(cmd);
return ret;
-no_memory:
+ no_memory:
virReportOOMError();
-error:
+ error:
virJSONValueFree(addr);
virJSONValueFree(data);
virJSONValueFree(backend);
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
for (i = 0; i < n; i++)
qemuMonitorJSONListPathFree(paths[i]);
VIR_FREE(paths);
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(cmd);
virJSONValueFree(reply);
virCPUx86DataFree(x86Data);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
return ret;
}
VIR_FREE(cmd);
return 0;
-error:
+ error:
VIR_FREE(info);
VIR_FREE(cmd);
*pids = cpupids;
return ncpupids;
-error:
+ error:
VIR_FREE(qemucpus);
VIR_FREE(cpupids);
ret = 0;
}
-cleanup:
+ cleanup:
VIR_FREE(reply);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(info);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
VIR_FREE(cmd);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
VIR_FREE(cmd);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
VIR_FREE(cmd);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
VIR_FREE(cmd);
VIR_FREE(safepath);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
VIR_FREE(safepath);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(info);
VIR_FREE(cmd);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(info);
VIR_FREE(cmd);
return ret;
}
}
-done:
+ done:
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
if (ret < 0)
memset(status, 0, sizeof(*status));
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(extrastr);
VIR_FREE(safedest);
VIR_FREE(info);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(safepath);
VIR_FREE(info);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
if (!safe_path)
return -1;
-try_command:
+ try_command:
if (virAsprintf(&cmd, "pci_add %s storage file=%s,if=%s",
(tryOldSyntax ? "0": "pci_addr=auto"), safe_path, bus) < 0)
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(safe_path);
VIR_FREE(cmd);
VIR_FREE(reply);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
VIR_FREE(cmd);
return ret;
bool tryOldSyntax = false;
int ret = -1;
-try_command:
+ try_command:
if (tryOldSyntax) {
if (virAsprintf(&cmd, "pci_del 0 %.2x", guestAddr->slot) < 0)
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
return ret;
}
bool tryOldSyntax = false;
int ret = -1;
-try_command:
+ try_command:
if (virAsprintf(&cmd, "pci_add %s storage if=%s",
(tryOldSyntax ? "0": "pci_addr=auto"), bus) < 0)
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
if (!safe_str)
return -1;
-try_command:
+ try_command:
if (virAsprintf(&cmd, "drive_add %s%.2x:%.2x:%.2x %s",
(tryOldSyntax ? "" : "pci_addr="),
controllerAddr->domain, controllerAddr->bus,
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
VIR_FREE(safe_str);
return naddrs;
-error:
+ error:
VIR_FREE(addrs);
VIR_FREE(reply);
return -1;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
VIR_FREE(safedev);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
VIR_FREE(safedev);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
VIR_FREE(safe_str);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
VIR_FREE(safedev);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
VIR_FREE(safe_str);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(safename);
VIR_FREE(cmd);
VIR_FREE(reply);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(safename);
VIR_FREE(cmd);
VIR_FREE(reply);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(safename);
VIR_FREE(cmd);
VIR_FREE(reply);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(reply);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
VIR_FREE(cmd);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
VIR_FREE(cmd);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cmd);
VIR_FREE(result);
return ret;
virReportError(VIR_ERR_INVALID_ARG,
_("No info for device '%s'"), device);
-cleanup:
+ cleanup:
return ret;
}
ret = qemuMonitorTextParseBlockIoThrottle(result, device, reply);
-cleanup:
+ cleanup:
VIR_FREE(result);
return ret;
}
vm->def->name, virStrerror(errno, ebuf, sizeof(ebuf)));
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
qemuAgentClose(agent);
return;
-unlock:
+ unlock:
virObjectUnlock(vm);
return;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
goto cleanup;
}
-unlock:
+ unlock:
virObjectUnlock(vm);
-cleanup:
+ cleanup:
if (event)
qemuDomainEventQueue(driver, event);
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = qemuProcessGetVolumeQcowPassphrase(conn, disk, secretRet, secretLen);
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return ret;
}
ret = 0;
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, vm))
vm = NULL;
-cleanup:
+ cleanup:
if (vm) {
if (ret == -1) {
ignore_value(qemuProcessKill(vm, VIR_QEMU_PROCESS_KILL_FORCE));
qemuProcessShutdownOrReboot(driver, vm);
-unlock:
+ unlock:
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
}
}
-unlock:
+ unlock:
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
}
}
-unlock:
+ unlock:
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
return 0;
-error:
+ error:
if (localAddr) {
VIR_FREE(localAddr->service);
VIR_FREE(localAddr->node);
VIR_FREE(processEvent);
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
VIR_WARN("unable to save domain status with balloon change");
-cleanup:
+ cleanup:
virObjectUnlock(vm);
virObjectUnref(cfg);
return 0;
ret = virQEMUCapsProbeQMP(priv->qemuCaps, priv->mon);
qemuDomainObjExitMonitor(driver, vm);
-error:
+ error:
return ret;
}
_("Timed out while reading %s log output: %s"),
what, buf);
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(logfd);
return ret;
}
if (ret == 0)
ret = qemuProcessFindCharDevicePTYsMonitor(vm, qemuCaps, paths);
-cleanup:
+ cleanup:
virHashFree(paths);
if (pos != -1 && kill(vm->pid, 0) == -1 && errno == ESRCH) {
ret = -1;
}
-closelog:
+ closelog:
if (VIR_CLOSE(logfd) < 0) {
char ebuf[1024];
VIR_WARN("Unable to close logfile: %s",
}
}
-cleanup:
+ cleanup:
virObjectUnref(caps);
return cpumap;
}
ret = 0;
-cleanup:
+ cleanup:
virBitmapFree(cpumap);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
}
}
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(h->cfg);
VIR_DEBUG("Hook complete ret=%d", ret);
return ret;
VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));
}
-cleanup:
+ cleanup:
virObjectUnref(cfg);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virStringFreeList(old);
return ret;
}
if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback)
driver->inhibitCallback(true, driver->inhibitOpaque);
-endjob:
+ endjob:
if (!qemuDomainObjEndJob(driver, obj))
obj = NULL;
return;
-error:
+ error:
if (!qemuDomainObjEndJob(driver, obj))
obj = NULL;
return 0;
-error:
+ error:
VIR_FREE(data);
return -1;
}
return 0;
-error:
+ error:
virPortAllocatorRelease(driver->remotePorts, port);
return -1;
}
ret = true;
-cleanup:
+ cleanup:
cpuDataFree(guestcpu);
return ret;
}
return 0;
-cleanup:
+ cleanup:
/* We jump here if we failed to start the VM for any reason, or
* if we failed to initialize the now running VM. kill it off and
* pretend we never started it */
networkReleaseActualDevice(vm->def, net);
}
-retry:
+ retry:
if ((ret = qemuRemoveCgroup(vm)) < 0) {
if (ret == -EBUSY && (retries++ < 5)) {
usleep(200*1000);
return 0;
-error:
+ error:
/* We jump here if we failed to attach to the VM for any reason.
* Leave the domain running, but pretend we never attempted to
* attach to it. */
if (event)
qemuDomainEventQueue(driver, event);
-cleanup:
+ cleanup:
return dom;
}
projects / people / liuw / libxenctrl-split / libvirt.git / commitdiff