From: Alexander Burluka <aburl...@parallels.com>
Add code, which can fill virDomainDef structure
by parallels sdk handle. prlsdkCreateDomainObj function
is an analogue of parallelsLoadDomain from parallels_driver.c.
Also use this new code in parallelsDomainGetXMLDesc to check
it and remove build error about unused function.
Signed-off-by: Dmitry Guryanov <dgurya...@parallels.com>
---
src/parallels/parallels_driver.c | 5 +-
src/parallels/parallels_sdk.c | 779 ++++++++++++++++++++++++++++++++++++++-
src/parallels/parallels_sdk.h | 2 +
src/parallels/parallels_utils.h | 1 +
4 files changed, 781 insertions(+), 6 deletions(-)
diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c
index fac1f8e..ac192a0 100644
--- a/src/parallels/parallels_driver.c
+++ b/src/parallels/parallels_driver.c
@@ -1284,16 +1284,13 @@ parallelsDomainGetState(virDomainPtr domain,
static char *
parallelsDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
- parallelsConnPtr privconn = domain->conn->privateData;
virDomainDefPtr def;
virDomainObjPtr privdom;
char *ret = NULL;
/* Flags checked by virDomainDefFormat */
- parallelsDriverLock(privconn);
- privdom = virDomainObjListFindByUUID(privconn->domains, domain->uuid);
- parallelsDriverUnlock(privconn);
+ privdom = prlsdkDomainObjLookupByUUID(domain->conn, domain->uuid);
if (privdom == NULL) {
parallelsDomNotFoundError(domain);
diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c
index 111c52a..ba9d226 100644
--- a/src/parallels/parallels_sdk.c
+++ b/src/parallels/parallels_sdk.c
@@ -25,12 +25,17 @@
#include "virerror.h"
#include "viralloc.h"
#include "datatypes.h"
+#include "virstring.h"
+#include "nodeinfo.h"
+#include "virlog.h"
#include "parallels_sdk.h"
#define VIR_FROM_THIS VIR_FROM_PARALLELS
#define JOB_INFINIT_WAIT_TIMEOUT UINT_MAX
+VIR_LOG_INIT("parallels.sdk");
+
PRL_UINT32 defaultJobTimeout = JOB_INFINIT_WAIT_TIMEOUT;
/*
@@ -475,8 +480,8 @@ prlsdkListAllDomains(virConnectPtr conn,
return j;
error:
- for (j = i - 1; j <= 0; j--)
- virDomainFree(domPtrArray[j]);
+ for (i = j - 1; i <= 0; i--)
+ virDomainFree(domPtrArray[i]);
VIR_FREE(domPtrArray);
PrlHandle_Free(result);
PrlHandle_Free(job);
@@ -565,3 +570,773 @@ prlsdkDomainLookupByName(virConnectPtr conn, const char
*name)
PrlHandle_Free(sdkdom);
return dom;
}
+
+static void
+prlsdkDomObjFreePrivate(void *p)
+{
+ parallelsDomObjPtr pdom = p;
+
+ if (!pdom)
+ return;
+
+ PrlHandle_Free(pdom->sdkdom);
+ virBitmapFree(pdom->cpumask);
+ VIR_FREE(pdom->uuid);
+ VIR_FREE(pdom->home);
+ VIR_FREE(p);
+};
+
+
+static int
+prlsdkAddDomainVideoInfo(PRL_HANDLE sdkdom, virDomainDefPtr def)
+{
+ virDomainVideoDefPtr video = NULL;
+ virDomainVideoAccelDefPtr accel = NULL;
+ PRL_RESULT ret;
+ PRL_UINT32 videoRam;
+
+ /* video info */
+ ret = PrlVmCfg_GetVideoRamSize(sdkdom, &videoRam);
+ prlsdkCheckRetGoto(ret, error);
+
+ if (VIR_ALLOC(video) < 0)
+ goto error;
+
+ if (VIR_ALLOC(accel) < 0)
+ goto error;
+
+ if (VIR_APPEND_ELEMENT_COPY(def->videos, def->nvideos, video) < 0)
+ goto error;
+
+ video->type = VIR_DOMAIN_VIDEO_TYPE_VGA;
+ video->vram = videoRam << 10; /* from mbibytes to kbibytes */
+ video->heads = 1;
+ video->accel = accel;
+
+ return 0;
+
+ error:
+ VIR_FREE(accel);
+ virDomainVideoDefFree(video);
+ return -1;
+}
+
+static int
+prlsdkGetHddInfo(PRL_HANDLE hdd,
+ virDomainDiskDefPtr disk)
+{
+ char *buf = NULL;
+ PRL_UINT32 buflen = 0;
+ PRL_RESULT pret;
+ PRL_UINT32 emulatedType;
+ PRL_UINT32 ifType;
+ PRL_UINT32 pos;
+ PRL_UINT32 hddIndex;
+ int ret = -1;
+
+ pret = PrlVmDev_GetEmulatedType(hdd, &emulatedType);
+ prlsdkCheckRetGoto(pret, cleanup);
+ if (emulatedType == PDT_USE_IMAGE_FILE) {
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
+ virDomainDiskSetFormat(disk, VIR_STORAGE_FILE_PLOOP);
+ } else {
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_BLOCK);
+ }
+
+ pret = PrlVmDev_GetFriendlyName(hdd, NULL, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (VIR_ALLOC_N(buf, buflen) < 0)
+ goto cleanup;
+
+ pret = PrlVmDev_GetFriendlyName(hdd, buf, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (virDomainDiskSetSource(disk, buf) < 0)
+ goto cleanup;
+
+ pret = PrlVmDev_GetIfaceType(hdd, &ifType);
+ prlsdkCheckRetGoto(pret, cleanup);
+ switch (ifType) {
+ case PMS_IDE_DEVICE:
+ disk->bus = VIR_DOMAIN_DISK_BUS_IDE;
+ break;
+ case PMS_SCSI_DEVICE:
+ disk->bus = VIR_DOMAIN_DISK_BUS_SCSI;
+ break;
+ case PMS_SATA_DEVICE:
+ disk->bus = VIR_DOMAIN_DISK_BUS_SATA;
+ break;
+ default:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Unknown disk bus: %X"), ifType);
+ goto cleanup;
+ break;
+ }
+
+ pret = PrlVmDev_GetStackIndex(hdd, &pos);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE;
+ disk->info.addr.drive.target = pos;
+
+ pret = PrlVmDev_GetIndex(hdd, &hddIndex);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (!(disk->dst = virIndexToDiskName(hddIndex, "sd")))
+ goto cleanup;
+
+ ret = 0;
+
+ cleanup:
+ VIR_FREE(buf);
+ return ret;
+}
+
+static int
+prlsdkAddDomainHardDisksInfo(PRL_HANDLE sdkdom, virDomainDefPtr def)
+{
+ PRL_RESULT pret;
+ PRL_UINT32 hddCount;
+ PRL_UINT32 i;
+ PRL_HANDLE hdd = PRL_INVALID_HANDLE;
+ virDomainDiskDefPtr disk = NULL;
+
+ pret = PrlVmCfg_GetHardDisksCount(sdkdom, &hddCount);
+ prlsdkCheckRetGoto(pret, error);
+
+ for (i = 0; i < hddCount; ++i) {
+ pret = PrlVmCfg_GetHardDisk(sdkdom, i, &hdd);
+ prlsdkCheckRetGoto(pret, error);
+
+ if (IS_CT(def)) {
+ /* TODO: convert info about disks in container
+ * to virDomainFSDef structs */
+ VIR_WARN("Skipping disk information for container");
+
+ PrlHandle_Free(hdd);
+ hdd = PRL_INVALID_HANDLE;
+ } else {
+ if (!(disk = virDomainDiskDefNew()))
+ goto error;
+
+ if (prlsdkGetHddInfo(hdd, disk) < 0)
+ goto error;
+
+ PrlHandle_Free(hdd);
+ hdd = PRL_INVALID_HANDLE;
+
+ if (VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk) < 0)
+ goto error;
+ }
+ }
+
+ return 0;
+
+ error:
+ PrlHandle_Free(hdd);
+ virDomainDiskDefFree(disk);
+ return -1;
+}
+
+static int
+prlsdkGetNetInfo(PRL_HANDLE netAdapter, virDomainNetDefPtr net, bool isCt)
+{
+ char macstr[VIR_MAC_STRING_BUFLEN];
+ PRL_UINT32 buflen;
+ PRL_UINT32 netAdapterIndex;
+ PRL_UINT32 emulatedType;
+ PRL_RESULT pret;
+ PRL_BOOL isConnected;
+ int ret = -1;
+
+ net->type = VIR_DOMAIN_NET_TYPE_NETWORK;
+
+
+ /* use device name, shown by prlctl as target device
+ * for identifying network adapter in virDomainDefineXML */
+ pret = PrlVmDev_GetIndex(netAdapter, &netAdapterIndex);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ pret = PrlVmDevNet_GetHostInterfaceName(netAdapter, NULL, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (VIR_ALLOC_N(net->ifname, buflen) < 0)
+ goto cleanup;
+
+ pret = PrlVmDevNet_GetHostInterfaceName(netAdapter, net->ifname, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (isCt && netAdapterIndex == (PRL_UINT32) -1) {
+ /* venet devices don't have mac address and
+ * always up */
+ net->linkstate = VIR_DOMAIN_NET_INTERFACE_LINK_STATE_UP;
+ if (VIR_STRDUP(net->data.network.name,
+ PARALLELS_ROUTED_NETWORK_NAME) < 0)
+ goto cleanup;
+ return 0;
+ }
+
+ buflen = ARRAY_CARDINALITY(macstr);
+ if (VIR_ALLOC_N(macstr, buflen))
+ goto cleanup;
+ pret = PrlVmDevNet_GetMacAddressCanonical(netAdapter, macstr, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (virMacAddrParse(macstr, &net->mac) < 0)
+ goto cleanup;
+
+ pret = PrlVmDev_GetEmulatedType(netAdapter, &emulatedType);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (emulatedType == PNA_ROUTED) {
+ if (VIR_STRDUP(net->data.network.name,
+ PARALLELS_ROUTED_NETWORK_NAME) < 0)
+ goto cleanup;
+ } else {
+ pret = PrlVmDevNet_GetVirtualNetworkId(netAdapter, NULL, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (VIR_ALLOC_N(net->data.network.name, buflen) < 0)
+ goto cleanup;
+
+ pret = PrlVmDevNet_GetVirtualNetworkId(netAdapter,
+ net->data.network.name,
+ &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+ }
+
+ pret = PrlVmDev_IsConnected(netAdapter, &isConnected);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (isConnected)
+ net->linkstate = VIR_DOMAIN_NET_INTERFACE_LINK_STATE_UP;
+ else
+ net->linkstate = VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN;
+
+ ret = 0;
+ cleanup:
+ return ret;
+}
+
+static int
+prlsdkAddDomainNetInfo(PRL_HANDLE sdkdom, virDomainDefPtr def)
+{
+ virDomainNetDefPtr net = NULL;
+ PRL_RESULT ret;
+ PRL_HANDLE netAdapter;
+ PRL_UINT32 netAdaptersCount;
+ PRL_UINT32 i;
+
+ ret = PrlVmCfg_GetNetAdaptersCount(sdkdom, &netAdaptersCount);
+ prlsdkCheckRetGoto(ret, error);
+ for (i = 0; i < netAdaptersCount; ++i) {
+ ret = PrlVmCfg_GetNetAdapter(sdkdom, i, &netAdapter);
+ prlsdkCheckRetGoto(ret, error);
+
+ if (VIR_ALLOC(net) < 0)
+ goto error;
+
+ if (prlsdkGetNetInfo(netAdapter, net, IS_CT(def)) < 0)
+ goto error;
+
+ PrlHandle_Free(netAdapter);
+ netAdapter = PRL_INVALID_HANDLE;
+
+ if (VIR_APPEND_ELEMENT(def->nets, def->nnets, net) < 0)
+ goto error;
+ }
+
+ return 0;
+
+ error:
+ PrlHandle_Free(netAdapter);
+ virDomainNetDefFree(net);
+ return -1;
+}
+
+static int
+prlsdkGetSerialInfo(PRL_HANDLE serialPort, virDomainChrDefPtr chr)
+{
+ PRL_RESULT pret;
+ PRL_UINT32 serialPortIndex;
+ PRL_UINT32 emulatedType;
+ char *friendlyName = NULL;
+ PRL_UINT32 buflen;
+
+ chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
+ chr->targetTypeAttr = false;
+ pret = PrlVmDev_GetIndex(serialPort, &serialPortIndex);
+ prlsdkCheckRetGoto(pret, error);
+ chr->target.port = serialPortIndex;
+
+ pret = PrlVmDev_GetEmulatedType(serialPort, &emulatedType);
+ prlsdkCheckRetGoto(pret, error);
+
+ pret = PrlVmDev_GetFriendlyName(serialPort, NULL, &buflen);
+ prlsdkCheckRetGoto(pret, error);
+
+ if (VIR_ALLOC_N(friendlyName, buflen) < 0)
+ goto error;
+
+ pret = PrlVmDev_GetFriendlyName(serialPort, friendlyName, &buflen);
+ prlsdkCheckRetGoto(pret, error);
+
+ switch (emulatedType) {
+ case PDT_USE_OUTPUT_FILE:
+ chr->source.type = VIR_DOMAIN_CHR_TYPE_FILE;
+ chr->source.data.file.path = friendlyName;
+ break;
+ case PDT_USE_SERIAL_PORT_SOCKET_MODE:
+ chr->source.type = VIR_DOMAIN_CHR_TYPE_UNIX;
+ chr->source.data.nix.path = friendlyName;
+ break;
+ case PDT_USE_REAL_DEVICE:
+ chr->source.type = VIR_DOMAIN_CHR_TYPE_DEV;
+ chr->source.data.file.path = friendlyName;
+ break;
+ default:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Unknown serial type: %X"), emulatedType);
+ goto error;
+ break;
+ }
+
+ return 0;
+ error:
+ VIR_FREE(friendlyName);
+ return -1;
+}
+
+
+static int
+prlsdkAddSerialInfo(PRL_HANDLE sdkdom,
+ virDomainChrDefPtr **serials,
+ size_t *nserials)
+{
+ PRL_RESULT ret;
+ PRL_HANDLE serialPort;
+ PRL_UINT32 serialPortsCount;
+ PRL_UINT32 i;
+ virDomainChrDefPtr chr = NULL;
+
+ ret = PrlVmCfg_GetSerialPortsCount(sdkdom, &serialPortsCount);
+ prlsdkCheckRetGoto(ret, cleanup);
+ for (i = 0; i < serialPortsCount; ++i) {
+ ret = PrlVmCfg_GetSerialPort(sdkdom, i, &serialPort);
+ prlsdkCheckRetGoto(ret, cleanup);
+
+ if (!(chr = virDomainChrDefNew()))
+ goto cleanup;
+
+ if (prlsdkGetSerialInfo(serialPort, chr))
+ goto cleanup;
+
+ PrlHandle_Free(serialPort);
+ serialPort = PRL_INVALID_HANDLE;
+
+ if (VIR_APPEND_ELEMENT(*serials, *nserials, chr) < 0)
+ goto cleanup;
+ }
+
+ return 0;
+
+ cleanup:
+ PrlHandle_Free(serialPort);
+ virDomainChrDefFree(chr);
+ return -1;
+}
+
+
+static int
+prlsdkAddDomainHardware(PRL_HANDLE sdkdom, virDomainDefPtr def)
+{
+ if (!IS_CT(def))
+ if (prlsdkAddDomainVideoInfo(sdkdom, def) < 0)
+ goto error;
+
+ if (prlsdkAddDomainHardDisksInfo(sdkdom, def) < 0)
+ goto error;
+
+ if (prlsdkAddDomainNetInfo(sdkdom, def) < 0)
+ goto error;
+
+ if (prlsdkAddSerialInfo(sdkdom,
+ &def->serials,
+ &def->nserials) < 0)
+ goto error;
+
+ return 0;
+ error:
+ return -1;
+}
+
+
+static int
+prlsdkAddVNCInfo(PRL_HANDLE sdkdom, virDomainDefPtr def)
+{
+ virDomainGraphicsDefPtr gr = NULL;
+ PRL_VM_REMOTE_DISPLAY_MODE vncMode;
+ PRL_UINT32 port;
+ PRL_UINT32 buflen = 0;
+ PRL_RESULT pret;
+
+ pret = PrlVmCfg_GetVNCMode(sdkdom, &vncMode);
+ prlsdkCheckRetGoto(pret, error);
+
+ if (vncMode == PRD_DISABLED)
+ return 0;
+
+ if (VIR_ALLOC(gr) < 0)
+ goto error;
+
+ pret = PrlVmCfg_GetVNCPort(sdkdom, &port);
+ prlsdkCheckRetGoto(pret, error);
+
+ gr->data.vnc.autoport = (vncMode == PRD_AUTO);
+ gr->type = VIR_DOMAIN_GRAPHICS_TYPE_VNC;
+ gr->data.vnc.port = port;
+ gr->data.vnc.keymap = NULL;
+ gr->data.vnc.socket = NULL;
+ gr->data.vnc.auth.passwd = NULL;
+ gr->data.vnc.auth.expires = false;
+ gr->data.vnc.auth.connected = 0;
+
+ if (VIR_ALLOC(gr->listens) < 0)
+ goto error;
+
+ gr->nListens = 1;
+
+ pret = PrlVmCfg_GetVNCHostName(sdkdom, NULL, &buflen);
+ prlsdkCheckRetGoto(pret, error);
+
+ if (VIR_ALLOC_N(gr->listens[0].address, buflen) < 0)
+ goto error;
+
+ pret = PrlVmCfg_GetVNCHostName(sdkdom, gr->listens[0].address, &buflen);
+ prlsdkCheckRetGoto(pret, error);
+
+ gr->listens[0].type = VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS;
+
+ if (VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, gr) < 0)
+ goto error;
+
+ return 0;
+
+ error:
+ virDomainGraphicsDefFree(gr);
+ return -1;
+}
+
+static int
+prlsdkConvertDomainState(parallelsConnPtr privconn,
+ PRL_HANDLE sdkdom,
+ PRL_UINT32 envId,
+ virDomainObjPtr dom)
+{
+ VIRTUAL_MACHINE_STATE domainState;
+
+ if (prlsdkGetDomainState(privconn, sdkdom, &domainState) < 0)
+ return -1;
+
+ switch (domainState) {
+ case VMS_STOPPED:
+ case VMS_MOUNTED:
+ virDomainObjSetState(dom, VIR_DOMAIN_SHUTOFF,
+ VIR_DOMAIN_SHUTOFF_SHUTDOWN);
+ dom->def->id = -1;
+ break;
+ case VMS_STARTING:
+ case VMS_COMPACTING:
+ case VMS_RESETTING:
+ case VMS_PAUSING:
+ case VMS_RECONNECTING:
+ case VMS_RUNNING:
+ virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
+ VIR_DOMAIN_RUNNING_BOOTED);
+ dom->def->id = envId;
+ break;
+ case VMS_PAUSED:
+ virDomainObjSetState(dom, VIR_DOMAIN_PAUSED,
+ VIR_DOMAIN_PAUSED_USER);
+ dom->def->id = envId;
+ break;
+ case VMS_SUSPENDED:
+ case VMS_DELETING_STATE:
+ case VMS_SUSPENDING_SYNC:
+ virDomainObjSetState(dom, VIR_DOMAIN_SHUTOFF,
+ VIR_DOMAIN_SHUTOFF_SAVED);
+ dom->def->id = -1;
+ break;
+ case VMS_STOPPING:
+ virDomainObjSetState(dom, VIR_DOMAIN_SHUTDOWN,
+ VIR_DOMAIN_SHUTDOWN_USER);
+ dom->def->id = envId;
+ break;
+ case VMS_SNAPSHOTING:
+ virDomainObjSetState(dom, VIR_DOMAIN_PAUSED,
+ VIR_DOMAIN_PAUSED_SNAPSHOT);
+ dom->def->id = envId;
+ break;
+ case VMS_MIGRATING:
+ virDomainObjSetState(dom, VIR_DOMAIN_PAUSED,
+ VIR_DOMAIN_PAUSED_MIGRATION);
+ dom->def->id = envId;
+ break;
+ case VMS_SUSPENDING:
+ virDomainObjSetState(dom, VIR_DOMAIN_PAUSED,
+ VIR_DOMAIN_PAUSED_SAVE);
+ dom->def->id = envId;
+ break;
+ case VMS_RESTORING:
+ virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
+ VIR_DOMAIN_RUNNING_RESTORED);
+ dom->def->id = envId;
+ break;
+ case VMS_CONTINUING:
+ virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
+ VIR_DOMAIN_RUNNING_UNPAUSED);
+ dom->def->id = envId;
+ break;
+ case VMS_RESUMING:
+ virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
+ VIR_DOMAIN_RUNNING_RESTORED);
+ dom->def->id = envId;
+ break;
+ case VMS_UNKNOWN:
+ virDomainObjSetState(dom, VIR_DOMAIN_NOSTATE,
+ VIR_DOMAIN_NOSTATE_UNKNOWN);
+ break;
+ default:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Unknown domain state: %X"), domainState);
+ return -1;
+ break;
+ }
+
+ return 0;
+}
+
+static int
+prlsdkConvertCpuMask(PRL_HANDLE sdkdom, parallelsDomObjPtr pdom)
+{
+ char *buf;
+ PRL_UINT32 buflen = 0;
+ int hostcpus;
+ PRL_RESULT pret;
+ int ret = -1;
+
+ pret = PrlVmCfg_GetCpuMask(sdkdom, NULL, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (VIR_ALLOC_N(buf, buflen) < 0)
+ goto cleanup;
+
+ pret = PrlVmCfg_GetCpuMask(sdkdom, buf, &buflen);
+
+ if ((hostcpus = nodeGetCPUCount()) < 0)
+ goto cleanup;
+
+ if (strlen(buf) == 0) {
+ if (!(pdom->cpumask = virBitmapNew(hostcpus)))
+ goto cleanup;
+ virBitmapSetAll(pdom->cpumask);
+ } else {
+ if (virBitmapParse(buf, 0, &pdom->cpumask, hostcpus) < 0)
+ goto cleanup;
+ }
+
+ ret = 0;
+ cleanup:
+ VIR_FREE(buf);
+ return ret;
+}
+
+static int
+prlsdkConvertDomainType(PRL_HANDLE sdkdom, virDomainDefPtr def)
+{
+ PRL_VM_TYPE domainType;
+ PRL_RESULT pret;
+
+ pret = PrlVmCfg_GetVmType(sdkdom, &domainType);
+ prlsdkCheckRetGoto(pret, error);
+
+ switch (domainType) {
+ case PVT_VM:
+ if (VIR_STRDUP(def->os.type, "hvm") < 0)
+ return -1;
+ break;
+ case PVT_CT:
+ if (VIR_STRDUP(def->os.type, "exe") < 0)
+ return -1;
+ if (VIR_STRDUP(def->os.init, "/sbin/init") < 0)
+ return -1;
+ break;
+ default:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Unknown domain type: %X"), domainType);
+ return -1;
+ }
+
+ return 0;
+
+ error:
+ return -1;
+}
+
+static int
+prlsdkConvertCpuMode(PRL_HANDLE sdkdom, virDomainDefPtr def)
+{
+ PRL_RESULT pret;
+ PRL_CPU_MODE cpuMode;
+
+ pret = PrlVmCfg_GetCpuMode(sdkdom, &cpuMode);
+ prlsdkCheckRetGoto(pret, error);
+
+ switch (cpuMode) {
+ case PCM_CPU_MODE_32:
+ def->os.arch = VIR_ARCH_I686;
+ break;
+ case VIR_ARCH_X86_64:
+ def->os.arch = VIR_ARCH_X86_64;
+ break;
+ default:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Unknown CPU mode: %X"), cpuMode);
+ return -1;
+ }
+
+ return 0;
+ error:
+ return -1;
+}
+
+static virDomainObjPtr
+prlsdkCreateDomainObj(parallelsConnPtr privconn, PRL_HANDLE sdkdom)
+{
+ virDomainObjPtr dom = NULL;
+ virDomainDefPtr def = NULL;
+ parallelsDomObjPtr pdom = NULL;
+
+ PRL_UINT32 buflen = 0;
+ PRL_RESULT pret;
+ PRL_UINT32 cpuCount;
+ PRL_UINT32 ram;
+ PRL_UINT32 envId;
+ PRL_VM_AUTOSTART_OPTION autostart;
+
+ virCheckNonNullArgGoto(privconn, cleanup);
+ virCheckNonNullArgGoto(sdkdom, cleanup);
+
+ if (VIR_ALLOC(def) < 0)
+ goto cleanup;
+
+ if (VIR_ALLOC(pdom) < 0)
+ goto cleanup;
+
+ def->virtType = VIR_DOMAIN_VIRT_PARALLELS;
+ def->id = -1;
+
+ /* we will remove this field in the near future, so let's set it
+ * to NULL temporarily */
+ pdom->uuid = NULL;
+
+ if (prlsdkGetDomainIds(sdkdom, &def->name, def->uuid) < 0)
+ goto cleanup;
+
+ /* get number of CPUs */
+ pret = PrlVmCfg_GetCpuCount(sdkdom, &cpuCount);
+ prlsdkCheckRetGoto(pret, cleanup);
+ def->vcpus = cpuCount;
+ def->maxvcpus = cpuCount;
+
+ /* get RAM parameters */
+ pret = PrlVmCfg_GetRamSize(sdkdom, &ram);
+ prlsdkCheckRetGoto(pret, cleanup);
+ def->mem.max_balloon = ram << 10; /* RAM size obtained in Mbytes,
+ convert to Kbytes */
+ def->mem.cur_balloon = def->mem.max_balloon;
+
+ if (prlsdkConvertCpuMask(sdkdom, pdom) < 0)
+ goto cleanup;
+
+ if (prlsdkConvertCpuMode(sdkdom, def) < 0)
+ goto cleanup;
+
+ if (prlsdkConvertDomainType(sdkdom, def) < 0)
+ goto cleanup;
+
+ if (prlsdkAddDomainHardware(sdkdom, def) < 0)
+ goto cleanup;
+
+ if (prlsdkAddVNCInfo(sdkdom, def) < 0)
+ goto cleanup;
+
+ pret = PrlVmCfg_GetEnvId(sdkdom, &envId);
+ prlsdkCheckRetGoto(pret, cleanup);
+ pdom->id = envId;
+
+ buflen = 0;
+ pret = PrlVmCfg_GetHomePath(sdkdom, NULL, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (VIR_ALLOC_N(pdom->home, buflen) < 0)
+ goto cleanup;
+
+ pret = PrlVmCfg_GetHomePath(sdkdom, pdom->home, &buflen);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ if (!(dom = virDomainObjNew(privconn->xmlopt)))
+ goto cleanup;
+
+ dom->def = def;
+ dom->privateData = pdom;
+ dom->privateDataFreeFunc = prlsdkDomObjFreePrivate;
+ dom->persistent = 1;
+
+ if (prlsdkConvertDomainState(privconn, sdkdom, envId, dom) < 0)
+ goto cleanup;
+
+ pret = PrlVmCfg_GetAutoStart(sdkdom, &autostart);
+ prlsdkCheckRetGoto(pret, cleanup);
+
+ switch (autostart) {
+ case PAO_VM_START_ON_LOAD:
+ dom->autostart = 1;
+ break;
+ case PAO_VM_START_MANUAL:
+ dom->autostart = 0;
+ break;
+ default:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Unknown autostart mode: %X"), autostart);
+ goto cleanup;
+ }
+
+ pret = PrlHandle_AddRef(sdkdom);
+ prlsdkCheckRetGoto(pret, cleanup);
+ pdom->sdkdom = sdkdom;
+ /* dom is locked here */
+
+ return dom;
+ cleanup:
+ virDomainDefFree(def);
+ prlsdkDomObjFreePrivate(pdom);
+ return NULL;
+}
+
+virDomainObjPtr
+prlsdkDomainObjLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+ PRL_HANDLE sdkdom;
+ virDomainObjPtr dom = NULL;
+
+ sdkdom = prlsdkSdkDomainLookupByUUID(conn, uuid);
+ if (sdkdom == PRL_INVALID_HANDLE)
+ return NULL;
+
+ dom = prlsdkCreateDomainObj(conn->privateData, sdkdom);
+ PrlHandle_Free(sdkdom);
+
+ return dom;
+}
diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h
index 16df5f2..30c6c21 100644
--- a/src/parallels/parallels_sdk.h
+++ b/src/parallels/parallels_sdk.h
@@ -35,3 +35,5 @@ virDomainPtr
prlsdkDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid);
virDomainPtr
prlsdkDomainLookupByName(virConnectPtr conn, const char *name);
+virDomainObjPtr
+prlsdkDomainObjLookupByUUID(virConnectPtr conn, const unsigned char *uuid);
diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h
index 269020a..95206d6 100644
--- a/src/parallels/parallels_utils.h
+++ b/src/parallels/parallels_utils.h
@@ -61,6 +61,7 @@ struct parallelsDomObj {
char *uuid;
char *home;
virBitmapPtr cpumask;
+ PRL_HANDLE sdkdom;
};
typedef struct parallelsDomObj *parallelsDomObjPtr;
--
1.9.3
--
libvir-list mailing list
libvir-list@redhat.com
https://www.redhat.com/mailman/listinfo/libvir-list
