static virDomainPtr
lightosDomainDefineXML(virConnectPtr conn,const char * xml)
{
lightosConnPtr privconn = conn->privateData;
virDomainPtr dom = NULL;
virDomainDefPtr def = NULL;
virDomainDefPtr oldDef = NULL;
virDomainObjPtr vm = NULL;
if((def = virDomainDefParseString(xml,privconn->caps,privconn->xmlopt,
1<<VIR_DOMAIN_VIRT_LIGHTOS,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
{
goto cleanup;
}
if(!(vm = virDomainObjListAdd(privconn->domains,def,privconn->xmlopt,
0,&olddef)))
goto cleanup;
def = NULL;
vm->persistent = 1;
dom = virGetDomain(conn,vm->def->name,vm->def->uuid);
if(dom)
dom->id = vm->def->id;
if(virDomainSaveConfig(LIGHTOS_CONFIG_DIR,vm->def)<0)
goto cleanup;
cleanup:
virDomainDefFree(def);
virObjectUnlock(vm);
return dom;
}
static virDomainPtr
bhyveDomainDefineXML(virConnectPtr conn, const char *xml)
{
bhyveConnPtr privconn = conn->privateData;
virDomainPtr dom = NULL;
virDomainDefPtr def = NULL;
virDomainDefPtr oldDef = NULL;
virDomainObjPtr vm = NULL;
virCapsPtr caps = NULL;
caps = bhyveDriverGetCapabilities(privconn);
if (!caps)
return NULL;
if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_BHYVE,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
if (virDomainDefineXMLEnsureACL(conn, def) < 0)
goto cleanup;
if (!(vm = virDomainObjListAdd(privconn->domains, def,
privconn->xmlopt,
0, &oldDef)))
goto cleanup;
def = NULL;
vm->persistent = 1;
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom)
dom->id = vm->def->id;
if (virDomainSaveConfig(BHYVE_CONFIG_DIR, vm->def) < 0)
goto cleanup;
cleanup:
virObjectUnref(caps);
virDomainDefFree(def);
virObjectUnlock(vm);
return dom;
}
virDomainObjPtr
vzNewDomain(vzDriverPtr driver, const char *name, const unsigned char *uuid)
{
virDomainDefPtr def = NULL;
virDomainObjPtr dom = NULL;
vzDomObjPtr pdom = NULL;
if (!(def = virDomainDefNewFull(name, uuid, -1)))
goto error;
if (VIR_ALLOC(pdom) < 0)
goto error;
if (virCondInit(&pdom->cache.cond) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("cannot initialize condition"));
goto error;
}
pdom->cache.stats = PRL_INVALID_HANDLE;
pdom->cache.count = -1;
def->virtType = VIR_DOMAIN_VIRT_VZ;
if (!(dom = virDomainObjListAdd(driver->domains, def,
driver->xmlopt,
0, NULL)))
goto error;
dom->privateData = pdom;
dom->privateDataFreeFunc = prlsdkDomObjFreePrivate;
dom->persistent = 1;
return dom;
error:
if (pdom && pdom->cache.count == -1)
virCondDestroy(&pdom->cache.cond);
virDomainDefFree(def);
VIR_FREE(pdom);
return NULL;
}
static virDomainPtr
bhyveDomainCreateXML(virConnectPtr conn,
const char *xml,
unsigned int flags)
{
bhyveConnPtr privconn = conn->privateData;
virDomainPtr dom = NULL;
virDomainDefPtr def = NULL;
virDomainObjPtr vm = NULL;
virObjectEventPtr event = NULL;
virCapsPtr caps = NULL;
unsigned int start_flags = 0;
virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, NULL);
if (flags & VIR_DOMAIN_START_AUTODESTROY)
start_flags |= VIR_BHYVE_PROCESS_START_AUTODESTROY;
caps = bhyveDriverGetCapabilities(privconn);
if (!caps)
return NULL;
if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_BHYVE,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
if (virDomainCreateXMLEnsureACL(conn, def) < 0)
goto cleanup;
if (bhyveDomainAssignAddresses(def, NULL) < 0)
goto cleanup;
if (!(vm = virDomainObjListAdd(privconn->domains, def,
privconn->xmlopt,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE, NULL)))
goto cleanup;
def = NULL;
if (virBhyveProcessStart(conn, privconn, vm,
VIR_DOMAIN_RUNNING_BOOTED,
start_flags) < 0) {
/* If domain is not persistent, remove its data */
if (!vm->persistent) {
virDomainObjListRemove(privconn->domains, vm);
vm = NULL;
}
goto cleanup;
}
event = virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_STARTED,
VIR_DOMAIN_EVENT_STARTED_BOOTED);
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom)
dom->id = vm->def->id;
cleanup:
virObjectUnref(caps);
virDomainDefFree(def);
if (vm)
virObjectUnlock(vm);
if (event)
virObjectEventStateQueue(privconn->domainEventState, event);
return dom;
}
static virDomainPtr
bhyveDomainDefineXML(virConnectPtr conn, const char *xml)
{
bhyveConnPtr privconn = conn->privateData;
virDomainPtr dom = NULL;
virDomainDefPtr def = NULL;
virDomainDefPtr oldDef = NULL;
virDomainObjPtr vm = NULL;
virObjectEventPtr event = NULL;
virCapsPtr caps = NULL;
caps = bhyveDriverGetCapabilities(privconn);
if (!caps)
return NULL;
if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_BHYVE,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
if (virDomainDefineXMLEnsureACL(conn, def) < 0)
goto cleanup;
if (bhyveDomainAssignAddresses(def, NULL) < 0)
goto cleanup;
if (!(vm = virDomainObjListAdd(privconn->domains, def,
privconn->xmlopt,
0, &oldDef)))
goto cleanup;
def = NULL;
vm->persistent = 1;
if (virDomainSaveConfig(BHYVE_CONFIG_DIR,
vm->newDef ? vm->newDef : vm->def) < 0) {
virDomainObjListRemove(privconn->domains, vm);
vm = NULL;
goto cleanup;
}
event = virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_DEFINED,
!oldDef ?
VIR_DOMAIN_EVENT_DEFINED_ADDED :
VIR_DOMAIN_EVENT_DEFINED_UPDATED);
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom)
dom->id = vm->def->id;
cleanup:
virObjectUnref(caps);
virDomainDefFree(def);
virDomainDefFree(oldDef);
if (vm)
virObjectUnlock(vm);
if (event)
virObjectEventStateQueue(privconn->domainEventState, event);
return dom;
}
int
vmwareLoadDomains(struct vmware_driver *driver)
{
virDomainDefPtr vmdef = NULL;
virDomainObjPtr vm = NULL;
char *vmxPath = NULL;
char *vmx = NULL;
vmwareDomainPtr pDomain;
char *directoryName = NULL;
char *fileName = NULL;
int ret = -1;
virVMXContext ctx;
char *outbuf = NULL;
char *str;
char *saveptr = NULL;
virCommandPtr cmd;
ctx.parseFileName = vmwareCopyVMXFileName;
cmd = virCommandNewArgList(VMRUN, "-T",
driver->type == TYPE_PLAYER ? "player" : "ws",
"list", NULL);
virCommandSetOutputBuffer(cmd, &outbuf);
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
for (str = outbuf; (vmxPath = strtok_r(str, "\n", &saveptr)) != NULL;
str = NULL) {
if (vmxPath[0] != '/')
continue;
if (virFileReadAll(vmxPath, 10000, &vmx) < 0)
goto cleanup;
if ((vmdef =
virVMXParseConfig(&ctx, driver->xmlopt, vmx)) == NULL) {
goto cleanup;
}
if (!(vm = virDomainObjListAdd(driver->domains, vmdef,
driver->xmlopt,
0, NULL)))
goto cleanup;
pDomain = vm->privateData;
if (VIR_STRDUP(pDomain->vmxPath, vmxPath) < 0)
goto cleanup;
vmwareDomainConfigDisplay(pDomain, vmdef);
if ((vm->def->id = vmwareExtractPid(vmxPath)) < 0)
goto cleanup;
/* vmrun list only reports running vms */
virDomainObjSetState(vm, VIR_DOMAIN_RUNNING,
VIR_DOMAIN_RUNNING_UNKNOWN);
vm->persistent = 1;
virObjectUnlock(vm);
vmdef = NULL;
vm = NULL;
}
ret = 0;
cleanup:
virCommandFree(cmd);
VIR_FREE(outbuf);
virDomainDefFree(vmdef);
VIR_FREE(directoryName);
VIR_FREE(fileName);
VIR_FREE(vmx);
virObjectUnref(vm);
return ret;
}
static virDomainPtr
vmwareDomainCreateXML(virConnectPtr conn, const char *xml,
unsigned int flags)
{
struct vmware_driver *driver = conn->privateData;
virDomainDefPtr vmdef = NULL;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
char *vmx = NULL;
char *vmxPath = NULL;
vmwareDomainPtr pDomain = NULL;
virVMXContext ctx;
virCheckFlags(0, NULL);
ctx.formatFileName = vmwareCopyVMXFileName;
vmwareDriverLock(driver);
if ((vmdef = virDomainDefParseString(driver->caps, xml,
1 << VIR_DOMAIN_VIRT_VMWARE,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
/* generate vmx file */
vmx = virVMXFormatConfig(&ctx, driver->caps, vmdef, 7);
if (vmx == NULL)
goto cleanup;
if (vmwareVmxPath(vmdef, &vmxPath) < 0)
goto cleanup;
/* create vmx file */
if (virFileWriteStr(vmxPath, vmx, S_IRUSR|S_IWUSR) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Failed to write vmx file '%s'"), vmxPath);
goto cleanup;
}
/* assign def */
if (!(vm = virDomainObjListAdd(driver->domains,
driver->caps,
vmdef,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
goto cleanup;
pDomain = vm->privateData;
pDomain->vmxPath = strdup(vmxPath);
vmwareDomainConfigDisplay(pDomain, vmdef);
vmdef = NULL;
if (vmwareStartVM(driver, vm) < 0) {
virDomainObjListRemove(driver->domains, vm);
vm = NULL;
goto cleanup;
}
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom)
dom->id = vm->def->id;
cleanup:
virDomainDefFree(vmdef);
VIR_FREE(vmx);
VIR_FREE(vmxPath);
if (vm)
virObjectUnlock(vm);
vmwareDriverUnlock(driver);
return dom;
}
int
libxlDomainMigrationPrepare(virConnectPtr dconn,
virDomainDefPtr def,
const char *uri_in,
char **uri_out,
unsigned int flags)
{
libxlDriverPrivatePtr driver = dconn->privateData;
virDomainObjPtr vm = NULL;
char *hostname = NULL;
unsigned short port;
char portstr[100];
virURIPtr uri = NULL;
virNetSocketPtr *socks = NULL;
size_t nsocks = 0;
int nsocks_listen = 0;
libxlMigrationDstArgs *args;
size_t i;
int ret = -1;
if (!(vm = virDomainObjListAdd(driver->domains, def,
driver->xmlopt,
VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
goto cleanup;
/* Create socket connection to receive migration data */
if (!uri_in) {
if ((hostname = virGetHostname()) == NULL)
goto cleanup;
if (STRPREFIX(hostname, "localhost")) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("hostname on destination resolved to localhost,"
" but migration requires an FQDN"));
goto cleanup;
}
if (virPortAllocatorAcquire(driver->migrationPorts, &port) < 0)
goto cleanup;
if (virAsprintf(uri_out, "tcp://%s:%d", hostname, port) < 0)
goto cleanup;
} else {
if (!(STRPREFIX(uri_in, "tcp://"))) {
/* not full URI, add prefix tcp:// */
char *tmp;
if (virAsprintf(&tmp, "tcp://%s", uri_in) < 0)
goto cleanup;
uri = virURIParse(tmp);
VIR_FREE(tmp);
} else {
uri = virURIParse(uri_in);
}
if (uri == NULL) {
virReportError(VIR_ERR_INVALID_ARG,
_("unable to parse URI: %s"),
uri_in);
goto cleanup;
}
if (uri->server == NULL) {
virReportError(VIR_ERR_INVALID_ARG,
_("missing host in migration URI: %s"),
uri_in);
goto cleanup;
} else {
hostname = uri->server;
}
if (uri->port == 0) {
if (virPortAllocatorAcquire(driver->migrationPorts, &port) < 0)
goto cleanup;
} else {
port = uri->port;
}
if (virAsprintf(uri_out, "tcp://%s:%d", hostname, port) < 0)
goto cleanup;
}
snprintf(portstr, sizeof(portstr), "%d", port);
if (virNetSocketNewListenTCP(hostname, portstr, &socks, &nsocks) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("Fail to create socket for incoming migration"));
goto cleanup;
}
if (libxlMigrationDstArgsInitialize() < 0)
goto cleanup;
if (!(args = virObjectNew(libxlMigrationDstArgsClass)))
goto cleanup;
args->conn = dconn;
args->vm = vm;
args->flags = flags;
args->socks = socks;
args->nsocks = nsocks;
for (i = 0; i < nsocks; i++) {
if (virNetSocketSetBlocking(socks[i], true) < 0)
continue;
if (virNetSocketListen(socks[i], 1) < 0)
continue;
if (virNetSocketAddIOCallback(socks[i],
VIR_EVENT_HANDLE_READABLE,
libxlDoMigrateReceive,
args,
virObjectFreeCallback) < 0)
continue;
/*
* Successfully added sock to event loop. Take a ref on args to
* ensure it is not freed until sock is removed from the event loop.
* Ref is dropped in virObjectFreeCallback after being removed
* from the event loop.
*/
virObjectRef(args);
nsocks_listen++;
}
/* Done with args in this function, drop reference */
virObjectUnref(args);
if (!nsocks_listen)
goto cleanup;
ret = 0;
goto done;
cleanup:
for (i = 0; i < nsocks; i++) {
virNetSocketClose(socks[i]);
virObjectUnref(socks[i]);
}
done:
virURIFree(uri);
if (vm)
virObjectUnlock(vm);
return ret;
}
int openvzLoadDomains(struct openvz_driver *driver)
{
int veid, ret;
char *status;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virDomainObjPtr dom = NULL;
virDomainDefPtr def = NULL;
char *temp = NULL;
char *outbuf = NULL;
char *line;
virCommandPtr cmd = NULL;
unsigned int vcpus = 0;
if (openvzAssignUUIDs() < 0)
return -1;
cmd = virCommandNewArgList(VZLIST, "-a", "-ovpsid,status", "-H", NULL);
virCommandSetOutputBuffer(cmd, &outbuf);
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
line = outbuf;
while (line[0] != '\0') {
unsigned int flags = 0;
if (virStrToLong_i(line, &status, 10, &veid) < 0 ||
*status++ != ' ' ||
(line = strchr(status, '\n')) == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Failed to parse vzlist output"));
goto cleanup;
}
*line++ = '\0';
if (!(def = virDomainDefNew()))
goto cleanup;
def->virtType = VIR_DOMAIN_VIRT_OPENVZ;
if (STREQ(status, "stopped"))
def->id = -1;
else
def->id = veid;
if (virAsprintf(&def->name, "%i", veid) < 0)
goto cleanup;
openvzGetVPSUUID(veid, uuidstr, sizeof(uuidstr));
ret = virUUIDParse(uuidstr, def->uuid);
if (ret == -1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("UUID in config file malformed"));
goto cleanup;
}
def->os.type = VIR_DOMAIN_OSTYPE_EXE;
if (VIR_STRDUP(def->os.init, "/sbin/init") < 0)
goto cleanup;
ret = openvzReadVPSConfigParam(veid, "CPUS", &temp);
if (ret < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Could not read config for container %d"),
veid);
goto cleanup;
} else if (ret > 0) {
vcpus = strtoI(temp);
}
if (ret == 0 || vcpus == 0)
vcpus = openvzGetNodeCPUs();
def->maxvcpus = vcpus;
def->vcpus = vcpus;
/* XXX load rest of VM config data .... */
openvzReadNetworkConf(def, veid);
openvzReadFSConf(def, veid);
openvzReadMemConf(def, veid);
virUUIDFormat(def->uuid, uuidstr);
flags = VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE;
if (STRNEQ(status, "stopped"))
flags |= VIR_DOMAIN_OBJ_LIST_ADD_LIVE;
if (!(dom = virDomainObjListAdd(driver->domains,
def,
driver->xmlopt,
flags,
NULL)))
goto cleanup;
if (STREQ(status, "stopped")) {
virDomainObjSetState(dom, VIR_DOMAIN_SHUTOFF,
VIR_DOMAIN_SHUTOFF_UNKNOWN);
dom->pid = -1;
} else {
virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
VIR_DOMAIN_RUNNING_UNKNOWN);
dom->pid = veid;
}
/* XXX OpenVZ doesn't appear to have concept of a transient domain */
dom->persistent = 1;
virObjectUnlock(dom);
dom = NULL;
def = NULL;
}
virCommandFree(cmd);
VIR_FREE(temp);
VIR_FREE(outbuf);
return 0;
cleanup:
virCommandFree(cmd);
VIR_FREE(temp);
VIR_FREE(outbuf);
virObjectUnref(dom);
virDomainDefFree(def);
return -1;
}
int lxctoolsLoadDomains(struct lxctools_driver *driver)
{
int i,flags;
virDomainObjPtr dom = NULL;
virDomainDefPtr def = NULL;
int cret_len;
struct lxc_container** cret;
char** names;
virDomainXMLOptionPtr xmlopt;
if ((cret_len = list_all_containers(driver->path, &names, &cret)) < 0)
goto cleanup;
for (i=0; i < cret_len; ++i) {
if (!(def = virDomainDefNew()))
goto cleanup;
def->virtType = VIR_DOMAIN_VIRT_LXCTOOLS;
if (!cret[i]->is_running(cret[i])) {
def->id = -1;
} else {
def->id = cret[i]->init_pid(cret[i]);
}
if (lxctoolsReadUUID(cret[i], def->uuid) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s", "could not parse UUID");
goto cleanup;
}
def->os.type = VIR_DOMAIN_OSTYPE_EXE;
def->name = names[i];
if (lxctoolsReadConfig(cret[i], def) < 0){
goto cleanup;
}
flags = VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE;
if (def->id != -1)
flags |= VIR_DOMAIN_OBJ_LIST_ADD_LIVE;
if (!(xmlopt = virDomainXMLOptionNew(NULL, NULL, NULL, NULL, NULL)))
goto cleanup;
if (!(dom = virDomainObjListAdd(driver->domains,
def,
xmlopt,
flags,
NULL)))
goto cleanup;
if (!cret[i]->is_running(cret[i])) {
virDomainObjSetState(dom, VIR_DOMAIN_SHUTOFF,
VIR_DOMAIN_SHUTOFF_UNKNOWN);
dom->pid = -1;
} else {
virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
VIR_DOMAIN_RUNNING_UNKNOWN);
dom->pid = cret[i]->init_pid(cret[i]);
}
dom->persistent = 1;
dom->privateData = cret[i];
dom->privateDataFreeFunc = &container_cleaner;
virObjectUnlock(dom);
dom = NULL;
def = NULL;
}
return 0;
cleanup:
VIR_FREE(cret);
virObjectUnref(dom);
virDomainDefFree(def);
return -1;
}
