External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-03-07 17:28:15 +00:00
Code

parallels: change parallels prefixes to vz

Browse Source 
This patch changes all parallels/vz driver structure and
function prefixes from parallels to vz.
No functional changes.

Signed-off-by: Maxim Nestratov <mnestratov@parallels.com>
This commit is contained in:
Maxim Nestratov 2015-06-10 10:50:00 +03:00 committed by Dmitry Guryanov
parent c132b1b6e6
commit 9c70b91ea8
9 changed files with 565 additions and 565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libvirt.c
View File

@ -434,7 +434,7 @@ virGlobalInit(void)
goto error; goto error;
# endif # endif
# ifdef WITH_PARALLELS # ifdef WITH_PARALLELS
if (parallelsRegister() == -1) if (vzRegister() == -1)
goto error; goto error;
# endif # endif
#endif #endif

378
src/parallels/parallels_driver.c
View File

@ -64,22 +64,22 @@ VIR_LOG_INIT("parallels.parallels_driver");
#define PRLCTL "prlctl" #define PRLCTL "prlctl"
#define PRLSRVCTL "prlsrvctl" #define PRLSRVCTL "prlsrvctl"
static int parallelsConnectClose(virConnectPtr conn); static int vzConnectClose(virConnectPtr conn);
void void
parallelsDriverLock(parallelsConnPtr driver) vzDriverLock(vzConnPtr driver)
{ {
virMutexLock(&driver->lock); virMutexLock(&driver->lock);
} }
void void
parallelsDriverUnlock(parallelsConnPtr driver) vzDriverUnlock(vzConnPtr driver)
{ {
virMutexUnlock(&driver->lock); virMutexUnlock(&driver->lock);
} }
static virCapsPtr static virCapsPtr
parallelsBuildCapabilities(void) vzBuildCapabilities(void)
{ {
virCapsPtr caps = NULL; virCapsPtr caps = NULL;
virCPUDefPtr cpu = NULL; virCPUDefPtr cpu = NULL;
@ -177,19 +177,19 @@ parallelsBuildCapabilities(void)
} }
static char * static char *
parallelsConnectGetCapabilities(virConnectPtr conn) vzConnectGetCapabilities(virConnectPtr conn)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
char *xml; char *xml;
parallelsDriverLock(privconn); vzDriverLock(privconn);
xml = virCapabilitiesFormatXML(privconn->caps); xml = virCapabilitiesFormatXML(privconn->caps);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
return xml; return xml;
} }
static int static int
parallelsDomainDefPostParse(virDomainDefPtr def, vzDomainDefPostParse(virDomainDefPtr def,
virCapsPtr caps ATTRIBUTE_UNUSED, virCapsPtr caps ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED) void *opaque ATTRIBUTE_UNUSED)
{ {
@ -201,7 +201,7 @@ parallelsDomainDefPostParse(virDomainDefPtr def,
} }
static int static int
parallelsDomainDeviceDefPostParse(virDomainDeviceDefPtr dev, vzDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
const virDomainDef *def, const virDomainDef *def,
virCapsPtr caps ATTRIBUTE_UNUSED, virCapsPtr caps ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED) void *opaque ATTRIBUTE_UNUSED)
@ -222,17 +222,17 @@ parallelsDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
} }
virDomainDefParserConfig parallelsDomainDefParserConfig = { virDomainDefParserConfig vzDomainDefParserConfig = {
.macPrefix = {0x42, 0x1C, 0x00}, .macPrefix = {0x42, 0x1C, 0x00},
.devicesPostParseCallback = parallelsDomainDeviceDefPostParse, .devicesPostParseCallback = vzDomainDeviceDefPostParse,
.domainPostParseCallback = parallelsDomainDefPostParse, .domainPostParseCallback = vzDomainDefPostParse,
}; };
static int static int
parallelsOpenDefault(virConnectPtr conn) vzOpenDefault(virConnectPtr conn)
{ {
parallelsConnPtr privconn; vzConnPtr privconn;
if (VIR_ALLOC(privconn) < 0) if (VIR_ALLOC(privconn) < 0)
return VIR_DRV_OPEN_ERROR; return VIR_DRV_OPEN_ERROR;
@ -252,10 +252,10 @@ parallelsOpenDefault(virConnectPtr conn)
if (prlsdkConnect(privconn) < 0) if (prlsdkConnect(privconn) < 0)
goto err_free; goto err_free;
if (!(privconn->caps = parallelsBuildCapabilities())) if (!(privconn->caps = vzBuildCapabilities()))
goto error; goto error;
if (!(privconn->xmlopt = virDomainXMLOptionNew(&parallelsDomainDefParserConfig, if (!(privconn->xmlopt = virDomainXMLOptionNew(&vzDomainDefParserConfig,
NULL, NULL))) NULL, NULL)))
goto error; goto error;
@ -288,7 +288,7 @@ parallelsOpenDefault(virConnectPtr conn)
} }
static virDrvOpenStatus static virDrvOpenStatus
parallelsConnectOpen(virConnectPtr conn, vzConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED, virConnectAuthPtr auth ATTRIBUTE_UNUSED,
unsigned int flags) unsigned int flags)
{ {
@ -324,10 +324,10 @@ parallelsConnectOpen(virConnectPtr conn,
return VIR_DRV_OPEN_ERROR; return VIR_DRV_OPEN_ERROR;
} }
if ((ret = parallelsOpenDefault(conn)) != VIR_DRV_OPEN_SUCCESS || if ((ret = vzOpenDefault(conn)) != VIR_DRV_OPEN_SUCCESS ||
(ret = parallelsStorageOpen(conn, flags)) != VIR_DRV_OPEN_SUCCESS || (ret = vzStorageOpen(conn, flags)) != VIR_DRV_OPEN_SUCCESS ||
(ret = parallelsNetworkOpen(conn, flags)) != VIR_DRV_OPEN_SUCCESS) { (ret = vzNetworkOpen(conn, flags)) != VIR_DRV_OPEN_SUCCESS) {
parallelsConnectClose(conn); vzConnectClose(conn);
return ret; return ret;
} }
@ -335,17 +335,17 @@ parallelsConnectOpen(virConnectPtr conn,
} }
static int static int
parallelsConnectClose(virConnectPtr conn) vzConnectClose(virConnectPtr conn)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
if (!privconn) if (!privconn)
return 0; return 0;
parallelsNetworkClose(conn); vzNetworkClose(conn);
parallelsStorageClose(conn); vzStorageClose(conn);
parallelsDriverLock(privconn); vzDriverLock(privconn);
prlsdkUnsubscribeFromPCSEvents(privconn); prlsdkUnsubscribeFromPCSEvents(privconn);
virObjectUnref(privconn->caps); virObjectUnref(privconn->caps);
virObjectUnref(privconn->xmlopt); virObjectUnref(privconn->xmlopt);
@ -355,7 +355,7 @@ parallelsConnectClose(virConnectPtr conn)
conn->privateData = NULL; conn->privateData = NULL;
prlsdkDeinit(); prlsdkDeinit();
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
virMutexDestroy(&privconn->lock); virMutexDestroy(&privconn->lock);
VIR_FREE(privconn); VIR_FREE(privconn);
@ -363,21 +363,21 @@ parallelsConnectClose(virConnectPtr conn)
} }
static int static int
parallelsConnectGetVersion(virConnectPtr conn ATTRIBUTE_UNUSED, unsigned long *hvVer) vzConnectGetVersion(virConnectPtr conn ATTRIBUTE_UNUSED, unsigned long *hvVer)
{ {
char *output, *sVer, *tmp; char *output, *sVer, *tmp;
const char *searchStr = "prlsrvctl version "; const char *searchStr = "prlsrvctl version ";
int ret = -1; int ret = -1;
output = parallelsGetOutput(PRLSRVCTL, "--help", NULL); output = vzGetOutput(PRLSRVCTL, "--help", NULL);
if (!output) { if (!output) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (!(sVer = strstr(output, searchStr))) { if (!(sVer = strstr(output, searchStr))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
@ -386,18 +386,18 @@ parallelsConnectGetVersion(virConnectPtr conn ATTRIBUTE_UNUSED, unsigned long *h
/* parallels server has versions number like 6.0.17977.782218, /* parallels server has versions number like 6.0.17977.782218,
* so libvirt can handle only first two numbers. */ * so libvirt can handle only first two numbers. */
if (!(tmp = strchr(sVer, '.'))) { if (!(tmp = strchr(sVer, '.'))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (!(tmp = strchr(tmp + 1, '.'))) { if (!(tmp = strchr(tmp + 1, '.'))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
tmp[0] = '\0'; tmp[0] = '\0';
if (virParseVersionString(sVer, hvVer, true) < 0) { if (virParseVersionString(sVer, hvVer, true) < 0) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
@ -409,96 +409,96 @@ parallelsConnectGetVersion(virConnectPtr conn ATTRIBUTE_UNUSED, unsigned long *h
} }
static char *parallelsConnectGetHostname(virConnectPtr conn ATTRIBUTE_UNUSED) static char *vzConnectGetHostname(virConnectPtr conn ATTRIBUTE_UNUSED)
{ {
return virGetHostname(); return virGetHostname();
} }
static int static int
parallelsConnectListDomains(virConnectPtr conn, int *ids, int maxids) vzConnectListDomains(virConnectPtr conn, int *ids, int maxids)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
int n; int n;
parallelsDriverLock(privconn); vzDriverLock(privconn);
n = virDomainObjListGetActiveIDs(privconn->domains, ids, maxids, n = virDomainObjListGetActiveIDs(privconn->domains, ids, maxids,
NULL, NULL); NULL, NULL);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
return n; return n;
} }
static int static int
parallelsConnectNumOfDomains(virConnectPtr conn) vzConnectNumOfDomains(virConnectPtr conn)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
int count; int count;
parallelsDriverLock(privconn); vzDriverLock(privconn);
count = virDomainObjListNumOfDomains(privconn->domains, true, count = virDomainObjListNumOfDomains(privconn->domains, true,
NULL, NULL); NULL, NULL);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
return count; return count;
} }
static int static int
parallelsConnectListDefinedDomains(virConnectPtr conn, char **const names, int maxnames) vzConnectListDefinedDomains(virConnectPtr conn, char **const names, int maxnames)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
int n; int n;
parallelsDriverLock(privconn); vzDriverLock(privconn);
memset(names, 0, sizeof(*names) * maxnames); memset(names, 0, sizeof(*names) * maxnames);
n = virDomainObjListGetInactiveNames(privconn->domains, names, n = virDomainObjListGetInactiveNames(privconn->domains, names,
maxnames, NULL, NULL); maxnames, NULL, NULL);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
return n; return n;
} }
static int static int
parallelsConnectNumOfDefinedDomains(virConnectPtr conn) vzConnectNumOfDefinedDomains(virConnectPtr conn)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
int count; int count;
parallelsDriverLock(privconn); vzDriverLock(privconn);
count = virDomainObjListNumOfDomains(privconn->domains, false, count = virDomainObjListNumOfDomains(privconn->domains, false,
NULL, NULL); NULL, NULL);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
return count; return count;
} }
static int static int
parallelsConnectListAllDomains(virConnectPtr conn, vzConnectListAllDomains(virConnectPtr conn,
virDomainPtr **domains, virDomainPtr **domains,
unsigned int flags) unsigned int flags)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
int ret = -1; int ret = -1;
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1); virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
parallelsDriverLock(privconn); vzDriverLock(privconn);
ret = virDomainObjListExport(privconn->domains, conn, domains, ret = virDomainObjListExport(privconn->domains, conn, domains,
NULL, flags); NULL, flags);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
return ret; return ret;
} }
static virDomainPtr static virDomainPtr
parallelsDomainLookupByID(virConnectPtr conn, int id) vzDomainLookupByID(virConnectPtr conn, int id)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
virDomainPtr ret = NULL; virDomainPtr ret = NULL;
virDomainObjPtr dom; virDomainObjPtr dom;
parallelsDriverLock(privconn); vzDriverLock(privconn);
dom = virDomainObjListFindByID(privconn->domains, id); dom = virDomainObjListFindByID(privconn->domains, id);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
if (dom == NULL) { if (dom == NULL) {
virReportError(VIR_ERR_NO_DOMAIN, NULL); virReportError(VIR_ERR_NO_DOMAIN, NULL);
@ -516,15 +516,15 @@ parallelsDomainLookupByID(virConnectPtr conn, int id)
} }
static virDomainPtr static virDomainPtr
parallelsDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid) vzDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
virDomainPtr ret = NULL; virDomainPtr ret = NULL;
virDomainObjPtr dom; virDomainObjPtr dom;
parallelsDriverLock(privconn); vzDriverLock(privconn);
dom = virDomainObjListFindByUUID(privconn->domains, uuid); dom = virDomainObjListFindByUUID(privconn->domains, uuid);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
if (dom == NULL) { if (dom == NULL) {
char uuidstr[VIR_UUID_STRING_BUFLEN]; char uuidstr[VIR_UUID_STRING_BUFLEN];
@ -545,15 +545,15 @@ parallelsDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
} }
static virDomainPtr static virDomainPtr
parallelsDomainLookupByName(virConnectPtr conn, const char *name) vzDomainLookupByName(virConnectPtr conn, const char *name)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
virDomainPtr ret = NULL; virDomainPtr ret = NULL;
virDomainObjPtr dom; virDomainObjPtr dom;
parallelsDriverLock(privconn); vzDriverLock(privconn);
dom = virDomainObjListFindByName(privconn->domains, name); dom = virDomainObjListFindByName(privconn->domains, name);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
if (dom == NULL) { if (dom == NULL) {
virReportError(VIR_ERR_NO_DOMAIN, virReportError(VIR_ERR_NO_DOMAIN,
@ -571,12 +571,12 @@ parallelsDomainLookupByName(virConnectPtr conn, const char *name)
} }
static int static int
parallelsDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) vzDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
{ {
virDomainObjPtr privdom; virDomainObjPtr privdom;
int ret = -1; int ret = -1;
if (!(privdom = parallelsDomObjFromDomain(domain))) if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup; goto cleanup;
info->state = virDomainObjGetState(privdom, NULL); info->state = virDomainObjGetState(privdom, NULL);
@ -593,13 +593,13 @@ parallelsDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
} }
static char * static char *
parallelsDomainGetOSType(virDomainPtr domain) vzDomainGetOSType(virDomainPtr domain)
{ {
virDomainObjPtr privdom; virDomainObjPtr privdom;
char *ret = NULL; char *ret = NULL;
if (!(privdom = parallelsDomObjFromDomain(domain))) if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup; goto cleanup;
ignore_value(VIR_STRDUP(ret, virDomainOSTypeToString(privdom->def->os.type))); ignore_value(VIR_STRDUP(ret, virDomainOSTypeToString(privdom->def->os.type)));
@ -611,12 +611,12 @@ parallelsDomainGetOSType(virDomainPtr domain)
} }
static int static int
parallelsDomainIsPersistent(virDomainPtr domain) vzDomainIsPersistent(virDomainPtr domain)
{ {
virDomainObjPtr privdom; virDomainObjPtr privdom;
int ret = -1; int ret = -1;
if (!(privdom = parallelsDomObjFromDomain(domain))) if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup; goto cleanup;
ret = 1; ret = 1;
@ -628,14 +628,14 @@ parallelsDomainIsPersistent(virDomainPtr domain)
} }
static int static int
parallelsDomainGetState(virDomainPtr domain, vzDomainGetState(virDomainPtr domain,
int *state, int *reason, unsigned int flags) int *state, int *reason, unsigned int flags)
{ {
virDomainObjPtr privdom; virDomainObjPtr privdom;
int ret = -1; int ret = -1;
virCheckFlags(0, -1); virCheckFlags(0, -1);
if (!(privdom = parallelsDomObjFromDomain(domain))) if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup; goto cleanup;
*state = virDomainObjGetState(privdom, reason); *state = virDomainObjGetState(privdom, reason);
@ -648,7 +648,7 @@ parallelsDomainGetState(virDomainPtr domain,
} }
static char * static char *
parallelsDomainGetXMLDesc(virDomainPtr domain, unsigned int flags) vzDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{ {
virDomainDefPtr def; virDomainDefPtr def;
virDomainObjPtr privdom; virDomainObjPtr privdom;
@ -656,7 +656,7 @@ parallelsDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
/* Flags checked by virDomainDefFormat */ /* Flags checked by virDomainDefFormat */
if (!(privdom = parallelsDomObjFromDomain(domain))) if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup; goto cleanup;
def = (flags & VIR_DOMAIN_XML_INACTIVE) && def = (flags & VIR_DOMAIN_XML_INACTIVE) &&
@ -671,12 +671,12 @@ parallelsDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
} }
static int static int
parallelsDomainGetAutostart(virDomainPtr domain, int *autostart) vzDomainGetAutostart(virDomainPtr domain, int *autostart)
{ {
virDomainObjPtr privdom; virDomainObjPtr privdom;
int ret = -1; int ret = -1;
if (!(privdom = parallelsDomObjFromDomain(domain))) if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup; goto cleanup;
*autostart = privdom->autostart; *autostart = privdom->autostart;
@ -689,9 +689,9 @@ parallelsDomainGetAutostart(virDomainPtr domain, int *autostart)
} }
static virDomainPtr static virDomainPtr
parallelsDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags) vzDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
virDomainPtr retdom = NULL; virDomainPtr retdom = NULL;
virDomainDefPtr def; virDomainDefPtr def;
virDomainObjPtr olddom = NULL; virDomainObjPtr olddom = NULL;
@ -702,7 +702,7 @@ parallelsDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int
if (flags & VIR_DOMAIN_DEFINE_VALIDATE) if (flags & VIR_DOMAIN_DEFINE_VALIDATE)
parse_flags |= VIR_DOMAIN_DEF_PARSE_VALIDATE; parse_flags |= VIR_DOMAIN_DEF_PARSE_VALIDATE;
parallelsDriverLock(privconn); vzDriverLock(privconn);
if ((def = virDomainDefParseString(xml, privconn->caps, privconn->xmlopt, if ((def = virDomainDefParseString(xml, privconn->caps, privconn->xmlopt,
parse_flags)) == NULL) parse_flags)) == NULL)
goto cleanup; goto cleanup;
@ -766,44 +766,44 @@ parallelsDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int
if (olddom) if (olddom)
virObjectUnlock(olddom); virObjectUnlock(olddom);
virDomainDefFree(def); virDomainDefFree(def);
parallelsDriverUnlock(privconn); vzDriverUnlock(privconn);
return retdom; return retdom;
} }
static virDomainPtr static virDomainPtr
parallelsDomainDefineXML(virConnectPtr conn, const char *xml) vzDomainDefineXML(virConnectPtr conn, const char *xml)
{ {
return parallelsDomainDefineXMLFlags(conn, xml, 0); return vzDomainDefineXMLFlags(conn, xml, 0);
} }
static int static int
parallelsNodeGetInfo(virConnectPtr conn ATTRIBUTE_UNUSED, vzNodeGetInfo(virConnectPtr conn ATTRIBUTE_UNUSED,
virNodeInfoPtr nodeinfo) virNodeInfoPtr nodeinfo)
{ {
return nodeGetInfo(nodeinfo); return nodeGetInfo(nodeinfo);
} }
static int parallelsConnectIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED) static int vzConnectIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
{ {
/* Encryption is not relevant / applicable to way we talk to PCS */ /* Encryption is not relevant / applicable to way we talk to PCS */
return 0; return 0;
} }
static int parallelsConnectIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED) static int vzConnectIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
{ {
/* We run CLI tools directly so this is secure */ /* We run CLI tools directly so this is secure */
return 1; return 1;
} }
static int parallelsConnectIsAlive(virConnectPtr conn ATTRIBUTE_UNUSED) static int vzConnectIsAlive(virConnectPtr conn ATTRIBUTE_UNUSED)
{ {
return 1; return 1;
} }
static char * static char *
parallelsConnectBaselineCPU(virConnectPtr conn ATTRIBUTE_UNUSED, vzConnectBaselineCPU(virConnectPtr conn ATTRIBUTE_UNUSED,
const char **xmlCPUs, const char **xmlCPUs,
unsigned int ncpus, unsigned int ncpus,
unsigned int flags) unsigned int flags)
@ -815,7 +815,7 @@ parallelsConnectBaselineCPU(virConnectPtr conn ATTRIBUTE_UNUSED,
static int static int
parallelsDomainGetVcpus(virDomainPtr domain, vzDomainGetVcpus(virDomainPtr domain,
virVcpuInfoPtr info, virVcpuInfoPtr info,
int maxinfo, int maxinfo,
unsigned char *cpumaps, unsigned char *cpumaps,
@ -826,7 +826,7 @@ parallelsDomainGetVcpus(virDomainPtr domain,
int v, maxcpu, hostcpus; int v, maxcpu, hostcpus;
int ret = -1; int ret = -1;
if (!(privdom = parallelsDomObjFromDomain(domain))) if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup; goto cleanup;
if (!virDomainObjIsActive(privdom)) { if (!virDomainObjIsActive(privdom)) {
@ -877,7 +877,7 @@ parallelsDomainGetVcpus(virDomainPtr domain,
static int static int
parallelsNodeGetCPUMap(virConnectPtr conn ATTRIBUTE_UNUSED, vzNodeGetCPUMap(virConnectPtr conn ATTRIBUTE_UNUSED,
unsigned char **cpumap, unsigned char **cpumap,
unsigned int *online, unsigned int *online,
unsigned int flags) unsigned int flags)
@ -886,7 +886,7 @@ parallelsNodeGetCPUMap(virConnectPtr conn ATTRIBUTE_UNUSED,
} }
static int static int
parallelsConnectDomainEventRegisterAny(virConnectPtr conn, vzConnectDomainEventRegisterAny(virConnectPtr conn,
virDomainPtr domain, virDomainPtr domain,
int eventID, int eventID,
virConnectDomainEventGenericCallback callback, virConnectDomainEventGenericCallback callback,
@ -894,7 +894,7 @@ parallelsConnectDomainEventRegisterAny(virConnectPtr conn,
virFreeCallback freecb) virFreeCallback freecb)
{ {
int ret = -1; int ret = -1;
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
if (virDomainEventStateRegisterID(conn, if (virDomainEventStateRegisterID(conn,
privconn->domainEventState, privconn->domainEventState,
domain, eventID, domain, eventID,
@ -904,10 +904,10 @@ parallelsConnectDomainEventRegisterAny(virConnectPtr conn,
} }
static int static int
parallelsConnectDomainEventDeregisterAny(virConnectPtr conn, vzConnectDomainEventDeregisterAny(virConnectPtr conn,
int callbackID) int callbackID)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
int ret = -1; int ret = -1;
if (virObjectEventStateDeregisterID(conn, if (virObjectEventStateDeregisterID(conn,
@ -921,37 +921,37 @@ parallelsConnectDomainEventDeregisterAny(virConnectPtr conn,
return ret; return ret;
} }
static int parallelsDomainSuspend(virDomainPtr domain) static int vzDomainSuspend(virDomainPtr domain)
{ {
return prlsdkDomainChangeState(domain, prlsdkPause); return prlsdkDomainChangeState(domain, prlsdkPause);
} }
static int parallelsDomainResume(virDomainPtr domain) static int vzDomainResume(virDomainPtr domain)
{ {
return prlsdkDomainChangeState(domain, prlsdkResume); return prlsdkDomainChangeState(domain, prlsdkResume);
} }
static int parallelsDomainCreate(virDomainPtr domain) static int vzDomainCreate(virDomainPtr domain)
{ {
return prlsdkDomainChangeState(domain, prlsdkStart); return prlsdkDomainChangeState(domain, prlsdkStart);
} }
static int parallelsDomainDestroy(virDomainPtr domain) static int vzDomainDestroy(virDomainPtr domain)
{ {
return prlsdkDomainChangeState(domain, prlsdkKill); return prlsdkDomainChangeState(domain, prlsdkKill);
} }
static int parallelsDomainShutdown(virDomainPtr domain) static int vzDomainShutdown(virDomainPtr domain)
{ {
return prlsdkDomainChangeState(domain, prlsdkStop); return prlsdkDomainChangeState(domain, prlsdkStop);
} }
static int parallelsDomainIsActive(virDomainPtr domain) static int vzDomainIsActive(virDomainPtr domain)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
int ret = -1; int ret = -1;
if (!(dom = parallelsDomObjFromDomain(domain))) if (!(dom = vzDomObjFromDomain(domain)))
return -1; return -1;
ret = virDomainObjIsActive(dom); ret = virDomainObjIsActive(dom);
@ -961,25 +961,25 @@ static int parallelsDomainIsActive(virDomainPtr domain)
} }
static int static int
parallelsDomainCreateWithFlags(virDomainPtr domain, unsigned int flags) vzDomainCreateWithFlags(virDomainPtr domain, unsigned int flags)
{ {
/* we don't support any create flags */ /* we don't support any create flags */
virCheckFlags(0, -1); virCheckFlags(0, -1);
return parallelsDomainCreate(domain); return vzDomainCreate(domain);
} }
static int static int
parallelsDomainUndefineFlags(virDomainPtr domain, vzDomainUndefineFlags(virDomainPtr domain,
unsigned int flags) unsigned int flags)
{ {
parallelsConnPtr privconn = domain->conn->privateData; vzConnPtr privconn = domain->conn->privateData;
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
int ret; int ret;
virCheckFlags(0, -1); virCheckFlags(0, -1);
if (!(dom = parallelsDomObjFromDomain(domain))) if (!(dom = vzDomObjFromDomain(domain)))
return -1; return -1;
ret = prlsdkUnregisterDomain(privconn, dom); ret = prlsdkUnregisterDomain(privconn, dom);
@ -990,13 +990,13 @@ parallelsDomainUndefineFlags(virDomainPtr domain,
} }
static int static int
parallelsDomainUndefine(virDomainPtr domain) vzDomainUndefine(virDomainPtr domain)
{ {
return parallelsDomainUndefineFlags(domain, 0); return vzDomainUndefineFlags(domain, 0);
} }
static int static int
parallelsDomainHasManagedSaveImage(virDomainPtr domain, unsigned int flags) vzDomainHasManagedSaveImage(virDomainPtr domain, unsigned int flags)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
int state, reason; int state, reason;
@ -1004,7 +1004,7 @@ parallelsDomainHasManagedSaveImage(virDomainPtr domain, unsigned int flags)
virCheckFlags(0, -1); virCheckFlags(0, -1);
if (!(dom = parallelsDomObjFromDomain(domain))) if (!(dom = vzDomObjFromDomain(domain)))
return -1; return -1;
state = virDomainObjGetState(dom, &reason); state = virDomainObjGetState(dom, &reason);
@ -1016,9 +1016,9 @@ parallelsDomainHasManagedSaveImage(virDomainPtr domain, unsigned int flags)
} }
static int static int
parallelsDomainManagedSave(virDomainPtr domain, unsigned int flags) vzDomainManagedSave(virDomainPtr domain, unsigned int flags)
{ {
parallelsConnPtr privconn = domain->conn->privateData; vzConnPtr privconn = domain->conn->privateData;
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
int state, reason; int state, reason;
int ret = -1; int ret = -1;
@ -1026,7 +1026,7 @@ parallelsDomainManagedSave(virDomainPtr domain, unsigned int flags)
virCheckFlags(VIR_DOMAIN_SAVE_RUNNING | virCheckFlags(VIR_DOMAIN_SAVE_RUNNING |
VIR_DOMAIN_SAVE_PAUSED, -1); VIR_DOMAIN_SAVE_PAUSED, -1);
if (!(dom = parallelsDomObjFromDomain(domain))) if (!(dom = vzDomObjFromDomain(domain)))
return -1; return -1;
state = virDomainObjGetState(dom, &reason); state = virDomainObjGetState(dom, &reason);
@ -1045,7 +1045,7 @@ parallelsDomainManagedSave(virDomainPtr domain, unsigned int flags)
} }
static int static int
parallelsDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags) vzDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
int state, reason; int state, reason;
@ -1053,7 +1053,7 @@ parallelsDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags)
virCheckFlags(0, -1); virCheckFlags(0, -1);
if (!(dom = parallelsDomObjFromDomain(domain))) if (!(dom = vzDomObjFromDomain(domain)))
return -1; return -1;
state = virDomainObjGetState(dom, &reason); state = virDomainObjGetState(dom, &reason);
@ -1068,11 +1068,11 @@ parallelsDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags)
return ret; return ret;
} }
static int parallelsDomainAttachDeviceFlags(virDomainPtr dom, const char *xml, static int vzDomainAttachDeviceFlags(virDomainPtr dom, const char *xml,
unsigned int flags) unsigned int flags)
{ {
int ret = -1; int ret = -1;
parallelsConnPtr privconn = dom->conn->privateData; vzConnPtr privconn = dom->conn->privateData;
virDomainDeviceDefPtr dev = NULL; virDomainDeviceDefPtr dev = NULL;
virDomainObjPtr privdom = NULL; virDomainObjPtr privdom = NULL;
bool domactive = false; bool domactive = false;
@ -1080,7 +1080,7 @@ static int parallelsDomainAttachDeviceFlags(virDomainPtr dom, const char *xml,
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1); VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(privdom = parallelsDomObjFromDomain(dom))) if (!(privdom = vzDomObjFromDomain(dom)))
return -1; return -1;
if (!(flags & VIR_DOMAIN_AFFECT_CONFIG)) { if (!(flags & VIR_DOMAIN_AFFECT_CONFIG)) {
@ -1130,17 +1130,17 @@ static int parallelsDomainAttachDeviceFlags(virDomainPtr dom, const char *xml,
return ret; return ret;
} }
static int parallelsDomainAttachDevice(virDomainPtr dom, const char *xml) static int vzDomainAttachDevice(virDomainPtr dom, const char *xml)
{ {
return parallelsDomainAttachDeviceFlags(dom, xml, return vzDomainAttachDeviceFlags(dom, xml,
VIR_DOMAIN_AFFECT_CONFIG | VIR_DOMAIN_AFFECT_LIVE); VIR_DOMAIN_AFFECT_CONFIG | VIR_DOMAIN_AFFECT_LIVE);
} }
static int parallelsDomainDetachDeviceFlags(virDomainPtr dom, const char *xml, static int vzDomainDetachDeviceFlags(virDomainPtr dom, const char *xml,
unsigned int flags) unsigned int flags)
{ {
int ret = -1; int ret = -1;
parallelsConnPtr privconn = dom->conn->privateData; vzConnPtr privconn = dom->conn->privateData;
virDomainDeviceDefPtr dev = NULL; virDomainDeviceDefPtr dev = NULL;
virDomainObjPtr privdom = NULL; virDomainObjPtr privdom = NULL;
bool domactive = false; bool domactive = false;
@ -1148,7 +1148,7 @@ static int parallelsDomainDetachDeviceFlags(virDomainPtr dom, const char *xml,
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1); VIR_DOMAIN_AFFECT_CONFIG, -1);
privdom = parallelsDomObjFromDomain(dom); privdom = vzDomObjFromDomain(dom);
if (privdom == NULL) if (privdom == NULL)
return -1; return -1;
@ -1199,19 +1199,19 @@ static int parallelsDomainDetachDeviceFlags(virDomainPtr dom, const char *xml,
return ret; return ret;
} }
static int parallelsDomainDetachDevice(virDomainPtr dom, const char *xml) static int vzDomainDetachDevice(virDomainPtr dom, const char *xml)
{ {
return parallelsDomainDetachDeviceFlags(dom, xml, return vzDomainDetachDeviceFlags(dom, xml,
VIR_DOMAIN_AFFECT_CONFIG | VIR_DOMAIN_AFFECT_LIVE); VIR_DOMAIN_AFFECT_CONFIG | VIR_DOMAIN_AFFECT_LIVE);
} }
static unsigned long long static unsigned long long
parallelsDomainGetMaxMemory(virDomainPtr domain) vzDomainGetMaxMemory(virDomainPtr domain)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
int ret = -1; int ret = -1;
if (!(dom = parallelsDomObjFromDomain(domain))) if (!(dom = vzDomObjFromDomain(domain)))
return -1; return -1;
ret = dom->def->mem.max_balloon; ret = dom->def->mem.max_balloon;
@ -1220,7 +1220,7 @@ parallelsDomainGetMaxMemory(virDomainPtr domain)
} }
static int static int
parallelsDomainBlockStats(virDomainPtr domain, const char *path, vzDomainBlockStats(virDomainPtr domain, const char *path,
virDomainBlockStatsPtr stats) virDomainBlockStatsPtr stats)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
@ -1228,7 +1228,7 @@ parallelsDomainBlockStats(virDomainPtr domain, const char *path,
size_t i; size_t i;
int idx; int idx;
if (!(dom = parallelsDomObjFromDomainRef(domain))) if (!(dom = vzDomObjFromDomainRef(domain)))
return -1; return -1;
if (*path) { if (*path) {
@ -1272,7 +1272,7 @@ parallelsDomainBlockStats(virDomainPtr domain, const char *path,
} }
static int static int
parallelsDomainBlockStatsFlags(virDomainPtr domain, vzDomainBlockStatsFlags(virDomainPtr domain,
const char *path, const char *path,
virTypedParameterPtr params, virTypedParameterPtr params,
int *nparams, int *nparams,
@ -1286,7 +1286,7 @@ parallelsDomainBlockStatsFlags(virDomainPtr domain,
/* We don't return strings, and thus trivially support this flag. */ /* We don't return strings, and thus trivially support this flag. */
flags &= ~VIR_TYPED_PARAM_STRING_OKAY; flags &= ~VIR_TYPED_PARAM_STRING_OKAY;
if (parallelsDomainBlockStats(domain, path, &stats) < 0) if (vzDomainBlockStats(domain, path, &stats) < 0)
goto cleanup; goto cleanup;
if (*nparams == 0) { if (*nparams == 0) {
@ -1324,61 +1324,61 @@ parallelsDomainBlockStatsFlags(virDomainPtr domain,
static virHypervisorDriver vzDriver = { static virHypervisorDriver vzDriver = {
.name = "vz", .name = "vz",
.connectOpen = parallelsConnectOpen, /* 0.10.0 */ .connectOpen = vzConnectOpen, /* 0.10.0 */
.connectClose = parallelsConnectClose, /* 0.10.0 */ .connectClose = vzConnectClose, /* 0.10.0 */
.connectGetVersion = parallelsConnectGetVersion, /* 0.10.0 */ .connectGetVersion = vzConnectGetVersion, /* 0.10.0 */
.connectGetHostname = parallelsConnectGetHostname, /* 0.10.0 */ .connectGetHostname = vzConnectGetHostname, /* 0.10.0 */
.nodeGetInfo = parallelsNodeGetInfo, /* 0.10.0 */ .nodeGetInfo = vzNodeGetInfo, /* 0.10.0 */
.connectGetCapabilities = parallelsConnectGetCapabilities, /* 0.10.0 */ .connectGetCapabilities = vzConnectGetCapabilities, /* 0.10.0 */
.connectBaselineCPU = parallelsConnectBaselineCPU, /* 1.2.6 */ .connectBaselineCPU = vzConnectBaselineCPU, /* 1.2.6 */
.connectListDomains = parallelsConnectListDomains, /* 0.10.0 */ .connectListDomains = vzConnectListDomains, /* 0.10.0 */
.connectNumOfDomains = parallelsConnectNumOfDomains, /* 0.10.0 */ .connectNumOfDomains = vzConnectNumOfDomains, /* 0.10.0 */
.connectListDefinedDomains = parallelsConnectListDefinedDomains, /* 0.10.0 */ .connectListDefinedDomains = vzConnectListDefinedDomains, /* 0.10.0 */
.connectNumOfDefinedDomains = parallelsConnectNumOfDefinedDomains, /* 0.10.0 */ .connectNumOfDefinedDomains = vzConnectNumOfDefinedDomains, /* 0.10.0 */
.connectListAllDomains = parallelsConnectListAllDomains, /* 0.10.0 */ .connectListAllDomains = vzConnectListAllDomains, /* 0.10.0 */
.domainLookupByID = parallelsDomainLookupByID, /* 0.10.0 */ .domainLookupByID = vzDomainLookupByID, /* 0.10.0 */
.domainLookupByUUID = parallelsDomainLookupByUUID, /* 0.10.0 */ .domainLookupByUUID = vzDomainLookupByUUID, /* 0.10.0 */
.domainLookupByName = parallelsDomainLookupByName, /* 0.10.0 */ .domainLookupByName = vzDomainLookupByName, /* 0.10.0 */
.domainGetOSType = parallelsDomainGetOSType, /* 0.10.0 */ .domainGetOSType = vzDomainGetOSType, /* 0.10.0 */
.domainGetInfo = parallelsDomainGetInfo, /* 0.10.0 */ .domainGetInfo = vzDomainGetInfo, /* 0.10.0 */
.domainGetState = parallelsDomainGetState, /* 0.10.0 */ .domainGetState = vzDomainGetState, /* 0.10.0 */
.domainGetXMLDesc = parallelsDomainGetXMLDesc, /* 0.10.0 */ .domainGetXMLDesc = vzDomainGetXMLDesc, /* 0.10.0 */
.domainIsPersistent = parallelsDomainIsPersistent, /* 0.10.0 */ .domainIsPersistent = vzDomainIsPersistent, /* 0.10.0 */
.domainGetAutostart = parallelsDomainGetAutostart, /* 0.10.0 */ .domainGetAutostart = vzDomainGetAutostart, /* 0.10.0 */
.domainGetVcpus = parallelsDomainGetVcpus, /* 1.2.6 */ .domainGetVcpus = vzDomainGetVcpus, /* 1.2.6 */
.domainSuspend = parallelsDomainSuspend, /* 0.10.0 */ .domainSuspend = vzDomainSuspend, /* 0.10.0 */
.domainResume = parallelsDomainResume, /* 0.10.0 */ .domainResume = vzDomainResume, /* 0.10.0 */
.domainDestroy = parallelsDomainDestroy, /* 0.10.0 */ .domainDestroy = vzDomainDestroy, /* 0.10.0 */
.domainShutdown = parallelsDomainShutdown, /* 0.10.0 */ .domainShutdown = vzDomainShutdown, /* 0.10.0 */
.domainCreate = parallelsDomainCreate, /* 0.10.0 */ .domainCreate = vzDomainCreate, /* 0.10.0 */
.domainCreateWithFlags = parallelsDomainCreateWithFlags, /* 1.2.10 */ .domainCreateWithFlags = vzDomainCreateWithFlags, /* 1.2.10 */
.domainDefineXML = parallelsDomainDefineXML, /* 0.10.0 */ .domainDefineXML = vzDomainDefineXML, /* 0.10.0 */
.domainDefineXMLFlags = parallelsDomainDefineXMLFlags, /* 1.2.12 */ .domainDefineXMLFlags = vzDomainDefineXMLFlags, /* 1.2.12 */
.domainUndefine = parallelsDomainUndefine, /* 1.2.10 */ .domainUndefine = vzDomainUndefine, /* 1.2.10 */
.domainUndefineFlags = parallelsDomainUndefineFlags, /* 1.2.10 */ .domainUndefineFlags = vzDomainUndefineFlags, /* 1.2.10 */
.domainAttachDevice = parallelsDomainAttachDevice, /* 1.2.15 */ .domainAttachDevice = vzDomainAttachDevice, /* 1.2.15 */
.domainAttachDeviceFlags = parallelsDomainAttachDeviceFlags, /* 1.2.15 */ .domainAttachDeviceFlags = vzDomainAttachDeviceFlags, /* 1.2.15 */
.domainDetachDevice = parallelsDomainDetachDevice, /* 1.2.15 */ .domainDetachDevice = vzDomainDetachDevice, /* 1.2.15 */
.domainDetachDeviceFlags = parallelsDomainDetachDeviceFlags, /* 1.2.15 */ .domainDetachDeviceFlags = vzDomainDetachDeviceFlags, /* 1.2.15 */
.domainIsActive = parallelsDomainIsActive, /* 1.2.10 */ .domainIsActive = vzDomainIsActive, /* 1.2.10 */
.connectDomainEventRegisterAny = parallelsConnectDomainEventRegisterAny, /* 1.2.10 */ .connectDomainEventRegisterAny = vzConnectDomainEventRegisterAny, /* 1.2.10 */
.connectDomainEventDeregisterAny = parallelsConnectDomainEventDeregisterAny, /* 1.2.10 */ .connectDomainEventDeregisterAny = vzConnectDomainEventDeregisterAny, /* 1.2.10 */
.nodeGetCPUMap = parallelsNodeGetCPUMap, /* 1.2.8 */ .nodeGetCPUMap = vzNodeGetCPUMap, /* 1.2.8 */
.connectIsEncrypted = parallelsConnectIsEncrypted, /* 1.2.5 */ .connectIsEncrypted = vzConnectIsEncrypted, /* 1.2.5 */
.connectIsSecure = parallelsConnectIsSecure, /* 1.2.5 */ .connectIsSecure = vzConnectIsSecure, /* 1.2.5 */
.connectIsAlive = parallelsConnectIsAlive, /* 1.2.5 */ .connectIsAlive = vzConnectIsAlive, /* 1.2.5 */
.domainHasManagedSaveImage = parallelsDomainHasManagedSaveImage, /* 1.2.13 */ .domainHasManagedSaveImage = vzDomainHasManagedSaveImage, /* 1.2.13 */
.domainManagedSave = parallelsDomainManagedSave, /* 1.2.14 */ .domainManagedSave = vzDomainManagedSave, /* 1.2.14 */
.domainManagedSaveRemove = parallelsDomainManagedSaveRemove, /* 1.2.14 */ .domainManagedSaveRemove = vzDomainManagedSaveRemove, /* 1.2.14 */
.domainGetMaxMemory = parallelsDomainGetMaxMemory, /* 1.2.15 */ .domainGetMaxMemory = vzDomainGetMaxMemory, /* 1.2.15 */
.domainBlockStats = parallelsDomainBlockStats, /* 1.3.0 */ .domainBlockStats = vzDomainBlockStats, /* 1.3.0 */
.domainBlockStatsFlags = parallelsDomainBlockStatsFlags, /* 1.3.0 */ .domainBlockStatsFlags = vzDomainBlockStatsFlags, /* 1.3.0 */
}; };
static virConnectDriver vzConnectDriver = { static virConnectDriver vzConnectDriver = {
.hypervisorDriver = &vzDriver, .hypervisorDriver = &vzDriver,
.storageDriver = &parallelsStorageDriver, .storageDriver = &vzStorageDriver,
.networkDriver = &parallelsNetworkDriver, .networkDriver = &vzNetworkDriver,
}; };
/* Parallels domain type backward compatibility*/ /* Parallels domain type backward compatibility*/
@ -1386,12 +1386,12 @@ static virHypervisorDriver parallelsDriver;
static virConnectDriver parallelsConnectDriver; static virConnectDriver parallelsConnectDriver;
/** /**
* parallelsRegister: * vzRegister:
* *
* Registers the parallels driver * Registers the vz driver
*/ */
int int
parallelsRegister(void) vzRegister(void)
{ {
char *prlctl_path; char *prlctl_path;

2
src/parallels/parallels_driver.h
View File

@ -23,6 +23,6 @@
#ifndef PARALLELS_DRIVER_H #ifndef PARALLELS_DRIVER_H
# define PARALLELS_DRIVER_H # define PARALLELS_DRIVER_H
int parallelsRegister(void); int vzRegister(void);
#endif #endif

138
src/parallels/parallels_network.c
View File

@ -36,11 +36,11 @@
#define VIR_FROM_THIS VIR_FROM_PARALLELS #define VIR_FROM_THIS VIR_FROM_PARALLELS
#define PARALLELS_ROUTED_NETWORK_UUID "eb593dd1-6846-45b0-84a0-de0729286982" #define PARALLELS_ROUTED_NETWORK_UUID "eb593dd1-6846-45b0-84a0-de0729286982"
#define parallelsParseError() \ #define vzParseError() \
virReportErrorHelper(VIR_FROM_TEST, VIR_ERR_OPERATION_FAILED, __FILE__, \ virReportErrorHelper(VIR_FROM_TEST, VIR_ERR_OPERATION_FAILED, __FILE__, \
__FUNCTION__, __LINE__, _("Can't parse prlctl output")) __FUNCTION__, __LINE__, _("Can't parse prlctl output"))
static int parallelsGetBridgedNetInfo(virNetworkDefPtr def, virJSONValuePtr jobj) static int vzGetBridgedNetInfo(virNetworkDefPtr def, virJSONValuePtr jobj)
{ {
const char *ifname; const char *ifname;
char *bridgeLink = NULL; char *bridgeLink = NULL;
@ -51,7 +51,7 @@ static int parallelsGetBridgedNetInfo(virNetworkDefPtr def, virJSONValuePtr jobj
int ret = -1; int ret = -1;
if (!(ifname = virJSONValueObjectGetString(jobj, "Bound To"))) { if (!(ifname = virJSONValueObjectGetString(jobj, "Bound To"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
@ -100,7 +100,7 @@ static int parallelsGetBridgedNetInfo(virNetworkDefPtr def, virJSONValuePtr jobj
return ret; return ret;
} }
static int parallelsGetHostOnlyNetInfo(virNetworkDefPtr def, const char *name) static int vzGetHostOnlyNetInfo(virNetworkDefPtr def, const char *name)
{ {
const char *tmp; const char *tmp;
virJSONValuePtr jobj = NULL, jobj2; virJSONValuePtr jobj = NULL, jobj2;
@ -109,15 +109,15 @@ static int parallelsGetHostOnlyNetInfo(virNetworkDefPtr def, const char *name)
if (VIR_EXPAND_N(def->ips, def->nips, 1) < 0) if (VIR_EXPAND_N(def->ips, def->nips, 1) < 0)
goto cleanup; goto cleanup;
jobj = parallelsParseOutput("prlsrvctl", "net", "info", "-j", name, NULL); jobj = vzParseOutput("prlsrvctl", "net", "info", "-j", name, NULL);
if (!jobj) { if (!jobj) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (!(jobj2 = virJSONValueObjectGet(jobj, "Parallels adapter"))) { if (!(jobj2 = virJSONValueObjectGet(jobj, "Parallels adapter"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
@ -125,27 +125,27 @@ static int parallelsGetHostOnlyNetInfo(virNetworkDefPtr def, const char *name)
goto cleanup; goto cleanup;
if (!(tmp = virJSONValueObjectGetString(jobj2, "IP address"))) { if (!(tmp = virJSONValueObjectGetString(jobj2, "IP address"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (virSocketAddrParseIPv4(&def->ips[0].address, tmp) < 0) { if (virSocketAddrParseIPv4(&def->ips[0].address, tmp) < 0) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (!(tmp = virJSONValueObjectGetString(jobj2, "Subnet mask"))) { if (!(tmp = virJSONValueObjectGetString(jobj2, "Subnet mask"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (virSocketAddrParseIPv4(&def->ips[0].netmask, tmp) < 0) { if (virSocketAddrParseIPv4(&def->ips[0].netmask, tmp) < 0) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (!(jobj2 = virJSONValueObjectGet(jobj, "DHCPv4 server"))) { if (!(jobj2 = virJSONValueObjectGet(jobj, "DHCPv4 server"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
@ -153,22 +153,22 @@ static int parallelsGetHostOnlyNetInfo(virNetworkDefPtr def, const char *name)
goto cleanup; goto cleanup;
if (!(tmp = virJSONValueObjectGetString(jobj2, "IP scope start address"))) { if (!(tmp = virJSONValueObjectGetString(jobj2, "IP scope start address"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (virSocketAddrParseIPv4(&def->ips[0].ranges[0].start, tmp) < 0) { if (virSocketAddrParseIPv4(&def->ips[0].ranges[0].start, tmp) < 0) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (!(tmp = virJSONValueObjectGetString(jobj2, "IP scope end address"))) { if (!(tmp = virJSONValueObjectGetString(jobj2, "IP scope end address"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (virSocketAddrParseIPv4(&def->ips[0].ranges[0].end, tmp) < 0) { if (virSocketAddrParseIPv4(&def->ips[0].ranges[0].end, tmp) < 0) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
@ -179,7 +179,7 @@ static int parallelsGetHostOnlyNetInfo(virNetworkDefPtr def, const char *name)
} }
static int static int
parallelsLoadNetwork(parallelsConnPtr privconn, virJSONValuePtr jobj) vzLoadNetwork(vzConnPtr privconn, virJSONValuePtr jobj)
{ {
int ret = -1; int ret = -1;
virNetworkObjPtr net = NULL; virNetworkObjPtr net = NULL;
@ -192,7 +192,7 @@ parallelsLoadNetwork(parallelsConnPtr privconn, virJSONValuePtr jobj)
goto cleanup; goto cleanup;
if (!(tmp = virJSONValueObjectGetString(jobj, "Network ID"))) { if (!(tmp = virJSONValueObjectGetString(jobj, "Network ID"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
@ -206,14 +206,14 @@ parallelsLoadNetwork(parallelsConnPtr privconn, virJSONValuePtr jobj)
def->uuid_specified = 1; def->uuid_specified = 1;
if (!(tmp = virJSONValueObjectGetString(jobj, "Type"))) { if (!(tmp = virJSONValueObjectGetString(jobj, "Type"))) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (STREQ(tmp, PARALLELS_BRIDGED_NETWORK_TYPE)) { if (STREQ(tmp, PARALLELS_BRIDGED_NETWORK_TYPE)) {
def->forward.type = VIR_NETWORK_FORWARD_BRIDGE; def->forward.type = VIR_NETWORK_FORWARD_BRIDGE;
if (parallelsGetBridgedNetInfo(def, jobj) < 0) { if (vzGetBridgedNetInfo(def, jobj) < 0) {
/* Only mandatory networks are required to be configured completely */ /* Only mandatory networks are required to be configured completely */
if (STRNEQ(def->name, PARALLELS_REQUIRED_BRIDGED_NETWORK)) if (STRNEQ(def->name, PARALLELS_REQUIRED_BRIDGED_NETWORK))
@ -224,7 +224,7 @@ parallelsLoadNetwork(parallelsConnPtr privconn, virJSONValuePtr jobj)
} else if (STREQ(tmp, PARALLELS_HOSTONLY_NETWORK_TYPE)) { } else if (STREQ(tmp, PARALLELS_HOSTONLY_NETWORK_TYPE)) {
def->forward.type = VIR_NETWORK_FORWARD_NONE; def->forward.type = VIR_NETWORK_FORWARD_NONE;
if (parallelsGetHostOnlyNetInfo(def, def->name) < 0) { if (vzGetHostOnlyNetInfo(def, def->name) < 0) {
/* Only mandatory networks are required to be configured completely */ /* Only mandatory networks are required to be configured completely */
if (STRNEQ(def->name, PARALLELS_REQUIRED_HOSTONLY_NETWORK)) if (STRNEQ(def->name, PARALLELS_REQUIRED_HOSTONLY_NETWORK))
@ -233,7 +233,7 @@ parallelsLoadNetwork(parallelsConnPtr privconn, virJSONValuePtr jobj)
goto cleanup; goto cleanup;
} }
} else { } else {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
@ -251,7 +251,7 @@ parallelsLoadNetwork(parallelsConnPtr privconn, virJSONValuePtr jobj)
} }
static int static int
parallelsAddRoutedNetwork(parallelsConnPtr privconn) vzAddRoutedNetwork(vzConnPtr privconn)
{ {
virNetworkObjPtr net = NULL; virNetworkObjPtr net = NULL;
virNetworkDefPtr def; virNetworkDefPtr def;
@ -285,38 +285,38 @@ parallelsAddRoutedNetwork(parallelsConnPtr privconn)
return -1; return -1;
} }
static int parallelsLoadNetworks(parallelsConnPtr privconn) static int vzLoadNetworks(vzConnPtr privconn)
{ {
virJSONValuePtr jobj, jobj2; virJSONValuePtr jobj, jobj2;
int ret = -1; int ret = -1;
int count; int count;
size_t i; size_t i;
jobj = parallelsParseOutput("prlsrvctl", "net", "list", "-j", NULL); jobj = vzParseOutput("prlsrvctl", "net", "list", "-j", NULL);
if (!jobj) { if (!jobj) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
count = virJSONValueArraySize(jobj); count = virJSONValueArraySize(jobj);
if (count < 0) { if (count < 0) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
jobj2 = virJSONValueArrayGet(jobj, i); jobj2 = virJSONValueArrayGet(jobj, i);
if (!jobj2) { if (!jobj2) {
parallelsParseError(); vzParseError();
goto cleanup; goto cleanup;
} }
if (parallelsLoadNetwork(privconn, jobj2) < 0) if (vzLoadNetwork(privconn, jobj2) < 0)
goto cleanup; goto cleanup;
} }
if (parallelsAddRoutedNetwork(privconn) < 0) if (vzAddRoutedNetwork(privconn) < 0)
goto cleanup; goto cleanup;
ret = 0; ret = 0;
@ -327,10 +327,10 @@ static int parallelsLoadNetworks(parallelsConnPtr privconn)
} }
virDrvOpenStatus virDrvOpenStatus
parallelsNetworkOpen(virConnectPtr conn, vzNetworkOpen(virConnectPtr conn,
unsigned int flags) unsigned int flags)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR); virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
@ -341,7 +341,7 @@ parallelsNetworkOpen(virConnectPtr conn,
if (!(privconn->networks = virNetworkObjListNew())) if (!(privconn->networks = virNetworkObjListNew()))
goto error; goto error;
if (parallelsLoadNetworks(conn->privateData) < 0) if (vzLoadNetworks(conn->privateData) < 0)
goto error; goto error;
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
@ -351,9 +351,9 @@ parallelsNetworkOpen(virConnectPtr conn,
return VIR_DRV_OPEN_ERROR; return VIR_DRV_OPEN_ERROR;
} }
int parallelsNetworkClose(virConnectPtr conn) int vzNetworkClose(virConnectPtr conn)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
if (!privconn) if (!privconn)
return 0; return 0;
@ -362,21 +362,21 @@ int parallelsNetworkClose(virConnectPtr conn)
return 0; return 0;
} }
static int parallelsConnectNumOfNetworks(virConnectPtr conn) static int vzConnectNumOfNetworks(virConnectPtr conn)
{ {
int nactive; int nactive;
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
nactive = virNetworkObjListNumOfNetworks(privconn->networks, nactive = virNetworkObjListNumOfNetworks(privconn->networks,
true, NULL, conn); true, NULL, conn);
return nactive; return nactive;
} }
static int parallelsConnectListNetworks(virConnectPtr conn, static int vzConnectListNetworks(virConnectPtr conn,
char **const names, char **const names,
int nnames) int nnames)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
int got; int got;
got = virNetworkObjListGetNames(privconn->networks, got = virNetworkObjListGetNames(privconn->networks,
@ -384,21 +384,21 @@ static int parallelsConnectListNetworks(virConnectPtr conn,
return got; return got;
} }
static int parallelsConnectNumOfDefinedNetworks(virConnectPtr conn) static int vzConnectNumOfDefinedNetworks(virConnectPtr conn)
{ {
int ninactive; int ninactive;
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
ninactive = virNetworkObjListNumOfNetworks(privconn->networks, ninactive = virNetworkObjListNumOfNetworks(privconn->networks,
false, NULL, conn); false, NULL, conn);
return ninactive; return ninactive;
} }
static int parallelsConnectListDefinedNetworks(virConnectPtr conn, static int vzConnectListDefinedNetworks(virConnectPtr conn,
char **const names, char **const names,
int nnames) int nnames)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
int got; int got;
got = virNetworkObjListGetNames(privconn->networks, got = virNetworkObjListGetNames(privconn->networks,
@ -406,21 +406,21 @@ static int parallelsConnectListDefinedNetworks(virConnectPtr conn,
return got; return got;
} }
static int parallelsConnectListAllNetworks(virConnectPtr conn, static int vzConnectListAllNetworks(virConnectPtr conn,
virNetworkPtr **nets, virNetworkPtr **nets,
unsigned int flags) unsigned int flags)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1); virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1);
return virNetworkObjListExport(conn, privconn->networks, nets, NULL, flags); return virNetworkObjListExport(conn, privconn->networks, nets, NULL, flags);
} }
static virNetworkPtr parallelsNetworkLookupByUUID(virConnectPtr conn, static virNetworkPtr vzNetworkLookupByUUID(virConnectPtr conn,
const unsigned char *uuid) const unsigned char *uuid)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
virNetworkObjPtr network; virNetworkObjPtr network;
virNetworkPtr ret = NULL; virNetworkPtr ret = NULL;
@ -438,10 +438,10 @@ static virNetworkPtr parallelsNetworkLookupByUUID(virConnectPtr conn,
return ret; return ret;
} }
static virNetworkPtr parallelsNetworkLookupByName(virConnectPtr conn, static virNetworkPtr vzNetworkLookupByName(virConnectPtr conn,
const char *name) const char *name)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
virNetworkObjPtr network; virNetworkObjPtr network;
virNetworkPtr ret = NULL; virNetworkPtr ret = NULL;
@ -459,10 +459,10 @@ static virNetworkPtr parallelsNetworkLookupByName(virConnectPtr conn,
return ret; return ret;
} }
static char *parallelsNetworkGetXMLDesc(virNetworkPtr net, static char *vzNetworkGetXMLDesc(virNetworkPtr net,
unsigned int flags) unsigned int flags)
{ {
parallelsConnPtr privconn = net->conn->privateData; vzConnPtr privconn = net->conn->privateData;
virNetworkObjPtr network; virNetworkObjPtr network;
char *ret = NULL; char *ret = NULL;
@ -482,9 +482,9 @@ static char *parallelsNetworkGetXMLDesc(virNetworkPtr net,
return ret; return ret;
} }
static int parallelsNetworkIsActive(virNetworkPtr net) static int vzNetworkIsActive(virNetworkPtr net)
{ {
parallelsConnPtr privconn = net->conn->privateData; vzConnPtr privconn = net->conn->privateData;
virNetworkObjPtr obj; virNetworkObjPtr obj;
int ret = -1; int ret = -1;
@ -500,9 +500,9 @@ static int parallelsNetworkIsActive(virNetworkPtr net)
return ret; return ret;
} }
static int parallelsNetworkIsPersistent(virNetworkPtr net) static int vzNetworkIsPersistent(virNetworkPtr net)
{ {
parallelsConnPtr privconn = net->conn->privateData; vzConnPtr privconn = net->conn->privateData;
virNetworkObjPtr obj; virNetworkObjPtr obj;
int ret = -1; int ret = -1;
@ -518,10 +518,10 @@ static int parallelsNetworkIsPersistent(virNetworkPtr net)
return ret; return ret;
} }
static int parallelsNetworkGetAutostart(virNetworkPtr net, static int vzNetworkGetAutostart(virNetworkPtr net,
int *autostart) int *autostart)
{ {
parallelsConnPtr privconn = net->conn->privateData; vzConnPtr privconn = net->conn->privateData;
virNetworkObjPtr network; virNetworkObjPtr network;
int ret = -1; int ret = -1;
@ -540,17 +540,17 @@ static int parallelsNetworkGetAutostart(virNetworkPtr net,
return ret; return ret;
} }
virNetworkDriver parallelsNetworkDriver = { virNetworkDriver vzNetworkDriver = {
.name = "Parallels", .name = "Parallels",
.connectNumOfNetworks = parallelsConnectNumOfNetworks, /* 1.0.1 */ .connectNumOfNetworks = vzConnectNumOfNetworks, /* 1.0.1 */
.connectListNetworks = parallelsConnectListNetworks, /* 1.0.1 */ .connectListNetworks = vzConnectListNetworks, /* 1.0.1 */
.connectNumOfDefinedNetworks = parallelsConnectNumOfDefinedNetworks, /* 1.0.1 */ .connectNumOfDefinedNetworks = vzConnectNumOfDefinedNetworks, /* 1.0.1 */
.connectListDefinedNetworks = parallelsConnectListDefinedNetworks, /* 1.0.1 */ .connectListDefinedNetworks = vzConnectListDefinedNetworks, /* 1.0.1 */
.connectListAllNetworks = parallelsConnectListAllNetworks, /* 1.0.1 */ .connectListAllNetworks = vzConnectListAllNetworks, /* 1.0.1 */
.networkLookupByUUID = parallelsNetworkLookupByUUID, /* 1.0.1 */ .networkLookupByUUID = vzNetworkLookupByUUID, /* 1.0.1 */
.networkLookupByName = parallelsNetworkLookupByName, /* 1.0.1 */ .networkLookupByName = vzNetworkLookupByName, /* 1.0.1 */
.networkGetXMLDesc = parallelsNetworkGetXMLDesc, /* 1.0.1 */ .networkGetXMLDesc = vzNetworkGetXMLDesc, /* 1.0.1 */
.networkGetAutostart = parallelsNetworkGetAutostart, /* 1.0.1 */ .networkGetAutostart = vzNetworkGetAutostart, /* 1.0.1 */
.networkIsActive = parallelsNetworkIsActive, /* 1.0.1 */ .networkIsActive = vzNetworkIsActive, /* 1.0.1 */
.networkIsPersistent = parallelsNetworkIsPersistent, /* 1.0.1 */ .networkIsPersistent = vzNetworkIsPersistent, /* 1.0.1 */
}; };

78
src/parallels/parallels_sdk.c
View File

@ -226,7 +226,7 @@ prlsdkDeinit(void)
}; };
int int
prlsdkConnect(parallelsConnPtr privconn) prlsdkConnect(vzConnPtr privconn)
{ {
PRL_RESULT ret; PRL_RESULT ret;
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
@ -249,7 +249,7 @@ prlsdkConnect(parallelsConnPtr privconn)
} }
void void
prlsdkDisconnect(parallelsConnPtr privconn) prlsdkDisconnect(vzConnPtr privconn)
{ {
PRL_HANDLE job; PRL_HANDLE job;
@ -260,7 +260,7 @@ prlsdkDisconnect(parallelsConnPtr privconn)
} }
static int static int
prlsdkSdkDomainLookup(parallelsConnPtr privconn, prlsdkSdkDomainLookup(vzConnPtr privconn,
const char *id, const char *id,
unsigned int flags, unsigned int flags,
PRL_HANDLE *sdkdom) PRL_HANDLE *sdkdom)
@ -295,7 +295,7 @@ prlsdkUUIDFormat(const unsigned char *uuid, char *uuidstr)
} }
static PRL_HANDLE static PRL_HANDLE
prlsdkSdkDomainLookupByUUID(parallelsConnPtr privconn, const unsigned char *uuid) prlsdkSdkDomainLookupByUUID(vzConnPtr privconn, const unsigned char *uuid)
{ {
char uuidstr[VIR_UUID_STRING_BUFLEN + 2]; char uuidstr[VIR_UUID_STRING_BUFLEN + 2];
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE; PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
@ -406,7 +406,7 @@ prlsdkGetDomainState(PRL_HANDLE sdkdom, VIRTUAL_MACHINE_STATE_PTR vmState)
static void static void
prlsdkDomObjFreePrivate(void *p) prlsdkDomObjFreePrivate(void *p)
{ {
parallelsDomObjPtr pdom = p; vzDomObjPtr pdom = p;
if (!pdom) if (!pdom)
return; return;
@ -1244,13 +1244,13 @@ prlsdkConvertCpuMode(PRL_HANDLE sdkdom, virDomainDefPtr def)
* The function return a pointer to a locked virDomainObj. * The function return a pointer to a locked virDomainObj.
*/ */
static virDomainObjPtr static virDomainObjPtr
prlsdkLoadDomain(parallelsConnPtr privconn, prlsdkLoadDomain(vzConnPtr privconn,
PRL_HANDLE sdkdom, PRL_HANDLE sdkdom,
virDomainObjPtr olddom) virDomainObjPtr olddom)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
virDomainDefPtr def = NULL; virDomainDefPtr def = NULL;
parallelsDomObjPtr pdom = NULL; vzDomObjPtr pdom = NULL;
VIRTUAL_MACHINE_STATE domainState; VIRTUAL_MACHINE_STATE domainState;
PRL_UINT32 buflen = 0; PRL_UINT32 buflen = 0;
@ -1428,7 +1428,7 @@ prlsdkLoadDomain(parallelsConnPtr privconn,
} }
int int
prlsdkLoadDomains(parallelsConnPtr privconn) prlsdkLoadDomains(vzConnPtr privconn)
{ {
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
PRL_HANDLE result; PRL_HANDLE result;
@ -1472,7 +1472,7 @@ prlsdkLoadDomains(parallelsConnPtr privconn)
} }
virDomainObjPtr virDomainObjPtr
prlsdkAddDomain(parallelsConnPtr privconn, const unsigned char *uuid) prlsdkAddDomain(vzConnPtr privconn, const unsigned char *uuid)
{ {
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE; PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
virDomainObjPtr dom; virDomainObjPtr dom;
@ -1493,11 +1493,11 @@ prlsdkAddDomain(parallelsConnPtr privconn, const unsigned char *uuid)
} }
int int
prlsdkUpdateDomain(parallelsConnPtr privconn, virDomainObjPtr dom) prlsdkUpdateDomain(vzConnPtr privconn, virDomainObjPtr dom)
{ {
PRL_HANDLE job; PRL_HANDLE job;
virDomainObjPtr retdom = NULL; virDomainObjPtr retdom = NULL;
parallelsDomObjPtr pdom = dom->privateData; vzDomObjPtr pdom = dom->privateData;
job = PrlVm_RefreshConfig(pdom->sdkdom); job = PrlVm_RefreshConfig(pdom->sdkdom);
if (waitJob(job)) if (waitJob(job))
@ -1507,7 +1507,7 @@ prlsdkUpdateDomain(parallelsConnPtr privconn, virDomainObjPtr dom)
return retdom ? 0 : -1; return retdom ? 0 : -1;
} }
static int prlsdkSendEvent(parallelsConnPtr privconn, static int prlsdkSendEvent(vzConnPtr privconn,
virDomainObjPtr dom, virDomainObjPtr dom,
virDomainEventType lvEventType, virDomainEventType lvEventType,
int lvEventTypeDetails) int lvEventTypeDetails)
@ -1558,7 +1558,7 @@ prlsdkNewStateToEvent(VIRTUAL_MACHINE_STATE domainState,
} }
static void static void
prlsdkHandleVmStateEvent(parallelsConnPtr privconn, prlsdkHandleVmStateEvent(vzConnPtr privconn,
PRL_HANDLE prlEvent, PRL_HANDLE prlEvent,
unsigned char *uuid) unsigned char *uuid)
{ {
@ -1566,7 +1566,7 @@ prlsdkHandleVmStateEvent(parallelsConnPtr privconn,
PRL_HANDLE eventParam = PRL_INVALID_HANDLE; PRL_HANDLE eventParam = PRL_INVALID_HANDLE;
PRL_INT32 domainState; PRL_INT32 domainState;
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
parallelsDomObjPtr pdom; vzDomObjPtr pdom;
virDomainEventType lvEventType = 0; virDomainEventType lvEventType = 0;
int lvEventTypeDetails = 0; int lvEventTypeDetails = 0;
@ -1596,7 +1596,7 @@ prlsdkHandleVmStateEvent(parallelsConnPtr privconn,
} }
static void static void
prlsdkHandleVmConfigEvent(parallelsConnPtr privconn, prlsdkHandleVmConfigEvent(vzConnPtr privconn,
unsigned char *uuid) unsigned char *uuid)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
@ -1617,7 +1617,7 @@ prlsdkHandleVmConfigEvent(parallelsConnPtr privconn,
} }
static void static void
prlsdkHandleVmAddedEvent(parallelsConnPtr privconn, prlsdkHandleVmAddedEvent(vzConnPtr privconn,
unsigned char *uuid) unsigned char *uuid)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
@ -1634,7 +1634,7 @@ prlsdkHandleVmAddedEvent(parallelsConnPtr privconn,
} }
static void static void
prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn, prlsdkHandleVmRemovedEvent(vzConnPtr privconn,
unsigned char *uuid) unsigned char *uuid)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
@ -1655,12 +1655,12 @@ prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn,
#define PARALLELS_STATISTICS_DROP_COUNT 3 #define PARALLELS_STATISTICS_DROP_COUNT 3
static PRL_RESULT static PRL_RESULT
prlsdkHandlePerfEvent(parallelsConnPtr privconn, prlsdkHandlePerfEvent(vzConnPtr privconn,
PRL_HANDLE event, PRL_HANDLE event,
unsigned char *uuid) unsigned char *uuid)
{ {
virDomainObjPtr dom = NULL; virDomainObjPtr dom = NULL;
parallelsDomObjPtr privdom = NULL; vzDomObjPtr privdom = NULL;
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
dom = virDomainObjListFindByUUID(privconn->domains, uuid); dom = virDomainObjListFindByUUID(privconn->domains, uuid);
@ -1698,7 +1698,7 @@ prlsdkHandlePerfEvent(parallelsConnPtr privconn,
} }
static void static void
prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) prlsdkHandleVmEvent(vzConnPtr privconn, PRL_HANDLE prlEvent)
{ {
PRL_RESULT pret = PRL_ERR_FAILURE; PRL_RESULT pret = PRL_ERR_FAILURE;
char uuidstr[VIR_UUID_STRING_BUFLEN + 2]; char uuidstr[VIR_UUID_STRING_BUFLEN + 2];
@ -1748,7 +1748,7 @@ prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent)
static PRL_RESULT static PRL_RESULT
prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque)
{ {
parallelsConnPtr privconn = opaque; vzConnPtr privconn = opaque;
PRL_RESULT pret = PRL_ERR_FAILURE; PRL_RESULT pret = PRL_ERR_FAILURE;
PRL_HANDLE_TYPE handleType; PRL_HANDLE_TYPE handleType;
PRL_EVENT_ISSUER_TYPE prlIssuerType = PIE_UNKNOWN; PRL_EVENT_ISSUER_TYPE prlIssuerType = PIE_UNKNOWN;
@ -1782,7 +1782,7 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque)
} }
int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn) int prlsdkSubscribeToPCSEvents(vzConnPtr privconn)
{ {
PRL_RESULT pret = PRL_ERR_UNINITIALIZED; PRL_RESULT pret = PRL_ERR_UNINITIALIZED;
@ -1796,7 +1796,7 @@ int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn)
return -1; return -1;
} }
void prlsdkUnsubscribeFromPCSEvents(parallelsConnPtr privconn) void prlsdkUnsubscribeFromPCSEvents(vzConnPtr privconn)
{ {
PRL_RESULT ret = PRL_ERR_UNINITIALIZED; PRL_RESULT ret = PRL_ERR_UNINITIALIZED;
ret = PrlSrv_UnregEventHandler(privconn->server, ret = PrlSrv_UnregEventHandler(privconn->server,
@ -1857,11 +1857,11 @@ PRL_RESULT prlsdkSuspend(PRL_HANDLE sdkdom)
} }
int int
prlsdkDomainChangeStateLocked(parallelsConnPtr privconn, prlsdkDomainChangeStateLocked(vzConnPtr privconn,
virDomainObjPtr dom, virDomainObjPtr dom,
prlsdkChangeStateFunc chstate) prlsdkChangeStateFunc chstate)
{ {
parallelsDomObjPtr pdom; vzDomObjPtr pdom;
PRL_RESULT pret; PRL_RESULT pret;
virErrorNumber virerr; virErrorNumber virerr;
@ -1890,11 +1890,11 @@ int
prlsdkDomainChangeState(virDomainPtr domain, prlsdkDomainChangeState(virDomainPtr domain,
prlsdkChangeStateFunc chstate) prlsdkChangeStateFunc chstate)
{ {
parallelsConnPtr privconn = domain->conn->privateData; vzConnPtr privconn = domain->conn->privateData;
virDomainObjPtr dom; virDomainObjPtr dom;
int ret = -1; int ret = -1;
if (!(dom = parallelsDomObjFromDomain(domain))) if (!(dom = vzDomObjFromDomain(domain)))
return -1; return -1;
ret = prlsdkDomainChangeStateLocked(privconn, dom, chstate); ret = prlsdkDomainChangeStateLocked(privconn, dom, chstate);
@ -2007,7 +2007,7 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDefPtr def)
return -1; return -1;
} }
/* we fill only type and arch fields in parallelsLoadDomain for /* we fill only type and arch fields in vzLoadDomain for
* hvm type and also init for containers, so we can check that all * hvm type and also init for containers, so we can check that all
* other paramenters are null and boot devices config is default */ * other paramenters are null and boot devices config is default */
@ -2781,7 +2781,7 @@ static const char * prlsdkFormatMac(virMacAddrPtr mac, char *macstr)
} }
static int prlsdkAddNet(PRL_HANDLE sdkdom, static int prlsdkAddNet(PRL_HANDLE sdkdom,
parallelsConnPtr privconn, vzConnPtr privconn,
virDomainNetDefPtr net, virDomainNetDefPtr net,
bool isCt) bool isCt)
{ {
@ -2885,7 +2885,7 @@ static int prlsdkAddNet(PRL_HANDLE sdkdom,
return ret; return ret;
} }
static void prlsdkDelNet(parallelsConnPtr privconn, virDomainNetDefPtr net) static void prlsdkDelNet(vzConnPtr privconn, virDomainNetDefPtr net)
{ {
PRL_RESULT pret; PRL_RESULT pret;
PRL_HANDLE vnet = PRL_INVALID_HANDLE; PRL_HANDLE vnet = PRL_INVALID_HANDLE;
@ -3111,7 +3111,7 @@ int
prlsdkAttachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk) prlsdkAttachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk)
{ {
int ret = -1; int ret = -1;
parallelsDomObjPtr privdom = dom->privateData; vzDomObjPtr privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
job = PrlVm_BeginEdit(privdom->sdkdom); job = PrlVm_BeginEdit(privdom->sdkdom);
@ -3181,7 +3181,7 @@ int
prlsdkDetachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk) prlsdkDetachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk)
{ {
int ret = -1, idx; int ret = -1, idx;
parallelsDomObjPtr privdom = dom->privateData; vzDomObjPtr privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
idx = prlsdkGetDiskIndex(privdom->sdkdom, disk); idx = prlsdkGetDiskIndex(privdom->sdkdom, disk);
@ -3368,7 +3368,7 @@ prlsdkApplyConfig(virConnectPtr conn,
virDomainObjPtr dom, virDomainObjPtr dom,
virDomainDefPtr new) virDomainDefPtr new)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE; PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
int ret; int ret;
@ -3397,7 +3397,7 @@ prlsdkApplyConfig(virConnectPtr conn,
int int
prlsdkCreateVm(virConnectPtr conn, virDomainDefPtr def) prlsdkCreateVm(virConnectPtr conn, virDomainDefPtr def)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE; PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
PRL_HANDLE result = PRL_INVALID_HANDLE; PRL_HANDLE result = PRL_INVALID_HANDLE;
@ -3437,7 +3437,7 @@ prlsdkCreateVm(virConnectPtr conn, virDomainDefPtr def)
int int
prlsdkCreateCt(virConnectPtr conn, virDomainDefPtr def) prlsdkCreateCt(virConnectPtr conn, virDomainDefPtr def)
{ {
parallelsConnPtr privconn = conn->privateData; vzConnPtr privconn = conn->privateData;
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE; PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
PRL_GET_VM_CONFIG_PARAM_DATA confParam; PRL_GET_VM_CONFIG_PARAM_DATA confParam;
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
@ -3498,9 +3498,9 @@ prlsdkCreateCt(virConnectPtr conn, virDomainDefPtr def)
} }
int int
prlsdkUnregisterDomain(parallelsConnPtr privconn, virDomainObjPtr dom) prlsdkUnregisterDomain(vzConnPtr privconn, virDomainObjPtr dom)
{ {
parallelsDomObjPtr privdom = dom->privateData; vzDomObjPtr privdom = dom->privateData;
PRL_HANDLE job; PRL_HANDLE job;
size_t i; size_t i;
@ -3522,7 +3522,7 @@ prlsdkUnregisterDomain(parallelsConnPtr privconn, virDomainObjPtr dom)
int int
prlsdkDomainManagedSaveRemove(virDomainObjPtr dom) prlsdkDomainManagedSaveRemove(virDomainObjPtr dom)
{ {
parallelsDomObjPtr privdom = dom->privateData; vzDomObjPtr privdom = dom->privateData;
PRL_HANDLE job; PRL_HANDLE job;
job = PrlVm_DropSuspendedState(privdom->sdkdom); job = PrlVm_DropSuspendedState(privdom->sdkdom);
@ -3565,7 +3565,7 @@ prlsdkExtractStatsParam(PRL_HANDLE sdkstats, const char *name, long long *val)
static int static int
prlsdkGetStatsParam(virDomainObjPtr dom, const char *name, long long *val) prlsdkGetStatsParam(virDomainObjPtr dom, const char *name, long long *val)
{ {
parallelsDomObjPtr privdom = dom->privateData; vzDomObjPtr privdom = dom->privateData;
PRL_HANDLE job = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE;
unsigned long long now; unsigned long long now;

18
src/parallels/parallels_sdk.h
View File

@ -26,15 +26,15 @@
int prlsdkInit(void); int prlsdkInit(void);
void prlsdkDeinit(void); void prlsdkDeinit(void);
int prlsdkConnect(parallelsConnPtr privconn); int prlsdkConnect(vzConnPtr privconn);
void prlsdkDisconnect(parallelsConnPtr privconn); void prlsdkDisconnect(vzConnPtr privconn);
int int
prlsdkLoadDomains(parallelsConnPtr privconn); prlsdkLoadDomains(vzConnPtr privconn);
virDomainObjPtr virDomainObjPtr
prlsdkAddDomain(parallelsConnPtr privconn, const unsigned char *uuid); prlsdkAddDomain(vzConnPtr privconn, const unsigned char *uuid);
int prlsdkUpdateDomain(parallelsConnPtr privconn, virDomainObjPtr dom); int prlsdkUpdateDomain(vzConnPtr privconn, virDomainObjPtr dom);
int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn); int prlsdkSubscribeToPCSEvents(vzConnPtr privconn);
void prlsdkUnsubscribeFromPCSEvents(parallelsConnPtr privconn); void prlsdkUnsubscribeFromPCSEvents(vzConnPtr privconn);
PRL_RESULT prlsdkStart(PRL_HANDLE sdkdom); PRL_RESULT prlsdkStart(PRL_HANDLE sdkdom);
PRL_RESULT prlsdkKill(PRL_HANDLE sdkdom); PRL_RESULT prlsdkKill(PRL_HANDLE sdkdom);
PRL_RESULT prlsdkStop(PRL_HANDLE sdkdom); PRL_RESULT prlsdkStop(PRL_HANDLE sdkdom);
@ -47,7 +47,7 @@ int
prlsdkDomainChangeState(virDomainPtr domain, prlsdkDomainChangeState(virDomainPtr domain,
prlsdkChangeStateFunc chstate); prlsdkChangeStateFunc chstate);
int int
prlsdkDomainChangeStateLocked(parallelsConnPtr privconn, prlsdkDomainChangeStateLocked(vzConnPtr privconn,
virDomainObjPtr dom, virDomainObjPtr dom,
prlsdkChangeStateFunc chstate); prlsdkChangeStateFunc chstate);
int int
@ -57,7 +57,7 @@ prlsdkApplyConfig(virConnectPtr conn,
int prlsdkCreateVm(virConnectPtr conn, virDomainDefPtr def); int prlsdkCreateVm(virConnectPtr conn, virDomainDefPtr def);
int prlsdkCreateCt(virConnectPtr conn, virDomainDefPtr def); int prlsdkCreateCt(virConnectPtr conn, virDomainDefPtr def);
int int
prlsdkUnregisterDomain(parallelsConnPtr privconn, virDomainObjPtr dom); prlsdkUnregisterDomain(vzConnPtr privconn, virDomainObjPtr dom);
int int
prlsdkDomainManagedSaveRemove(virDomainObjPtr dom); prlsdkDomainManagedSaveRemove(virDomainObjPtr dom);
int int

434
src/parallels/parallels_storage.c
View File

File diff suppressed because it is too large Load Diff

28
src/parallels/parallels_utils.c
View File

@ -35,7 +35,7 @@
#define VIR_FROM_THIS VIR_FROM_PARALLELS #define VIR_FROM_THIS VIR_FROM_PARALLELS
/** /**
* parallelsDomObjFromDomain: * vzDomObjFromDomain:
* @domain: Domain pointer that has to be looked up * @domain: Domain pointer that has to be looked up
* *
* This function looks up @domain and returns the appropriate virDomainObjPtr * This function looks up @domain and returns the appropriate virDomainObjPtr
@ -45,10 +45,10 @@
* on success, NULL otherwise. * on success, NULL otherwise.
*/ */
virDomainObjPtr virDomainObjPtr
parallelsDomObjFromDomain(virDomainPtr domain) vzDomObjFromDomain(virDomainPtr domain)
{ {
virDomainObjPtr vm; virDomainObjPtr vm;
parallelsConnPtr privconn = domain->conn->privateData; vzConnPtr privconn = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN]; char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUID(privconn->domains, domain->uuid); vm = virDomainObjListFindByUUID(privconn->domains, domain->uuid);
@ -65,7 +65,7 @@ parallelsDomObjFromDomain(virDomainPtr domain)
} }
/** /**
* parallelsDomObjFromDomainRef: * vzDomObjFromDomainRef:
* @domain: Domain pointer that has to be looked up * @domain: Domain pointer that has to be looked up
* *
* This function looks up @domain and returns the appropriate virDomainObjPtr * This function looks up @domain and returns the appropriate virDomainObjPtr
@ -75,10 +75,10 @@ parallelsDomObjFromDomain(virDomainPtr domain)
* on success, NULL otherwise. * on success, NULL otherwise.
*/ */
virDomainObjPtr virDomainObjPtr
parallelsDomObjFromDomainRef(virDomainPtr domain) vzDomObjFromDomainRef(virDomainPtr domain)
{ {
virDomainObjPtr vm; virDomainObjPtr vm;
parallelsConnPtr privconn = domain->conn->privateData; vzConnPtr privconn = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN]; char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUIDRef(privconn->domains, domain->uuid); vm = virDomainObjListFindByUUIDRef(privconn->domains, domain->uuid);
@ -94,7 +94,7 @@ parallelsDomObjFromDomainRef(virDomainPtr domain)
} }
static int static int
parallelsDoCmdRun(char **outbuf, const char *binary, va_list list) vzDoCmdRun(char **outbuf, const char *binary, va_list list)
{ {
virCommandPtr cmd = virCommandNewVAList(binary, list); virCommandPtr cmd = virCommandNewVAList(binary, list);
int ret = -1; int ret = -1;
@ -119,7 +119,7 @@ parallelsDoCmdRun(char **outbuf, const char *binary, va_list list)
* pointer to virJSONValue or NULL in case of error. * pointer to virJSONValue or NULL in case of error.
*/ */
virJSONValuePtr virJSONValuePtr
parallelsParseOutput(const char *binary, ...) vzParseOutput(const char *binary, ...)
{ {
char *outbuf; char *outbuf;
virJSONValuePtr jobj = NULL; virJSONValuePtr jobj = NULL;
@ -127,7 +127,7 @@ parallelsParseOutput(const char *binary, ...)
int ret; int ret;
va_start(list, binary); va_start(list, binary);
ret = parallelsDoCmdRun(&outbuf, binary, list); ret = vzDoCmdRun(&outbuf, binary, list);
va_end(list); va_end(list);
if (ret) if (ret)
return NULL; return NULL;
@ -147,14 +147,14 @@ parallelsParseOutput(const char *binary, ...)
* for freeing the buffer. * for freeing the buffer.
*/ */
char * char *
parallelsGetOutput(const char *binary, ...) vzGetOutput(const char *binary, ...)
{ {
char *outbuf; char *outbuf;
va_list list; va_list list;
int ret; int ret;
va_start(list, binary); va_start(list, binary);
ret = parallelsDoCmdRun(&outbuf, binary, list); ret = vzDoCmdRun(&outbuf, binary, list);
va_end(list); va_end(list);
if (ret) if (ret)
return NULL; return NULL;
@ -168,13 +168,13 @@ parallelsGetOutput(const char *binary, ...)
* Return value is 0 in case of success, else - -1 * Return value is 0 in case of success, else - -1
*/ */
int int
parallelsCmdRun(const char *binary, ...) vzCmdRun(const char *binary, ...)
{ {
int ret; int ret;
va_list list; va_list list;
va_start(list, binary); va_start(list, binary);
ret = parallelsDoCmdRun(NULL, binary, list); ret = vzDoCmdRun(NULL, binary, list);
va_end(list); va_end(list);
return ret; return ret;
@ -185,7 +185,7 @@ parallelsCmdRun(const char *binary, ...)
* concatenating first and second function arguments. * concatenating first and second function arguments.
*/ */
char * char *
parallelsAddFileExt(const char *path, const char *ext) vzAddFileExt(const char *path, const char *ext)
{ {
char *new_path = NULL; char *new_path = NULL;
size_t len = strlen(path) + strlen(ext) + 1; size_t len = strlen(path) + strlen(ext) + 1;

52
src/parallels/parallels_utils.h
View File

@ -33,13 +33,13 @@
# include "virthread.h" # include "virthread.h"
# include "virjson.h" # include "virjson.h"
# define parallelsParseError() \ # define vzParseError() \
virReportErrorHelper(VIR_FROM_TEST, VIR_ERR_OPERATION_FAILED, __FILE__, \ virReportErrorHelper(VIR_FROM_TEST, VIR_ERR_OPERATION_FAILED, __FILE__, \
__FUNCTION__, __LINE__, _("Can't parse prlctl output")) __FUNCTION__, __LINE__, _("Can't parse prlctl output"))
# define IS_CT(def) (def->os.type == VIR_DOMAIN_OSTYPE_EXE) # define IS_CT(def) (def->os.type == VIR_DOMAIN_OSTYPE_EXE)
# define parallelsDomNotFoundError(domain) \ # define vzDomNotFoundError(domain) \
do { \ do { \
char uuidstr[VIR_UUID_STRING_BUFLEN]; \ char uuidstr[VIR_UUID_STRING_BUFLEN]; \
virUUIDFormat(domain->uuid, uuidstr); \ virUUIDFormat(domain->uuid, uuidstr); \
@ -55,7 +55,7 @@
# define PARALLELS_REQUIRED_BRIDGED_NETWORK "Bridged" # define PARALLELS_REQUIRED_BRIDGED_NETWORK "Bridged"
# define PARALLELS_BRIDGED_NETWORK_TYPE "bridged" # define PARALLELS_BRIDGED_NETWORK_TYPE "bridged"
struct _parallelsConn { struct _vzConn {
virMutex lock; virMutex lock;
/* Immutable pointer, self-locking APIs */ /* Immutable pointer, self-locking APIs */
@ -71,10 +71,10 @@ struct _parallelsConn {
const char *drivername; const char *drivername;
}; };
typedef struct _parallelsConn parallelsConn; typedef struct _vzConn vzConn;
typedef struct _parallelsConn *parallelsConnPtr; typedef struct _vzConn *vzConnPtr;
struct _parallelsCountersCache { struct _vzCountersCache {
PRL_HANDLE stats; PRL_HANDLE stats;
virCond cond; virCond cond;
// -1 - unsubscribed // -1 - unsubscribed
@ -82,41 +82,41 @@ struct _parallelsCountersCache {
int count; int count;
}; };
typedef struct _parallelsCountersCache parallelsCountersCache; typedef struct _vzCountersCache vzCountersCache;
struct parallelsDomObj { struct vzDomObj {
int id; int id;
char *uuid; char *uuid;
char *home; char *home;
PRL_HANDLE sdkdom; PRL_HANDLE sdkdom;
parallelsCountersCache cache; vzCountersCache cache;
}; };
typedef struct parallelsDomObj *parallelsDomObjPtr; typedef struct vzDomObj *vzDomObjPtr;
virDrvOpenStatus parallelsStorageOpen(virConnectPtr conn, unsigned int flags); virDrvOpenStatus vzStorageOpen(virConnectPtr conn, unsigned int flags);
int parallelsStorageClose(virConnectPtr conn); int vzStorageClose(virConnectPtr conn);
extern virStorageDriver parallelsStorageDriver; extern virStorageDriver vzStorageDriver;
virDrvOpenStatus parallelsNetworkOpen(virConnectPtr conn, unsigned int flags); virDrvOpenStatus vzNetworkOpen(virConnectPtr conn, unsigned int flags);
int parallelsNetworkClose(virConnectPtr conn); int vzNetworkClose(virConnectPtr conn);
extern virNetworkDriver parallelsNetworkDriver; extern virNetworkDriver vzNetworkDriver;
virDomainObjPtr parallelsDomObjFromDomain(virDomainPtr domain); virDomainObjPtr vzDomObjFromDomain(virDomainPtr domain);
virDomainObjPtr parallelsDomObjFromDomainRef(virDomainPtr domain); virDomainObjPtr vzDomObjFromDomainRef(virDomainPtr domain);
virJSONValuePtr parallelsParseOutput(const char *binary, ...) virJSONValuePtr vzParseOutput(const char *binary, ...)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL; ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL;
char * parallelsGetOutput(const char *binary, ...) char * vzGetOutput(const char *binary, ...)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL; ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL;
int parallelsCmdRun(const char *binary, ...) int vzCmdRun(const char *binary, ...)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL; ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL;
char * parallelsAddFileExt(const char *path, const char *ext); char * vzAddFileExt(const char *path, const char *ext);
void parallelsDriverLock(parallelsConnPtr driver); void vzDriverLock(vzConnPtr driver);
void parallelsDriverUnlock(parallelsConnPtr driver); void vzDriverUnlock(vzConnPtr driver);
virStorageVolPtr parallelsStorageVolLookupByPathLocked(virConnectPtr conn, virStorageVolPtr vzStorageVolLookupByPathLocked(virConnectPtr conn,
const char *path); const char *path);
int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool, int vzStorageVolDefRemove(virStoragePoolObjPtr privpool,
virStorageVolDefPtr privvol); virStorageVolDefPtr privvol);
# define PARALLELS_BLOCK_STATS_FOREACH(OP) \ # define PARALLELS_BLOCK_STATS_FOREACH(OP) \