openkylin
/
libvirt
mirror of https://gitee.com/openkylin/libvirt.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

parallels: change parallels prefixes to vz 

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;
# endif
# ifdef WITH_PARALLELS
if (parallelsRegister() == -1)
if (vzRegister() == -1)
goto error;
# endif
#endif

378
src/parallels/parallels_driver.c
View File

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

2
src/parallels/parallels_driver.h
View File

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

138
src/parallels/parallels_network.c
View File

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

78
src/parallels/parallels_sdk.c
View File

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

18
src/parallels/parallels_sdk.h
View File

@ -26,15 +26,15 @@
int prlsdkInit(void);
void prlsdkDeinit(void);
int prlsdkConnect(parallelsConnPtr privconn);
void prlsdkDisconnect(parallelsConnPtr privconn);
int prlsdkConnect(vzConnPtr privconn);
void prlsdkDisconnect(vzConnPtr privconn);
int
prlsdkLoadDomains(parallelsConnPtr privconn);
prlsdkLoadDomains(vzConnPtr privconn);
virDomainObjPtr
prlsdkAddDomain(parallelsConnPtr privconn, const unsigned char *uuid);
int prlsdkUpdateDomain(parallelsConnPtr privconn, virDomainObjPtr dom);
int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn);
void prlsdkUnsubscribeFromPCSEvents(parallelsConnPtr privconn);
prlsdkAddDomain(vzConnPtr privconn, const unsigned char *uuid);
int prlsdkUpdateDomain(vzConnPtr privconn, virDomainObjPtr dom);
int prlsdkSubscribeToPCSEvents(vzConnPtr privconn);
void prlsdkUnsubscribeFromPCSEvents(vzConnPtr privconn);
PRL_RESULT prlsdkStart(PRL_HANDLE sdkdom);
PRL_RESULT prlsdkKill(PRL_HANDLE sdkdom);
PRL_RESULT prlsdkStop(PRL_HANDLE sdkdom);
@ -47,7 +47,7 @@ int
prlsdkDomainChangeState(virDomainPtr domain,
prlsdkChangeStateFunc chstate);
int
prlsdkDomainChangeStateLocked(parallelsConnPtr privconn,
prlsdkDomainChangeStateLocked(vzConnPtr privconn,
virDomainObjPtr dom,
prlsdkChangeStateFunc chstate);
int
@ -57,7 +57,7 @@ prlsdkApplyConfig(virConnectPtr conn,
int prlsdkCreateVm(virConnectPtr conn, virDomainDefPtr def);
int prlsdkCreateCt(virConnectPtr conn, virDomainDefPtr def);
int
prlsdkUnregisterDomain(parallelsConnPtr privconn, virDomainObjPtr dom);
prlsdkUnregisterDomain(vzConnPtr privconn, virDomainObjPtr dom);
int
prlsdkDomainManagedSaveRemove(virDomainObjPtr dom);
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
/**
* parallelsDomObjFromDomain:
* vzDomObjFromDomain:
* @domain: Domain pointer that has to be looked up
*
* This function looks up @domain and returns the appropriate virDomainObjPtr
@ -45,10 +45,10 @@
* on success, NULL otherwise.
*/
virDomainObjPtr
parallelsDomObjFromDomain(virDomainPtr domain)
vzDomObjFromDomain(virDomainPtr domain)
{
virDomainObjPtr vm;
parallelsConnPtr privconn = domain->conn->privateData;
vzConnPtr privconn = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUID(privconn->domains, domain->uuid);
@ -65,7 +65,7 @@ parallelsDomObjFromDomain(virDomainPtr domain)
}
/**
* parallelsDomObjFromDomainRef:
* vzDomObjFromDomainRef:
* @domain: Domain pointer that has to be looked up
*
* This function looks up @domain and returns the appropriate virDomainObjPtr
@ -75,10 +75,10 @@ parallelsDomObjFromDomain(virDomainPtr domain)
* on success, NULL otherwise.
*/
virDomainObjPtr
parallelsDomObjFromDomainRef(virDomainPtr domain)
vzDomObjFromDomainRef(virDomainPtr domain)
{
virDomainObjPtr vm;
parallelsConnPtr privconn = domain->conn->privateData;
vzConnPtr privconn = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
vm = virDomainObjListFindByUUIDRef(privconn->domains, domain->uuid);
@ -94,7 +94,7 @@ parallelsDomObjFromDomainRef(virDomainPtr domain)
}
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);
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.
*/
virJSONValuePtr
parallelsParseOutput(const char *binary, ...)
vzParseOutput(const char *binary, ...)
{
char *outbuf;
virJSONValuePtr jobj = NULL;
@ -127,7 +127,7 @@ parallelsParseOutput(const char *binary, ...)
int ret;
va_start(list, binary);
ret = parallelsDoCmdRun(&outbuf, binary, list);
ret = vzDoCmdRun(&outbuf, binary, list);
va_end(list);
if (ret)
return NULL;
@ -147,14 +147,14 @@ parallelsParseOutput(const char *binary, ...)
* for freeing the buffer.
*/
char *
parallelsGetOutput(const char *binary, ...)
vzGetOutput(const char *binary, ...)
{
char *outbuf;
va_list list;
int ret;
va_start(list, binary);
ret = parallelsDoCmdRun(&outbuf, binary, list);
ret = vzDoCmdRun(&outbuf, binary, list);
va_end(list);
if (ret)
return NULL;
@ -168,13 +168,13 @@ parallelsGetOutput(const char *binary, ...)
* Return value is 0 in case of success, else - -1
*/
int
parallelsCmdRun(const char *binary, ...)
vzCmdRun(const char *binary, ...)
{
int ret;
va_list list;
va_start(list, binary);
ret = parallelsDoCmdRun(NULL, binary, list);
ret = vzDoCmdRun(NULL, binary, list);
va_end(list);
return ret;
@ -185,7 +185,7 @@ parallelsCmdRun(const char *binary, ...)
* concatenating first and second function arguments.
*/
char *
parallelsAddFileExt(const char *path, const char *ext)
vzAddFileExt(const char *path, const char *ext)
{
char *new_path = NULL;
size_t len = strlen(path) + strlen(ext) + 1;

52
src/parallels/parallels_utils.h
View File

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