goto cleanup;
#endif
-cleanup:
+ cleanup:
virObjectUnref(identity);
return ret;
}
goto cleanup;
}
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(actionid);
VIR_FREE(process);
return manager;
-error:
+ error:
virObjectUnref(manager);
return NULL;
}
virReportSystemError(errno, "%s",
_("Unable to iterate over TAP devices"));
-cleanup:
+ cleanup:
VIR_FREE(devpath);
VIR_FORCE_CLOSE(fd);
closedir(dirp);
return cmd;
-error:
+ error:
virCommandFree(cmd);
return NULL;
}
return caps;
-error:
+ error:
virObjectUnref(caps);
return NULL;
}
info->nrVirtCpu = vm->def->vcpus;
ret = 0;
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return ret;
}
*state = virDomainObjGetState(vm, reason);
ret = 0;
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return ret;
}
ret = virDomainObjIsActive(obj);
-cleanup:
+ cleanup:
virObjectUnlock(obj);
return ret;
}
ret = obj->persistent;
-cleanup:
+ cleanup:
virObjectUnlock(obj);
return ret;
}
ret = virDomainDefFormat(vm->def, flags);
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return ret;
}
if (virDomainSaveConfig(BHYVE_CONFIG_DIR, vm->def) < 0)
goto cleanup;
-cleanup:
+ cleanup:
virDomainDefFree(def);
virObjectUnlock(vm);
ret = 0;
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return ret;
}
if (dom)
dom->id = vm->def->id;
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return dom;
}
if (dom)
dom->id = vm->def->id;
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return dom;
}
VIR_DOMAIN_RUNNING_BOOTED,
start_flags);
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return ret;
}
ret = virBhyveProcessStop(privconn, vm, VIR_DOMAIN_SHUTOFF_DESTROYED);
-cleanup:
+ cleanup:
virObjectUnlock(vm);
return ret;
}
return 0;
-cleanup:
+ cleanup:
bhyveStateCleanup();
return -1;
}
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0) {
virCommandPtr destroy_cmd;
if ((destroy_cmd = virBhyveProcessBuildDestroyCmd(driver, vm)) != NULL) {
vm->pid = -1;
vm->def->id = -1;
-cleanup:
+ cleanup:
virCommandFree(cmd);
return ret;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
ret->conn = virObjectRef(conn);
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
return ret;
-error:
+ error:
virObjectUnref(ret);
return NULL;
}
VIR_FREE(regfunc);
return handle;
-cleanup:
+ cleanup:
VIR_FREE(modfile);
VIR_FREE(regfunc);
if (handle)
ret = 0;
-cleanup:
+ cleanup:
virMutexUnlock(&fdst->lock);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virMutexUnlock(&fdst->lock);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virMutexUnlock(&fdst->lock);
return ret;
}
nbytes = fdst->length - fdst->offset;
}
-retry:
+ retry:
ret = write(fdst->fd, bytes, nbytes);
if (ret < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
nbytes = fdst->length - fdst->offset;
}
-retry:
+ retry:
ret = read(fdst->fd, bytes, nbytes);
if (ret < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
goto error;
return 0;
-error:
+ error:
VIR_FORCE_CLOSE(fd);
return -1;
}
return 0;
-error:
+ error:
virCommandFree(cmd);
VIR_FORCE_CLOSE(fd);
VIR_FORCE_CLOSE(childfd);
return 0;
-cleanup:
+ cleanup:
virFDStreamClose(st);
return -1;
}
priv = NULL;
result = VIR_DRV_OPEN_SUCCESS;
- cleanup:
+ cleanup:
hypervFreePrivate(&priv);
VIR_FREE(username);
VIR_FREE(password);
ignore_value(VIR_STRDUP(hostname, computerSystem->data->DNSHostName));
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return hostname;
result = 0;
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
hypervFreeObject(priv, (hypervObject *)processorList);
success = true;
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystemList);
return success ? count : -1;
success = true;
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystemList);
return success ? count : -1;
hypervMsvmComputerSystemToDomain(conn, computerSystem, &domain);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return domain;
hypervMsvmComputerSystemToDomain(conn, computerSystem, &domain);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return domain;
hypervMsvmComputerSystemToDomain(conn, computerSystem, &domain);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return domain;
result = hypervInvokeMsvmComputerSystemRequestStateChange
(domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_PAUSED);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
result = hypervInvokeMsvmComputerSystemRequestStateChange
(domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_ENABLED);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
result = hypervInvokeMsvmComputerSystemRequestStateChange
(domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
result = 0;
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
hypervFreeObject(priv, (hypervObject *)virtualSystemSettingData);
hypervFreeObject(priv, (hypervObject *)processorSettingData);
result = 0;
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
xml = virDomainDefFormat(def, flags);
- cleanup:
+ cleanup:
virDomainDefFree(def);
hypervFreeObject(priv, (hypervObject *)computerSystem);
hypervFreeObject(priv, (hypervObject *)virtualSystemSettingData);
success = true;
- cleanup:
+ cleanup:
if (!success) {
for (i = 0; i < count; ++i) {
VIR_FREE(names[i]);
success = true;
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystemList);
return success ? count : -1;
result = hypervInvokeMsvmComputerSystemRequestStateChange
(domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_ENABLED);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
result = hypervIsMsvmComputerSystemActive(computerSystem, NULL) ? 1 : 0;
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
result = hypervInvokeMsvmComputerSystemRequestStateChange
(domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_SUSPENDED);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
result = computerSystem->data->EnabledState ==
MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED ? 1 : 0;
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
result = hypervInvokeMsvmComputerSystemRequestStateChange
(domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED);
- cleanup:
+ cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
doms = NULL;
ret = count;
-cleanup:
+ cleanup:
if (doms) {
for (i = 0; i < count; ++i) {
virDomainFree(doms[i]);
result = 0;
- cleanup:
+ cleanup:
if (result < 0) {
hypervFreeParsedUri(parsedUri);
}
result = 0;
- cleanup:
+ cleanup:
if (options != NULL) {
wsmc_options_destroy(options);
}
result = 0;
- cleanup:
+ cleanup:
if (options != NULL) {
wsmc_options_destroy(options);
}
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnlock(driverState);
return ret;
return def;
-cleanup:
+ cleanup:
virInterfaceDefFree(def);
return NULL;
}
*active = flags & NETCF_IFACE_ACTIVE;
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(driverState);
return ret;
}
ret = want;
-cleanup:
+ cleanup:
if (names && count > 0)
for (i = 0; i < count; i++)
VIR_FREE(names[i]);
ret = want;
-cleanup:
+ cleanup:
if (allnames && count > 0)
for (i = 0; i < count; i++)
VIR_FREE(allnames[i]);
ret = niface_objs;
-cleanup:
+ cleanup:
ncf_if_free(iface);
if (names && count > 0)
ret = virGetInterface(conn, ncf_if_name(iface), ncf_if_mac_string(iface));
-cleanup:
+ cleanup:
ncf_if_free(iface);
virInterfaceDefFree(def);
virObjectUnlock(driver);
ret = virGetInterface(conn, ncf_if_name(iface), ncf_if_mac_string(iface));
-cleanup:
+ cleanup:
ncf_if_free(iface);
virInterfaceDefFree(def);
virObjectUnlock(driver);
goto cleanup;
}
-cleanup:
+ cleanup:
ncf_if_free(iface);
VIR_FREE(xmlstr);
virInterfaceDefFree(ifacedef);
ret = virGetInterface(conn, ncf_if_name(iface), ncf_if_mac_string(iface));
-cleanup:
+ cleanup:
ncf_if_free(iface);
VIR_FREE(xmlstr);
virInterfaceDefFree(ifacedef);
goto cleanup;
}
-cleanup:
+ cleanup:
ncf_if_free(iface);
virInterfaceDefFree(def);
virObjectUnlock(driver);
goto cleanup;
}
-cleanup:
+ cleanup:
ncf_if_free(iface);
virInterfaceDefFree(def);
virObjectUnlock(driver);
goto cleanup;
}
-cleanup:
+ cleanup:
ncf_if_free(iface);
virInterfaceDefFree(def);
virObjectUnlock(driver);
ret = active ? 1 : 0;
-cleanup:
+ cleanup:
ncf_if_free(iface);
virInterfaceDefFree(def);
virObjectUnlock(driver);
return def;
-cleanup:
+ cleanup:
virInterfaceDefFree(def);
return NULL;
}
return VIR_DRV_OPEN_SUCCESS;
-cleanup:
+ cleanup:
VIR_FREE(driverState);
return VIR_DRV_OPEN_ERROR;
virInterfaceDefFree(def);
}
-cleanup:
+ cleanup:
if (enumerate)
udev_enumerate_unref(enumerate);
udev_unref(udev);
return count;
-error:
+ error:
if (enumerate)
udev_enumerate_unref(enumerate);
udev_unref(udev);
return count;
-cleanup:
+ cleanup:
if (enumerate)
udev_enumerate_unref(enumerate);
udev_unref(udev);
ret = virGetInterface(conn, def->name, def->mac);
udev_device_unref(dev);
-cleanup:
+ cleanup:
udev_unref(udev);
virInterfaceDefFree(def);
ret = virGetInterface(conn, def->name, def->mac);
udev_device_unref(dev);
-cleanup:
+ cleanup:
if (enumerate)
udev_enumerate_unref(enumerate);
udev_unref(udev);
return 0;
-error:
+ error:
for (i = 0; slave_count != -1 && i < slave_count; i++) {
VIR_FREE(slave_list[i]);
}
return 0;
-error:
+ error:
for (i = 0; member_count != -1 && i < member_count; i++) {
VIR_FREE(member_list[i]);
}
return 0;
-error:
+ error:
VIR_FREE(ifacedef->data.vlan.tag);
VIR_FREE(ifacedef->data.vlan.devname);
return ifacedef;
-error:
+ error:
udev_device_unref(dev);
virInterfaceDefFree(ifacedef);
virInterfaceDefFree(ifacedef);
-cleanup:
+ cleanup:
/* decrement our udev ptr */
udev_unref(udev);
udev_device_unref(dev);
-cleanup:
+ cleanup:
udev_unref(udev);
virInterfaceDefFree(def);
virReportUnsupportedError();
-error:
+ error:
virDispatchError(conn);
return -1;
}
return 0;
-error:
+ error:
virDispatchError(domain->conn);
return -1;
}
return 0;
-error:
+ error:
virDispatchError(NULL);
return -1;
}
virReportUnsupportedError();
-error:
+ error:
virDispatchError(conn);
return -1;
}
virReportUnsupportedError();
-error:
+ error:
virDispatchError(conn);
return NULL;
}
virReportUnsupportedError();
-error:
+ error:
virDispatchError(conn);
return NULL;
}
}
virReportUnsupportedError();
-error:
+ error:
virDispatchError(conn);
return -1;
}
}
virReportUnsupportedError();
-error:
+ error:
virDispatchError(conn);
return -1;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(driver_link);
VIR_FREE(devpath);
return ret;
ret = virGetNodeDevice(conn, name);
-cleanup:
+ cleanup:
if (obj)
virNodeDeviceObjUnlock(obj);
return ret;
virNodeDeviceObjUnlock(obj);
}
-out:
+ out:
nodeDeviceUnlock(driver);
return dev;
}
ret = virNodeDeviceDefFormat(obj->def);
-cleanup:
+ cleanup:
if (obj)
virNodeDeviceObjUnlock(obj);
return ret;
"%s", _("no parent for this device"));
}
-cleanup:
+ cleanup:
if (obj)
virNodeDeviceObjUnlock(obj);
return ret;
++ncaps;
ret = ncaps;
-cleanup:
+ cleanup:
if (obj)
virNodeDeviceObjUnlock(obj);
return ret;
}
ret = ncaps;
-cleanup:
+ cleanup:
if (obj)
virNodeDeviceObjUnlock(obj);
if (ret == -1) {
virReportError(VIR_ERR_NO_NODE_DEVICE, NULL);
}
-cleanup:
+ cleanup:
nodeDeviceUnlock(driver);
virNodeDeviceDefFree(def);
VIR_FREE(wwnn);
}
ret = 0;
-out:
+ out:
if (obj)
virNodeDeviceObjUnlock(obj);
VIR_FREE(parent_name);
goto out;
}
-out:
+ out:
return retval;
}
failure:
VIR_DEBUG("FAILED TO ADD dev %s", name);
-cleanup:
+ cleanup:
VIR_FREE(privData);
virNodeDeviceDefFree(def);
nodeDeviceUnlock(driverState);
}
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0) {
/* Clear the two flags in case of producing confusing XML output */
d->scsi_host.flags &= ~(VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST |
property_key, *property_value,
udev_device_get_sysname(udev_device));
-out:
+ out:
return ret;
}
attr_name, *attr_value,
udev_device_get_sysname(udev_device));
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
if (ret != 0) {
VIR_ERROR(_("Failed to process SCSI device with sysfs path '%s'"),
def->sysfs_path);
data->storage.size = data->storage.num_blocks *
data->storage.logical_block_size;
-out:
+ out:
return ret;
}
def->caps->data.storage.logical_block_size;
}
-out:
+ out:
return ret;
}
has_media = tmp_int;
ret = udevProcessRemoveableMedia(device, def, has_media);
-out:
+ out:
return ret;
}
data->storage.size = data->storage.num_blocks *
data->storage.logical_block_size;
-out:
+ out:
return ret;
}
goto out;
}
-out:
+ out:
VIR_DEBUG("Storage ret=%d", ret);
return ret;
}
ret = 0;
-out:
+ out:
return ret;
}
ret = 0;
-out:
+ out:
if (ret != 0) {
VIR_DEBUG("Discarding device %d %p %s", ret, def,
def ? NULLSTR(def->sysfs_path) : "");
udevProcessDeviceListEntry(udev, list_entry);
}
-out:
+ out:
udev_enumerate_unref(udev_enumerate);
return ret;
}
goto out;
}
-out:
+ out:
udev_device_unref(device);
nodeDeviceUnlock(driverState);
return;
goto out;
}
-out:
+ out:
VIR_FREE(tmp);
if (device != NULL) {
udev_device_unref(device);
ret = 0;
-out:
+ out:
if (ret == -1) {
virNodeDeviceDefFree(def);
}
goto out_unlock;
}
-out_unlock:
+ out_unlock:
nodeDeviceUnlock(driverState);
-out:
+ out:
if (ret == -1) {
nodeStateCleanup();
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cpu_times);
return ret;
goto cleanup;
}
-cleanup:
+ cleanup:
VIR_FORCE_FCLOSE(pathfp);
VIR_FREE(path);
i++;
}
-cleanup:
+ cleanup:
VIR_FORCE_FCLOSE(pathfp);
VIR_FREE(path);
ret = processors;
-cleanup:
+ cleanup:
/* don't shadow a more serious error */
if (cpudir && closedir(cpudir) < 0 && ret >= 0) {
virReportSystemError(errno, _("problem closing %s"), node);
if (nodeinfo->cpus && nodeinfo->nodes)
goto done;
-fallback:
+ fallback:
VIR_FREE(sysfs_cpudir);
if (virAsprintf(&sysfs_cpudir, "%s/cpu", sysfs_dir) < 0)
nodeinfo->cores = cores;
nodeinfo->threads = threads;
-done:
+ done:
/* There should always be at least one cpu, socket, node, and thread. */
if (nodeinfo->cpus == 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no CPUs found"));
ret = 0;
-cleanup:
+ cleanup:
/* don't shadow a more serious error */
if (nodedir && closedir(nodedir) < 0 && ret >= 0) {
virReportSystemError(errno, _("problem closing %s"), sysfs_nodedir);
_("Invalid cpuNum in %s"),
__FUNCTION__);
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
} while (*tmp++ != '\n');
ret++;
-cleanup:
+ cleanup:
VIR_FREE(str);
return ret;
}
VIR_FREE(str);
return map;
-error:
+ error:
VIR_FREE(str);
virBitmapFree(map);
return NULL;
if (virBitmapParse(buf, 0, &ret, virNumaGetMaxCPUs()) < 0)
goto cleanup;
-cleanup:
+ cleanup:
VIR_FREE(buf);
VIR_FREE(path);
return ret;
/* Convert to KB. */
nodeinfo->memory = physmem_total() / 1024;
-cleanup:
+ cleanup:
VIR_FORCE_FCLOSE(cpuinfo);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(path);
VIR_FREE(strval);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(path);
VIR_FREE(buf);
return ret;
*online = virBitmapCountBits(cpus);
ret = maxpresent;
-cleanup:
+ cleanup:
if (ret < 0 && cpumap)
VIR_FREE(*cpumap);
virBitmapFree(cpus);
ret = 0;
-cleanup:
+ cleanup:
if (topology_failed || ret < 0)
virCapabilitiesClearHostNUMACellCPUTopology(cpus, ncpus);
}
ret = numCells;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(help);
}
}
ret = 0;
-error:
+ error:
VIR_FREE(str);
return ret;
}
return caps;
-no_memory:
+ no_memory:
virObjectUnref(caps);
return NULL;
}
return 0;
-error:
+ error:
VIR_FREE(temp);
virDomainNetDefFree(net);
return -1;
VIR_FREE(temp);
return 0;
-no_memory:
+ no_memory:
virReportOOMError();
-error:
+ error:
VIR_FREE(temp);
virDomainFSDefFree(fs);
return -1;
}
ret = 0;
-error:
+ error:
VIR_FREE(temp);
return ret;
}
return 0;
-error:
+ error:
VIR_FREE(line);
VIR_FORCE_FCLOSE(fp);
VIR_FORCE_CLOSE(temp_fd);
return 0;
-error:
+ error:
VIR_FREE(line);
VIR_FORCE_FCLOSE(fp);
VIR_FORCE_CLOSE(copy_fd);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(confdir);
VIR_FREE(default_conf_file);
VIR_FREE(configfile_value);
i++;
}
-cleanup:
+ cleanup:
return ret;
}
}
}
retval = 0;
-cleanup:
+ cleanup:
VIR_FREE(line);
VIR_FORCE_FCLOSE(fp);
VIR_FREE(conf_file);
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_FCLOSE(fp);
VIR_FREE(conf_file);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(confdir);
virCommandFree(cmd);
}
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
return ret;
goto error;
}
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return hostname;
-error:
+ error:
VIR_FREE(hostname);
goto cleanup;
}
if (dom)
dom->id = vm->def->id;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return dom;
ignore_value(VIR_STRDUP(ret, vm->def->os.type));
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
if (dom)
dom->id = vm->def->id;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return dom;
if (dom)
dom->id = vm->def->id;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return dom;
info->nrVirtCpu = vm->def->vcpus;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = openvzGetVEStatus(vm, state, reason);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
}
ret = virDomainObjIsActive(obj);
-cleanup:
+ cleanup:
if (obj)
virObjectUnlock(obj);
return ret;
}
ret = obj->persistent;
-cleanup:
+ cleanup:
if (obj)
virObjectUnlock(obj);
return ret;
ret = virDomainDefFormat(vm->def, flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
dom->id = -1;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
return 0;
-exit:
+ exit:
virBufferFreeAndReset(&buf);
return -1;
}
if (dom)
dom->id = -1;
-cleanup:
+ cleanup:
virDomainDefFree(vmdef);
if (vm)
virObjectUnlock(vm);
if (dom)
dom->id = vm->def->id;
-cleanup:
+ cleanup:
virDomainDefFree(vmdef);
if (vm)
virObjectUnlock(vm);
virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED);
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
openvzDriverUnlock(driver);
}
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
*autostart = 1;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(value);
if (vm)
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
return VIR_DRV_OPEN_SUCCESS;
-cleanup:
+ cleanup:
openvzFreeDriver(driver);
return VIR_DRV_OPEN_ERROR;
};
}
rc = got;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(outfd);
virCommandFree(cmd);
return rc;
}
rc = got;
-out:
+ out:
VIR_FORCE_CLOSE(outfd);
virCommandFree(cmd);
if (rc < 0) {
int err = 0;
/* read statistic from /proc/vz/vestat.
-sample:
+ sample:
Version: 2.2
VEID user nice system uptime idle other..
33 78 0 1330 59454597 142650441835148 other..
return 0;
-cleanup:
+ cleanup:
return -1;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(output);
virCommandFree(cmd);
return ret;
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
return ret;
}
*nparams = OPENVZ_NB_MEM_PARAM;
result = 0;
-cleanup:
+ cleanup:
return result;
}
}
}
result = 0;
-cleanup:
+ cleanup:
return result;
}
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(outbuf);
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:
openvzDriverUnlock(driver);
virDomainDeviceDefFree(dev);
if (vm)
if (len && output[len - 1] == '\n')
output[len - 1] = '\0';
-cleanup:
+ cleanup:
virCommandFree(cmd);
return output;
}
}
return virBufferContentAndReset(&tex_ret);
-err:
+ err:
(*exit_status) = SSH_CMD_ERR;
virBufferFreeAndReset(&tex_ret);
VIR_FREE(buffer);
return caps;
-no_memory:
+ no_memory:
virObjectUnref(caps);
return NULL;
}
line++; /* skip \n */
}
-cleanup:
+ cleanup:
VIR_FREE(ret);
return got;
}
}
return 0;
-err:
+ err:
VIR_FORCE_CLOSE(fd);
return -1;
}
ret = 0;
-cleanup:
+ cleanup:
if (channel) {
libssh2_channel_send_eof(channel);
libssh2_channel_wait_eof(channel);
return 0;
-err:
+ err:
return -1;
}
return 0;
-err:
+ err:
VIR_FREE(item);
return -1;
}
VIR_FORCE_CLOSE(fd);
return 0;
-err:
+ err:
VIR_FORCE_CLOSE(fd);
return -1;
}
ret = 0;
-cleanup:
+ cleanup:
if (channel) {
libssh2_channel_send_eof(channel);
libssh2_channel_wait_eof(channel);
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0 && table_created) {
for (i = 0; i < uuid_table->nlpars; i++) {
VIR_FREE(uuid_table->lpars[i]);
freeaddrinfo(ai);
goto err;
-connected:
+ connected:
(*internal_socket) = sock;
NULL)) ==
LIBSSH2_ERROR_EAGAIN);
-keyboard_interactive:
+ keyboard_interactive:
if (rc == LIBSSH2_ERROR_SOCKET_NONE
|| rc == LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED
|| rc == LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED) {
goto err;
}
-disconnect:
+ disconnect:
libssh2_session_disconnect(session, "Disconnecting...");
libssh2_session_free(session);
-err:
+ err:
VIR_FORCE_CLOSE(sock);
VIR_FREE(userhome);
VIR_FREE(pubkey);
VIR_FREE(password);
return NULL;
-exit:
+ exit:
VIR_FREE(userhome);
VIR_FREE(pubkey);
VIR_FREE(pvtkey);
return VIR_DRV_OPEN_SUCCESS;
-failure:
+ failure:
VIR_FREE(managed_system);
if (phyp_driver != NULL) {
if (char_ptr)
*char_ptr = '\0';
-cleanup:
+ cleanup:
VIR_FREE(ret);
return backing_device;
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(profile);
VIR_FREE(vios_name);
VIR_FREE(ret);
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
virDomainDeviceDefFree(dev);
virDomainDefFree(def);
key = phypStorageVolGetKey(conn, lvname);
-cleanup:
+ cleanup:
VIR_FREE(ret);
return key;
return vol;
-err:
+ err:
VIR_FREE(key);
virStorageVolDefFree(voldef);
virStoragePoolDefFree(spdef);
vol = virGetStorageVol(conn, ret, volname, key, NULL, NULL);
-cleanup:
+ cleanup:
VIR_FREE(ret);
VIR_FREE(key);
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
VIR_FREE(voldef.key);
-cleanup:
+ cleanup:
virObjectUnref(sp);
return xml;
}
if (virAsprintf(&path, "/%s/%s/%s", pv, ret, vol->name) < 0)
goto cleanup;
-cleanup:
+ cleanup:
VIR_FREE(ret);
VIR_FREE(path);
success = true;
-cleanup:
+ cleanup:
if (!success) {
for (i = 0; i < got; i++)
VIR_FREE(volumes[i]);
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
success = true;
-cleanup:
+ cleanup:
if (!success) {
for (i = 0; i < got; i++)
VIR_FREE(pools[i]);
}
}
-err:
+ err:
VIR_FREE(local_uuid);
VIR_FREE(pools);
return NULL;
return sp;
-err:
+ err:
virStoragePoolDefFree(def);
virObjectUnref(sp);
return NULL;
return virStoragePoolDefFormat(&def);
-err:
+ err:
return NULL;
}
rv = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return rv;
}
result = virGetInterface(conn, name, mac);
-cleanup:
+ cleanup:
VIR_FREE(ret);
virInterfaceDefFree(def);
return result;
result = virGetInterface(conn, name, ret);
-cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
}
}
}
-cleanup:
+ cleanup:
if (!success) {
for (i = 0; i < got; i++)
VIR_FREE(names[i]);
else if (STREQ(ret, "Shutting Down"))
state = VIR_DOMAIN_SHUTDOWN;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return state;
}
else if (STREQ(ret, "FBPOOL"))
disk_type = VIR_DOMAIN_DISK_TYPE_FILE;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return disk_type;
}
success = true;
-cleanup:
+ cleanup:
if (!success) {
for (i = 0; i < got; i++)
VIR_FREE(names[i]);
if (dom)
dom->id = lpar_id;
-cleanup:
+ cleanup:
VIR_FREE(lpar_name);
return dom;
return virDomainDefFormat(&def, flags);
-err:
+ err:
return NULL;
}
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
result = 0;
- cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
dom->id = -1;
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(ret);
return result;
return dom;
-err:
+ err:
virDomainDefFree(def);
virObjectUnref(dom);
return NULL;
VIR_FREE(tmp_path);
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(fd);
if (tmp_path != NULL) {
unlink(tmp_path);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(filename);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(base64);
VIR_FREE(filename);
return ret;
(void)unlink(value_filename);
-cleanup:
+ cleanup:
VIR_FREE(value_filename);
VIR_FREE(xml_filename);
return ret;
ret = 0;
-cleanup:
+ cleanup:
if (value != NULL) {
memset(value, 0, value_size);
VIR_FREE(value);
ret = secret;
secret = NULL;
-cleanup:
+ cleanup:
secretFree(secret);
virSecretDefFree(def);
VIR_FREE(xml_filename);
ret = 0;
-cleanup:
+ cleanup:
if (dir != NULL)
closedir(dir);
return ret;
secretDriverUnlock(driver);
return i;
-cleanup:
+ cleanup:
secretDriverUnlock(driver);
for (i = 0; i < maxuuids; i++)
secret->def->usage_type,
secretUsageIDForDef(secret->def));
-cleanup:
+ cleanup:
secretDriverUnlock(driver);
return ret;
}
secret->def->usage_type,
secretUsageIDForDef(secret->def));
-cleanup:
+ cleanup:
secretDriverUnlock(driver);
return ret;
}
secretUsageIDForDef(secret->def));
goto cleanup;
-restore_backup:
+ restore_backup:
if (backup) {
/* Error - restore previous state and free new attributes */
secret->def = backup;
secretFree(secret);
}
-cleanup:
+ cleanup:
virSecretDefFree(new_attrs);
secretDriverUnlock(driver);
ret = virSecretDefFormat(secret->def);
-cleanup:
+ cleanup:
secretDriverUnlock(driver);
return ret;
ret = 0;
goto cleanup;
-restore_backup:
+ restore_backup:
/* Error - restore previous state and free new value */
secret->value = old_value;
secret->value_size = old_value_size;
memset(new_value, 0, value_size);
-cleanup:
+ cleanup:
secretDriverUnlock(driver);
VIR_FREE(new_value);
memcpy(ret, secret->value, secret->value_size);
*value_size = secret->value_size;
-cleanup:
+ cleanup:
secretDriverUnlock(driver);
return ret;
ret = 0;
-cleanup:
+ cleanup:
secretDriverUnlock(driver);
return ret;
}
VIR_FREE(content);
- cleanup:
+ cleanup:
VIR_FREE(tmp);
VIR_FREE(etmp);
else
rc = 1;
- failed:
+ failed:
VIR_FREE(tmp);
VIR_FREE(profile);
VIR_FREE(content);
virCommandSetInputBuffer(cmd, xml);
rc = virCommandRun(cmd, NULL);
-cleanup:
+ cleanup:
VIR_FREE(xml);
virCommandFree(cmd);
rc = profile_status(libvirt_daemon, 1);
-cleanup:
+ cleanup:
VIR_FREE(libvirt_daemon);
return rc;
}
}
rc = 0;
- cleanup:
+ cleanup:
VIR_FREE(profile_name);
return rc;
}
rc = SECURITY_DRIVER_ENABLE;
- cleanup:
+ cleanup:
VIR_FREE(template);
return rc;
rc = 0;
goto cleanup;
- err:
+ err:
VIR_FREE(secdef->label);
VIR_FREE(secdef->imagelabel);
VIR_FREE(secdef->model);
- cleanup:
+ cleanup:
VIR_FREE(profile_name);
return rc;
}
rc = 0;
- cleanup:
+ cleanup:
VIR_FREE(profile_name);
return rc;
}
rc = 0;
- cleanup:
+ cleanup:
VIR_FREE(profile_name);
return rc;
virCommandSetAppArmorProfile(cmd, profile_name);
rc = 0;
- cleanup:
+ cleanup:
VIR_FREE(profile_name);
VIR_FREE(cmd_str);
return rc;
}
rc = 0;
- cleanup:
+ cleanup:
VIR_FREE(profile_name);
return rc;
break;
}
-done:
+ done:
VIR_FREE(ptr);
return ret;
}
/* XXX record previous ownership */
rc = virSecurityDACSetOwnership(newpath, 0, 0);
-err:
+ err:
VIR_FREE(newpath);
return rc;
}
break;
}
-done:
+ done:
return ret;
}
break;
}
-done:
+ done:
return ret;
}
break;
}
-done:
+ done:
VIR_FREE(in);
VIR_FREE(out);
return ret;
break;
}
-done:
+ done:
VIR_FREE(in);
VIR_FREE(out);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virObjectUnlock(mgr);
if (generated)
virSecurityLabelDefFree(seclabel);
ret = 0;
-cleanup:
+ cleanup:
if (ret < 0)
VIR_FREE(*sens);
freecon(ourSecContext);
ignore_value(VIR_STRDUP(ret, str));
-cleanup:
+ cleanup:
if (srccon) context_free(srccon);
if (dstcon) context_free(dstcon);
return ret;
if (VIR_STRDUP(ret, str) < 0)
goto cleanup;
VIR_DEBUG("Generated context '%s'", ret);
-cleanup:
+ cleanup:
freecon(ourSecContext);
context_free(ourContext);
context_free(context);
virConfFree(selinux_conf);
return 0;
-error:
+ error:
# if HAVE_SELINUX_LABEL_H
selabel_close(data->label_handle);
data->label_handle = NULL;
return 0;
-error:
+ error:
#if HAVE_SELINUX_LABEL_H
selabel_close(data->label_handle);
data->label_handle = NULL;
rc = 0;
-cleanup:
+ cleanup:
if (rc != 0) {
if (seclabel->type == VIR_DOMAIN_SECLABEL_DYNAMIC)
VIR_FREE(seclabel->label);
return 0;
-error:
+ error:
context_free(ctx);
return -1;
}
rc = virSecuritySELinuxSetFilecon(newpath, fcon);
}
-err:
+ err:
freecon(fcon);
VIR_FREE(newpath);
return rc;
break;
}
-done:
+ done:
return ret;
}
break;
}
-done:
+ done:
return ret;
}
break;
}
-done:
+ done:
VIR_FREE(in);
VIR_FREE(out);
return ret;
break;
}
-done:
+ done:
VIR_FREE(in);
VIR_FREE(out);
return ret;
}
rc = 0;
-done:
+ done:
if (security_getenforce() != 1)
rc = 0;
rc = 0;
-done:
+ done:
if (security_getenforce() != 1)
rc = 0;
rc = virSecuritySELinuxFSetFilecon(fd, str);
}
-cleanup:
+ cleanup:
freecon(fcon);
VIR_FREE(str);
return rc;
}
}
-cleanup:
+ cleanup:
context_free(ctx);
VIR_FREE(mcs);
return label;
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(profile);
return result;
}
rc = 0;
- cleanup:
+ cleanup:
VIR_FREE(pcontent);
VIR_FREE(existing);
}
rc = 0;
- clean_all:
+ clean_all:
VIR_FREE(pcontent);
- clean_replace:
+ clean_replace:
VIR_FREE(replace_name);
VIR_FREE(replace_files);
VIR_FREE(replace_driver);
- clean_tcontent:
+ clean_tcontent:
VIR_FREE(tcontent);
- end:
+ end:
VIR_FREE(template);
return rc;
}
rc = 0;
- error:
+ error:
return rc;
}
rc = 0;
- cleanup:
+ cleanup:
xmlFreeDoc(xml);
xmlXPathFreeContext(ctxt);
rc = 0;
- exit:
+ exit:
return rc;
}
virBufferAsprintf(buf, " \"%s/\" r,\n", tmp);
}
- cleanup:
+ cleanup:
VIR_FREE(tmp);
return rc;
rc = 0;
}
- cleanup:
+ cleanup:
return rc;
}
rc = 0;
ctl->files = virBufferContentAndReset(&buf);
- cleanup:
+ cleanup:
VIR_FREE(uuid);
return rc;
}
VIR_FORCE_CLOSE(tapfd);
return 0;
-error:
+ error:
VIR_FORCE_CLOSE(tapfd);
return -1;
}
return virBufferContentAndReset(&buf);
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
int retries = 0;
if (virAsprintf(&cmd, "config %s%d", dev, def->target.port) < 0)
return -1;
-requery:
+ requery:
if (umlMonitorCommand(driver, dom, cmd, &res) < 0)
return -1;
if (watch != driver->inotifyWatch)
goto cleanup;
-reread:
+ reread:
got = read(fd, buf, sizeof(buf));
if (got == -1) {
if (errno == EINTR)
}
}
-cleanup:
+ cleanup:
umlDriverUnlock(driver);
}
virNWFilterRegisterCallbackDriver(¨CallbackDriver);
return 0;
-out_of_memory:
+ out_of_memory:
VIR_ERROR(_("umlStartup: out of memory"));
-error:
+ error:
VIR_FREE(userdir);
VIR_FREE(base);
umlDriverUnlock(uml_driver);
driver->monitorDir, vm->def->name) < 0)
return -1;
-reopen:
+ reopen:
if (!(file = fopen(pidfile, "r"))) {
if (errno == ENOENT &&
retries++ < 50) {
return -1;
VIR_DEBUG("Dest address for monitor is '%s'", addr.sun_path);
-restat:
+ restat:
if (stat(addr.sun_path, &sb) < 0) {
if (errno == ENOENT &&
retries++ < 50) {
return ret;
-error:
+ error:
VIR_FREE(retdata);
return -1;
}
goto cleanup;
ret = virDomainObjSetDefTransient(driver->caps, driver->xmlopt, vm, false);
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(logfd);
virCommandFree(cmd);
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 = driver->umlVersion;
ret = 0;
-cleanup:
+ cleanup:
umlDriverUnlock(driver);
return ret;
}
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) dom->id = vm->def->id;
-cleanup:
+ cleanup:
virDomainDefFree(def);
if (vm)
virObjectUnlock(vm);
ret = 0;
#endif
-cleanup:
+ cleanup:
VIR_FREE(info);
if (vm)
virObjectUnlock(vm);
}
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (event)
if (VIR_STRDUP(type, vm->def->os.type) < 0)
goto cleanup;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return type;
ret = vm->def->mem.max_balloon;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
vm->def->mem.max_balloon = newmax;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
vm->def->mem.cur_balloon = newmem;
ret = 0;
-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;
vm->newDef : vm->def,
flags);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
VIR_DOMAIN_EVENT_STARTED,
VIR_DOMAIN_EVENT_STARTED_BOOTED);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
if (event)
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) dom->id = vm->def->id;
-cleanup:
+ cleanup:
virDomainDefFree(def);
if (vm)
virObjectUnlock(vm);
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
umlDriverUnlock(driver);
return 0;
-error:
+ error:
VIR_FREE(reply);
VIR_FREE(cmd);
goto cleanup;
}
-cleanup:
+ cleanup:
virDomainDeviceDefFree(dev);
if (vm)
VIR_FREE(reply);
-cleanup:
+ cleanup:
VIR_FREE(cmd);
return ret;
"%s", _("This type of device cannot be hot unplugged"));
}
-cleanup:
+ cleanup:
virDomainDeviceDefFree(dev);
if (vm)
virObjectUnlock(vm);
*autostart = vm->autostart;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
umlDriverUnlock(driver);
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(configFile);
VIR_FREE(autostartLink);
if (vm)
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(fd);
if (vm)
virObjectUnlock(vm);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
umlDriverUnlock(driver);
goto error;
}
-cleanup:
+ cleanup:
virCPUDefFree(cpu);
cpuDataFree(data);
return caps;
-error:
+ error:
virObjectUnref(caps);
goto cleanup;
}
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(outbuf);
virDomainDefFree(vmdef);
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(outbuf);
VIR_FREE(bin);
return 0;
-error:
+ error:
return -1;
}
ret = 0;
- cleanup:
+ cleanup:
VIR_FREE(directoryName);
VIR_FREE(fileName);
return ret;
goto cleanup;
}
-cleanup:
+ cleanup:
VIR_FREE(vmxDir);
VIR_FREE(logFilePath);
VIR_FORCE_FCLOSE(logFile);
return VIR_DRV_OPEN_SUCCESS;
- cleanup:
+ cleanup:
vmwareFreeDriver(driver);
return VIR_DRV_OPEN_ERROR;
};
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(outbuf);
VIR_FREE(vmxAbsolutePath);
if (dom)
dom->id = -1;
- cleanup:
+ cleanup:
virDomainDefFree(vmdef);
VIR_FREE(vmx);
VIR_FREE(directoryName);
}
ret = 0;
- cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
vmwareDriverUnlock(driver);
virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER);
ret = 0;
- cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED);
ret = 0;
- cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
ret = 0;
- cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
if (dom)
dom->id = vm->def->id;
-cleanup:
+ cleanup:
virDomainDefFree(vmdef);
VIR_FREE(vmx);
VIR_FREE(vmxPath);
ret = vmwareStartVM(driver, vm);
-cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
vmwareDriverUnlock(driver);
ret = 0;
- cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
vmwareDriverUnlock(driver);
if (dom)
dom->id = vm->def->id;
- cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return dom;
ignore_value(VIR_STRDUP(ret, vm->def->os.type));
- cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return ret;
if (dom)
dom->id = vm->def->id;
- cleanup:
+ cleanup:
if (vm)
virObjectUnlock(vm);
return dom;
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 = virDomainDefFormat(vm->def, flags);
- 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;
/*
-mapping:
+ mapping:
domain-xml <=> vmx
result = (char *)utf8->content;
utf8->content = NULL;
- cleanup:
+ cleanup:
xmlCharEncCloseFunc(handler);
xmlBufferFree(input);
xmlBufferFree(utf8);
result = 0;
- cleanup:
+ cleanup:
VIR_FREE(autodetectedModels);
return result;
success = true;
- cleanup:
+ cleanup:
if (! success) {
virDomainDefFree(def);
def = NULL;
return 0;
- failure:
+ failure:
VIR_FREE(listenAddr);
virDomainGraphicsDefFree(*def);
*def = NULL;
result = 0;
- cleanup:
+ cleanup:
VIR_FREE(virtualDev_string);
return result;
result = 0;
- cleanup:
+ cleanup:
if (result < 0) {
virDomainDiskDefFree(*def);
*def = NULL;
return result;
- ignore:
+ ignore:
virDomainDiskDefFree(*def);
*def = NULL;
result = 0;
- cleanup:
+ cleanup:
if (result < 0) {
virDomainFSDefFree(*def);
*def = NULL;
return result;
- ignore:
+ ignore:
virDomainFSDefFree(*def);
*def = NULL;
result = 0;
- cleanup:
+ cleanup:
if (result < 0) {
virDomainNetDefFree(*def);
*def = NULL;
return result;
- ignore:
+ ignore:
virDomainNetDefFree(*def);
*def = NULL;
result = 0;
- cleanup:
+ cleanup:
if (result < 0) {
virDomainChrDefFree(*def);
*def = NULL;
return result;
- ignore:
+ ignore:
virDomainChrDefFree(*def);
*def = NULL;
result = 0;
- cleanup:
+ cleanup:
if (result < 0) {
virDomainChrDefFree(*def);
*def = NULL;
return result;
- ignore:
+ ignore:
virDomainChrDefFree(*def);
*def = NULL;
result = 0;
- cleanup:
+ cleanup:
if (result < 0) {
virDomainVideoDefFree(*def);
*def = NULL;
vmx = virBufferContentAndReset(&buffer);
- cleanup:
+ cleanup:
if (vmx == NULL) {
virBufferFreeAndReset(&buffer);
}
return caps;
- error_cleanup:
+ error_cleanup:
virObjectUnref(caps);
return NULL;
}
xenapiSessionErrorHandler(conn, VIR_ERR_AUTH_FAILED, NULL);
- error:
+ error:
VIR_FREE(username);
VIR_FREE(password);
goto cleanup;
return xml;
}
- cleanup:
+ cleanup:
xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
_("Capabilities not available"));
return NULL;
} else
xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
- cleanup:
+ cleanup:
if (vms)
xen_vm_set_free(vms);
return ostype;
ret = 0;
-cleanup:
+ cleanup:
if (vms)
xen_vm_set_free(vms);
return ret;
virDomainDefFree(defPtr);
return xml;
- error:
+ error:
xen_vm_set_free(vms);
virDomainDefFree(defPtr);
return NULL;
}
}
- cleanup:
+ cleanup:
return result;
- failure:
+ failure:
result = -1;
goto cleanup;
VIR_STRDUP((*strings)->contents[sz-1].val, val) < 0)
goto error;
return 0;
- error:
+ error:
xen_string_string_map_free(*strings);
return -1;
}
}
return 0;
- error:
+ error:
xen_vm_record_free(*record);
return -1;
}
return 0;
-error:
+ error:
return -1;
}
return def;
-error:
+ error:
virDomainChrDefFree(def);
return NULL;
}
return 0;
-error:
+ error:
virDomainDiskDefFree(disk);
return -1;
}
return 0;
-cleanup:
+ cleanup:
virDomainNetDefFree(net);
return -1;
}
return 0;
-error:
+ error:
return -1;
}
}
return 0;
-error:
+ error:
return -1;
}
return 0;
-error:
+ error:
virDomainGraphicsDefFree(graphics);
return -1;
}
return 0;
-error:
+ error:
virDomainGraphicsDefFree(graphics);
return -1;
}
return 0;
-error:
+ error:
virDomainHostdevDefFree(dev);
return -1;
}
return def;
-error:
+ error:
VIR_FREE(tty);
virDomainDefFree(def);
return NULL;
VIR_DEBUG("Formatted sexpr: \n%s", bufout);
return bufout;
-error:
+ error:
virBufferFreeAndReset(&buf);
return NULL;
}
VIR_FREE(script);
return def;
-cleanup:
+ cleanup:
virDomainGraphicsDefFree(graphics);
virDomainNetDefFree(net);
virDomainDiskDefFree(disk);
return 0;
-cleanup:
+ cleanup:
virBufferFreeAndReset(&buf);
return -1;
}
return 0;
-cleanup:
+ cleanup:
virBufferFreeAndReset(&buf);
return -1;
}
return 0;
-cleanup:
+ cleanup:
virBufferFreeAndReset(&buf);
return -1;
}
return 0;
-error:
+ error:
virConfFreeValue(pciVal);
return -1;
}
return conf;
-cleanup:
+ cleanup:
virConfFreeValue(diskVal);
virConfFreeValue(netVal);
VIR_FREE(cpus);
projects / people / liuw / libxenctrl-split / libvirt.git / commitdiff