This patch changes all parallels/vz driver structure and
function prefixes from parallels to vz.
No functional changes.
Signed-off-by: Maxim Nestratov <mnestra...@parallels.com>
---
src/libvirt.c | 2 +-
src/parallels/parallels_driver.c | 378 ++++++++++++++++-----------------
src/parallels/parallels_driver.h | 2 +-
src/parallels/parallels_network.c | 138 ++++++------
src/parallels/parallels_sdk.c | 78 +++----
src/parallels/parallels_sdk.h | 18 +-
src/parallels/parallels_storage.c | 436 +++++++++++++++++++-------------------
src/parallels/parallels_utils.c | 28 +--
src/parallels/parallels_utils.h | 52 ++---
9 files changed, 566 insertions(+), 566 deletions(-)
diff --git a/src/libvirt.c b/src/libvirt.c
index fe62faa..f1e8d3f 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -434,7 +434,7 @@ virGlobalInit(void)
goto error;
# endif
# ifdef WITH_PARALLELS
- if (parallelsRegister() == -1)
+ if (vzRegister() == -1)
goto error;
# endif
#endif
diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c
index 706229d..5a18b06 100644
--- a/src/parallels/parallels_driver.c
+++ b/src/parallels/parallels_driver.c
@@ -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(¶llelsDomainDefParserConfig,
+ 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.2.17 */
- .domainBlockStatsFlags = parallelsDomainBlockStatsFlags, /* 1.2.17 */
+ .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.2.17 */
+ .domainBlockStatsFlags = vzDomainBlockStatsFlags, /* 1.2.17 */
};
static virConnectDriver vzConnectDriver = {
.hypervisorDriver = &vzDriver,
- .storageDriver = ¶llelsStorageDriver,
- .networkDriver = ¶llelsNetworkDriver,
+ .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;
diff --git a/src/parallels/parallels_driver.h b/src/parallels/parallels_driver.h
index babe5c0..173764b 100644
--- a/src/parallels/parallels_driver.h
+++ b/src/parallels/parallels_driver.h
@@ -23,6 +23,6 @@
#ifndef PARALLELS_DRIVER_H
# define PARALLELS_DRIVER_H
-int parallelsRegister(void);
+int vzRegister(void);
#endif
diff --git a/src/parallels/parallels_network.c
b/src/parallels/parallels_network.c
index 895c706..6e18707 100644
--- a/src/parallels/parallels_network.c
+++ b/src/parallels/parallels_network.c
@@ -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 */
};
diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c
index 104c905..53a4376 100644
--- a/src/parallels/parallels_sdk.c
+++ b/src/parallels/parallels_sdk.c
@@ -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;
diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h
index afa6745..5de6473 100644
--- a/src/parallels/parallels_sdk.h
+++ b/src/parallels/parallels_sdk.h
@@ -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
diff --git a/src/parallels/parallels_storage.c
b/src/parallels/parallels_storage.c
index ff3d0fa..b0dac50 100644
--- a/src/parallels/parallels_storage.c
+++ b/src/parallels/parallels_storage.c
@@ -42,35 +42,35 @@
#define VIR_FROM_THIS VIR_FROM_PARALLELS
-#define parallelsPoolNotFoundError(pool_name) \
+#define vzPoolNotFoundError(pool_name) \
virReportError(VIR_ERR_INVALID_ARG, \
_("pool '%s' not found"), pool_name);
static virStorageVolDefPtr
-parallelsStorageVolDefineXML(virStoragePoolObjPtr pool, const char *xmldesc,
+vzStorageVolDefineXML(virStoragePoolObjPtr pool, const char *xmldesc,
const char *xmlfile, bool is_new);
static virStorageVolPtr
-parallelsStorageVolLookupByPath(virConnectPtr conn, const char *path);
+vzStorageVolLookupByPath(virConnectPtr conn, const char *path);
static int
-parallelsStoragePoolGetAlloc(virStoragePoolDefPtr def);
+vzStoragePoolGetAlloc(virStoragePoolDefPtr def);
static void
-parallelsStorageLock(virStorageDriverStatePtr driver)
+vzStorageLock(virStorageDriverStatePtr driver)
{
virMutexLock(&driver->lock);
}
static void
-parallelsStorageUnlock(virStorageDriverStatePtr driver)
+vzStorageUnlock(virStorageDriverStatePtr driver)
{
virMutexUnlock(&driver->lock);
}
int
-parallelsStorageClose(virConnectPtr conn)
+vzStorageClose(virConnectPtr conn)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
if (!privconn)
return 0;
@@ -81,11 +81,11 @@ parallelsStorageClose(virConnectPtr conn)
if (!storageState)
return 0;
- parallelsStorageLock(storageState);
+ vzStorageLock(storageState);
virStoragePoolObjListFree(&privconn->pools);
VIR_FREE(storageState->configDir);
VIR_FREE(storageState->autostartDir);
- parallelsStorageUnlock(storageState);
+ vzStorageUnlock(storageState);
virMutexDestroy(&storageState->lock);
VIR_FREE(storageState);
@@ -93,7 +93,7 @@ parallelsStorageClose(virConnectPtr conn)
}
static int
-parallelsFindVolumes(virStoragePoolObjPtr pool)
+vzFindVolumes(virStoragePoolObjPtr pool)
{
DIR *dir;
struct dirent *ent;
@@ -115,7 +115,7 @@ parallelsFindVolumes(virStoragePoolObjPtr pool)
if (!(path = virFileBuildPath(pool->def->target.path,
ent->d_name, NULL)))
goto cleanup;
- if (!parallelsStorageVolDefineXML(pool, NULL, path, false))
+ if (!vzStorageVolDefineXML(pool, NULL, path, false))
goto cleanup;
VIR_FREE(path);
@@ -134,9 +134,9 @@ parallelsFindVolumes(virStoragePoolObjPtr pool)
/*
* Generate unique pool name by path
*/
-static char *parallelsMakePoolName(virConnectPtr conn, const char *path)
+static char *vzMakePoolName(virConnectPtr conn, const char *path)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
char *name;
size_t i;
@@ -169,9 +169,9 @@ static char *parallelsMakePoolName(virConnectPtr conn,
const char *path)
}
static virStoragePoolObjPtr
-parallelsPoolCreateByPath(virConnectPtr conn, const char *path)
+vzPoolCreateByPath(virConnectPtr conn, const char *path)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
virStoragePoolObjListPtr pools = &privconn->pools;
virStoragePoolDefPtr def;
virStoragePoolObjPtr pool = NULL;
@@ -179,7 +179,7 @@ parallelsPoolCreateByPath(virConnectPtr conn, const char
*path)
if (VIR_ALLOC(def) < 0)
goto error;
- if (!(def->name = parallelsMakePoolName(conn, path)))
+ if (!(def->name = vzMakePoolName(conn, path)))
goto error;
if (virUUIDGenerate(def->uuid)) {
@@ -215,10 +215,10 @@ parallelsPoolCreateByPath(virConnectPtr conn, const char
*path)
* path to the VM, if it does not exist.
*/
static virStoragePoolObjPtr
-parallelsPoolAddByDomain(virConnectPtr conn, virDomainObjPtr dom)
+vzPoolAddByDomain(virConnectPtr conn, virDomainObjPtr dom)
{
- parallelsConnPtr privconn = conn->privateData;
- parallelsDomObjPtr pdom = dom->privateData;
+ vzConnPtr privconn = conn->privateData;
+ vzDomObjPtr pdom = dom->privateData;
virStoragePoolObjListPtr pools = &privconn->pools;
char *poolPath;
virStoragePoolObjPtr pool = NULL;
@@ -238,13 +238,13 @@ parallelsPoolAddByDomain(virConnectPtr conn,
virDomainObjPtr dom)
}
if (!pool)
- pool = parallelsPoolCreateByPath(conn, poolPath);
+ pool = vzPoolCreateByPath(conn, poolPath);
VIR_FREE(poolPath);
return pool;
}
-static int parallelsDiskDescParseNode(xmlDocPtr xml,
+static int vzDiskDescParseNode(xmlDocPtr xml,
xmlNodePtr root,
virStorageVolDefPtr def)
{
@@ -282,7 +282,7 @@ static int parallelsDiskDescParseNode(xmlDocPtr xml,
}
-static int parallelsDiskDescParse(const char *path, virStorageVolDefPtr def)
+static int vzDiskDescParse(const char *path, virStorageVolDefPtr def)
{
xmlDocPtr xml;
int ret = -1;
@@ -290,12 +290,12 @@ static int parallelsDiskDescParse(const char *path,
virStorageVolDefPtr def)
if (!(xml = virXMLParse(path, NULL, NULL)))
return -1;
- ret = parallelsDiskDescParseNode(xml, xmlDocGetRootElement(xml), def);
+ ret = vzDiskDescParseNode(xml, xmlDocGetRootElement(xml), def);
xmlFreeDoc(xml);
return ret;
}
-static int parallelsAddDiskVolume(virStoragePoolObjPtr pool,
+static int vzAddDiskVolume(virStoragePoolObjPtr pool,
virDomainObjPtr dom,
const char *diskName,
const char *diskPath,
@@ -311,7 +311,7 @@ static int parallelsAddDiskVolume(virStoragePoolObjPtr pool,
def->type = VIR_STORAGE_VOL_FILE;
- if (parallelsDiskDescParse(diskDescPath, def) < 0)
+ if (vzDiskDescParse(diskDescPath, def) < 0)
goto error;
if (!(def->target.path = realpath(diskPath, NULL)))
@@ -331,10 +331,10 @@ static int parallelsAddDiskVolume(virStoragePoolObjPtr
pool,
return -1;
}
-static int parallelsFindVmVolumes(virStoragePoolObjPtr pool,
+static int vzFindVmVolumes(virStoragePoolObjPtr pool,
virDomainObjPtr dom)
{
- parallelsDomObjPtr pdom = dom->privateData;
+ vzDomObjPtr pdom = dom->privateData;
DIR *dir;
struct dirent *ent;
char *diskPath = NULL, *diskDescPath = NULL;
@@ -375,7 +375,7 @@ static int parallelsFindVmVolumes(virStoragePoolObjPtr pool,
/* here we know, that ent->d_name is a disk image directory */
- if (parallelsAddDiskVolume(pool, dom, ent->d_name,
+ if (vzAddDiskVolume(pool, dom, ent->d_name,
diskPath, diskDescPath))
goto cleanup;
}
@@ -392,24 +392,24 @@ static int parallelsFindVmVolumes(virStoragePoolObjPtr
pool,
}
static int
-parallelsPoolsAdd(virDomainObjPtr dom,
+vzPoolsAdd(virDomainObjPtr dom,
void *opaque)
{
virConnectPtr conn = opaque;
virStoragePoolObjPtr pool;
- if (!(pool = parallelsPoolAddByDomain(conn, dom)))
+ if (!(pool = vzPoolAddByDomain(conn, dom)))
return -1;
- if (parallelsFindVmVolumes(pool, dom))
+ if (vzFindVmVolumes(pool, dom))
return -1;
return 0;
}
-static int parallelsLoadPools(virConnectPtr conn)
+static int vzLoadPools(virConnectPtr conn)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
virStorageDriverStatePtr storageState = privconn->storageState;
char *base = NULL;
size_t i;
@@ -436,7 +436,7 @@ static int parallelsLoadPools(virConnectPtr conn)
goto error;
}
- if (virDomainObjListForEach(privconn->domains, parallelsPoolsAdd, conn) <
0)
+ if (virDomainObjListForEach(privconn->domains, vzPoolsAdd, conn) < 0)
goto error;
for (i = 0; i < privconn->pools.count; i++) {
@@ -446,10 +446,10 @@ static int parallelsLoadPools(virConnectPtr conn)
pool = privconn->pools.objs[i];
pool->active = 1;
- if (parallelsStoragePoolGetAlloc(pool->def) < 0)
+ if (vzStoragePoolGetAlloc(pool->def) < 0)
goto error;
- if (parallelsFindVolumes(pool) < 0)
+ if (vzFindVolumes(pool) < 0)
goto error;
virStoragePoolObjUnlock(privconn->pools.objs[i]);
@@ -463,10 +463,10 @@ static int parallelsLoadPools(virConnectPtr conn)
}
virDrvOpenStatus
-parallelsStorageOpen(virConnectPtr conn,
+vzStorageOpen(virConnectPtr conn,
unsigned int flags)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
virStorageDriverStatePtr storageState;
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
@@ -483,45 +483,45 @@ parallelsStorageOpen(virConnectPtr conn,
}
privconn->storageState = storageState;
- parallelsStorageLock(storageState);
+ vzStorageLock(storageState);
- if (parallelsLoadPools(conn))
+ if (vzLoadPools(conn))
goto error;
- parallelsStorageUnlock(storageState);
+ vzStorageUnlock(storageState);
return VIR_DRV_OPEN_SUCCESS;
error:
- parallelsStorageUnlock(storageState);
- parallelsStorageClose(conn);
+ vzStorageUnlock(storageState);
+ vzStorageClose(conn);
return VIR_DRV_OPEN_ERROR;
}
static int
-parallelsConnectNumOfStoragePools(virConnectPtr conn)
+vzConnectNumOfStoragePools(virConnectPtr conn)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
int numActive = 0;
size_t i;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
for (i = 0; i < privconn->pools.count; i++)
if (virStoragePoolObjIsActive(privconn->pools.objs[i]))
numActive++;
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return numActive;
}
static int
-parallelsConnectListStoragePools(virConnectPtr conn, char **const names, int
nnames)
+vzConnectListStoragePools(virConnectPtr conn, char **const names, int nnames)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
int n = 0;
size_t i;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
memset(names, 0, sizeof(*names) * nnames);
for (i = 0; i < privconn->pools.count && n < nnames; i++) {
virStoragePoolObjLock(privconn->pools.objs[i]);
@@ -532,45 +532,45 @@ parallelsConnectListStoragePools(virConnectPtr conn, char
**const names, int nna
}
virStoragePoolObjUnlock(privconn->pools.objs[i]);
}
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return n;
error:
for (n = 0; n < nnames; n++)
VIR_FREE(names[n]);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return -1;
}
static int
-parallelsConnectNumOfDefinedStoragePools(virConnectPtr conn)
+vzConnectNumOfDefinedStoragePools(virConnectPtr conn)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
int numInactive = 0;
size_t i;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
for (i = 0; i < privconn->pools.count; i++) {
virStoragePoolObjLock(privconn->pools.objs[i]);
if (!virStoragePoolObjIsActive(privconn->pools.objs[i]))
numInactive++;
virStoragePoolObjUnlock(privconn->pools.objs[i]);
}
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return numInactive;
}
static int
-parallelsConnectListDefinedStoragePools(virConnectPtr conn,
+vzConnectListDefinedStoragePools(virConnectPtr conn,
char **const names, int nnames)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
int n = 0;
size_t i;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
memset(names, 0, sizeof(*names) * nnames);
for (i = 0; i < privconn->pools.count && n < nnames; i++) {
virStoragePoolObjLock(privconn->pools.objs[i]);
@@ -581,28 +581,28 @@ parallelsConnectListDefinedStoragePools(virConnectPtr
conn,
}
virStoragePoolObjUnlock(privconn->pools.objs[i]);
}
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return n;
error:
for (n = 0; n < nnames; n++)
VIR_FREE(names[n]);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return -1;
}
static int
-parallelsStoragePoolIsActive(virStoragePoolPtr pool)
+vzStoragePoolIsActive(virStoragePoolPtr pool)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr obj;
int ret = -1;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
obj = virStoragePoolObjFindByUUID(&privconn->pools, pool->uuid);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (!obj) {
virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);
goto cleanup;
@@ -616,21 +616,21 @@ parallelsStoragePoolIsActive(virStoragePoolPtr pool)
}
static int
-parallelsStoragePoolIsPersistent(virStoragePoolPtr pool ATTRIBUTE_UNUSED)
+vzStoragePoolIsPersistent(virStoragePoolPtr pool ATTRIBUTE_UNUSED)
{
return 1;
}
static virStoragePoolPtr
-parallelsStoragePoolLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+vzStoragePoolLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
virStoragePoolObjPtr pool;
virStoragePoolPtr ret = NULL;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
pool = virStoragePoolObjFindByUUID(&privconn->pools, uuid);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (pool == NULL) {
virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);
@@ -647,15 +647,15 @@ parallelsStoragePoolLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
}
static virStoragePoolPtr
-parallelsStoragePoolLookupByName(virConnectPtr conn, const char *name)
+vzStoragePoolLookupByName(virConnectPtr conn, const char *name)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
virStoragePoolObjPtr pool;
virStoragePoolPtr ret = NULL;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
pool = virStoragePoolObjFindByName(&privconn->pools, name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (pool == NULL) {
virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);
@@ -672,9 +672,9 @@ parallelsStoragePoolLookupByName(virConnectPtr conn, const
char *name)
}
static virStoragePoolPtr
-parallelsStoragePoolLookupByVolume(virStorageVolPtr vol)
+vzStoragePoolLookupByVolume(virStorageVolPtr vol)
{
- return parallelsStoragePoolLookupByName(vol->conn, vol->pool);
+ return vzStoragePoolLookupByName(vol->conn, vol->pool);
}
/*
@@ -682,7 +682,7 @@ parallelsStoragePoolLookupByVolume(virStorageVolPtr vol)
* fields in pool definition.
*/
static int
-parallelsStoragePoolGetAlloc(virStoragePoolDefPtr def)
+vzStoragePoolGetAlloc(virStoragePoolDefPtr def)
{
struct statvfs sb;
@@ -703,17 +703,17 @@ parallelsStoragePoolGetAlloc(virStoragePoolDefPtr def)
}
static virStoragePoolPtr
-parallelsStoragePoolDefineXML(virConnectPtr conn,
+vzStoragePoolDefineXML(virConnectPtr conn,
const char *xml, unsigned int flags)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
virStoragePoolDefPtr def;
virStoragePoolObjPtr pool = NULL;
virStoragePoolPtr ret = NULL;
virCheckFlags(0, NULL);
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
if (!(def = virStoragePoolDefParseString(xml)))
goto cleanup;
@@ -729,7 +729,7 @@ parallelsStoragePoolDefineXML(virConnectPtr conn,
if (virStoragePoolSourceFindDuplicate(conn, &privconn->pools, def) < 0)
goto cleanup;
- if (parallelsStoragePoolGetAlloc(def))
+ if (vzStoragePoolGetAlloc(def))
goto cleanup;
if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def)))
@@ -752,22 +752,22 @@ parallelsStoragePoolDefineXML(virConnectPtr conn,
virStoragePoolDefFree(def);
if (pool)
virStoragePoolObjUnlock(pool);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return ret;
}
static int
-parallelsStoragePoolUndefine(virStoragePoolPtr pool)
+vzStoragePoolUndefine(virStoragePoolPtr pool)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int ret = -1;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -788,25 +788,25 @@ parallelsStoragePoolUndefine(virStoragePoolPtr pool)
cleanup:
if (privpool)
virStoragePoolObjUnlock(privpool);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return ret;
}
static int
-parallelsStoragePoolCreate(virStoragePoolPtr pool, unsigned int flags)
+vzStoragePoolCreate(virStoragePoolPtr pool, unsigned int flags)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int ret = -1;
virCheckFlags(0, -1);
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -826,17 +826,17 @@ parallelsStoragePoolCreate(virStoragePoolPtr pool,
unsigned int flags)
}
static int
-parallelsStoragePoolDestroy(virStoragePoolPtr pool)
+vzStoragePoolDestroy(virStoragePoolPtr pool)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int ret = -1;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -855,25 +855,25 @@ parallelsStoragePoolDestroy(virStoragePoolPtr pool)
cleanup:
if (privpool)
virStoragePoolObjUnlock(privpool);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
return ret;
}
static int
-parallelsStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
+vzStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int ret = -1;
virCheckFlags(0, -1);
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -892,18 +892,18 @@ parallelsStoragePoolRefresh(virStoragePoolPtr pool,
unsigned int flags)
static int
-parallelsStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info)
+vzStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int ret = -1;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -924,20 +924,20 @@ parallelsStoragePoolGetInfo(virStoragePoolPtr pool,
virStoragePoolInfoPtr info)
}
static char *
-parallelsStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags)
+vzStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
char *ret = NULL;
virCheckFlags(0, NULL);
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -950,18 +950,18 @@ parallelsStoragePoolGetXMLDesc(virStoragePoolPtr pool,
unsigned int flags)
}
static int
-parallelsStoragePoolGetAutostart(virStoragePoolPtr pool, int *autostart)
+vzStoragePoolGetAutostart(virStoragePoolPtr pool, int *autostart)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int ret = -1;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -979,18 +979,18 @@ parallelsStoragePoolGetAutostart(virStoragePoolPtr pool,
int *autostart)
}
static int
-parallelsStoragePoolSetAutostart(virStoragePoolPtr pool, int autostart)
+vzStoragePoolSetAutostart(virStoragePoolPtr pool, int autostart)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int ret = -1;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -1009,18 +1009,18 @@ parallelsStoragePoolSetAutostart(virStoragePoolPtr
pool, int autostart)
}
static int
-parallelsStoragePoolNumOfVolumes(virStoragePoolPtr pool)
+vzStoragePoolNumOfVolumes(virStoragePoolPtr pool)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int ret = -1;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -1039,22 +1039,22 @@ parallelsStoragePoolNumOfVolumes(virStoragePoolPtr pool)
}
static int
-parallelsStoragePoolListVolumes(virStoragePoolPtr pool,
+vzStoragePoolListVolumes(virStoragePoolPtr pool,
char **const names, int maxnames)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
int n = 0;
size_t i = 0;
memset(names, 0, maxnames * sizeof(*names));
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto error;
}
@@ -1083,20 +1083,20 @@ parallelsStoragePoolListVolumes(virStoragePoolPtr pool,
}
static virStorageVolPtr
-parallelsStorageVolLookupByName(virStoragePoolPtr pool,
+vzStorageVolLookupByName(virStoragePoolPtr pool,
const char *name)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
virStorageVolDefPtr privvol;
virStorageVolPtr ret = NULL;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -1127,13 +1127,13 @@ parallelsStorageVolLookupByName(virStoragePoolPtr pool,
static virStorageVolPtr
-parallelsStorageVolLookupByKey(virConnectPtr conn, const char *key)
+vzStorageVolLookupByKey(virConnectPtr conn, const char *key)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
size_t i;
virStorageVolPtr ret = NULL;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
for (i = 0; i < privconn->pools.count; i++) {
virStoragePoolObjLock(privconn->pools.objs[i]);
if (virStoragePoolObjIsActive(privconn->pools.objs[i])) {
@@ -1151,7 +1151,7 @@ parallelsStorageVolLookupByKey(virConnectPtr conn, const
char *key)
}
virStoragePoolObjUnlock(privconn->pools.objs[i]);
}
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (!ret)
virReportError(VIR_ERR_NO_STORAGE_VOL,
@@ -1161,9 +1161,9 @@ parallelsStorageVolLookupByKey(virConnectPtr conn, const
char *key)
}
virStorageVolPtr
-parallelsStorageVolLookupByPathLocked(virConnectPtr conn, const char *path)
+vzStorageVolLookupByPathLocked(virConnectPtr conn, const char *path)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
size_t i;
virStorageVolPtr ret = NULL;
@@ -1193,20 +1193,20 @@ parallelsStorageVolLookupByPathLocked(virConnectPtr
conn, const char *path)
}
static virStorageVolPtr
-parallelsStorageVolLookupByPath(virConnectPtr conn, const char *path)
+vzStorageVolLookupByPath(virConnectPtr conn, const char *path)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
virStorageVolPtr ret = NULL;
- parallelsDriverLock(privconn);
- ret = parallelsStorageVolLookupByPathLocked(conn, path);
- parallelsDriverUnlock(privconn);
+ vzDriverLock(privconn);
+ ret = vzStorageVolLookupByPathLocked(conn, path);
+ vzDriverUnlock(privconn);
return ret;
}
static virStorageVolDefPtr
-parallelsStorageVolDefineXML(virStoragePoolObjPtr pool,
+vzStorageVolDefineXML(virStoragePoolObjPtr pool,
const char *xmldesc,
const char *xmlfile, bool is_new)
{
@@ -1247,7 +1247,7 @@ parallelsStorageVolDefineXML(virStoragePoolObjPtr pool,
goto cleanup;
if (is_new) {
- xml_path = parallelsAddFileExt(privvol->target.path, ".xml");
+ xml_path = vzAddFileExt(privvol->target.path, ".xml");
if (!xml_path)
goto cleanup;
@@ -1276,22 +1276,22 @@ parallelsStorageVolDefineXML(virStoragePoolObjPtr pool,
}
static virStorageVolPtr
-parallelsStorageVolCreateXML(virStoragePoolPtr pool,
+vzStorageVolCreateXML(virStoragePoolPtr pool,
const char *xmldesc, unsigned int flags)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
virStorageVolPtr ret = NULL;
virStorageVolDefPtr privvol = NULL;
virCheckFlags(0, NULL);
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -1301,7 +1301,7 @@ parallelsStorageVolCreateXML(virStoragePoolPtr pool,
goto cleanup;
}
- privvol = parallelsStorageVolDefineXML(privpool, xmldesc, NULL, true);
+ privvol = vzStorageVolDefineXML(privpool, xmldesc, NULL, true);
if (!privvol)
goto cleanup;
@@ -1315,24 +1315,24 @@ parallelsStorageVolCreateXML(virStoragePoolPtr pool,
}
static virStorageVolPtr
-parallelsStorageVolCreateXMLFrom(virStoragePoolPtr pool,
+vzStorageVolCreateXMLFrom(virStoragePoolPtr pool,
const char *xmldesc,
virStorageVolPtr clonevol,
unsigned int flags)
{
- parallelsConnPtr privconn = pool->conn->privateData;
+ vzConnPtr privconn = pool->conn->privateData;
virStoragePoolObjPtr privpool;
virStorageVolDefPtr privvol = NULL, origvol = NULL;
virStorageVolPtr ret = NULL;
virCheckFlags(0, NULL);
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(pool->name);
+ vzPoolNotFoundError(pool->name);
goto cleanup;
}
@@ -1398,7 +1398,7 @@ parallelsStorageVolCreateXMLFrom(virStoragePoolPtr pool,
return ret;
}
-int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool,
+int vzStorageVolDefRemove(virStoragePoolObjPtr privpool,
virStorageVolDefPtr privvol)
{
int ret = -1;
@@ -1411,7 +1411,7 @@ int parallelsStorageVolDefRemove(virStoragePoolObjPtr
privpool,
for (i = 0; i < privpool->volumes.count; i++) {
if (privpool->volumes.objs[i] == privvol) {
- xml_path = parallelsAddFileExt(privvol->target.path, ".xml");
+ xml_path = vzAddFileExt(privvol->target.path, ".xml");
if (!xml_path)
goto cleanup;
@@ -1435,21 +1435,21 @@ int parallelsStorageVolDefRemove(virStoragePoolObjPtr
privpool,
}
static int
-parallelsStorageVolDelete(virStorageVolPtr vol, unsigned int flags)
+vzStorageVolDelete(virStorageVolPtr vol, unsigned int flags)
{
- parallelsConnPtr privconn = vol->conn->privateData;
+ vzConnPtr privconn = vol->conn->privateData;
virStoragePoolObjPtr privpool;
virStorageVolDefPtr privvol;
int ret = -1;
virCheckFlags(0, -1);
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(vol->pool);
+ vzPoolNotFoundError(vol->pool);
goto cleanup;
}
@@ -1469,7 +1469,7 @@ parallelsStorageVolDelete(virStorageVolPtr vol, unsigned
int flags)
}
- if (parallelsStorageVolDefRemove(privpool, privvol))
+ if (vzStorageVolDefRemove(privpool, privvol))
goto cleanup;
ret = 0;
@@ -1482,7 +1482,7 @@ parallelsStorageVolDelete(virStorageVolPtr vol, unsigned
int flags)
static int
-parallelsStorageVolTypeForPool(int pooltype)
+vzStorageVolTypeForPool(int pooltype)
{
switch (pooltype) {
@@ -1496,19 +1496,19 @@ parallelsStorageVolTypeForPool(int pooltype)
}
static int
-parallelsStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info)
+vzStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info)
{
- parallelsConnPtr privconn = vol->conn->privateData;
+ vzConnPtr privconn = vol->conn->privateData;
virStoragePoolObjPtr privpool;
virStorageVolDefPtr privvol;
int ret = -1;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(vol->pool);
+ vzPoolNotFoundError(vol->pool);
goto cleanup;
}
@@ -1527,7 +1527,7 @@ parallelsStorageVolGetInfo(virStorageVolPtr vol,
virStorageVolInfoPtr info)
}
memset(info, 0, sizeof(*info));
- info->type = parallelsStorageVolTypeForPool(privpool->def->type);
+ info->type = vzStorageVolTypeForPool(privpool->def->type);
info->capacity = privvol->target.capacity;
info->allocation = privvol->target.allocation;
ret = 0;
@@ -1539,21 +1539,21 @@ parallelsStorageVolGetInfo(virStorageVolPtr vol,
virStorageVolInfoPtr info)
}
static char *
-parallelsStorageVolGetXMLDesc(virStorageVolPtr vol, unsigned int flags)
+vzStorageVolGetXMLDesc(virStorageVolPtr vol, unsigned int flags)
{
- parallelsConnPtr privconn = vol->conn->privateData;
+ vzConnPtr privconn = vol->conn->privateData;
virStoragePoolObjPtr privpool;
virStorageVolDefPtr privvol;
char *ret = NULL;
virCheckFlags(0, NULL);
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(vol->pool);
+ vzPoolNotFoundError(vol->pool);
goto cleanup;
}
@@ -1580,19 +1580,19 @@ parallelsStorageVolGetXMLDesc(virStorageVolPtr vol,
unsigned int flags)
}
static char *
-parallelsStorageVolGetPath(virStorageVolPtr vol)
+vzStorageVolGetPath(virStorageVolPtr vol)
{
- parallelsConnPtr privconn = vol->conn->privateData;
+ vzConnPtr privconn = vol->conn->privateData;
virStoragePoolObjPtr privpool;
virStorageVolDefPtr privvol;
char *ret = NULL;
- parallelsDriverLock(privconn);
+ vzDriverLock(privconn);
privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool);
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (privpool == NULL) {
- parallelsPoolNotFoundError(vol->pool);
+ vzPoolNotFoundError(vol->pool);
goto cleanup;
}
@@ -1618,37 +1618,37 @@ parallelsStorageVolGetPath(virStorageVolPtr vol)
return ret;
}
-virStorageDriver parallelsStorageDriver = {
+virStorageDriver vzStorageDriver = {
.name = "Parallels",
- .connectNumOfStoragePools = parallelsConnectNumOfStoragePools, /* 0.10.0
*/
- .connectListStoragePools = parallelsConnectListStoragePools, /* 0.10.0 */
- .connectNumOfDefinedStoragePools =
parallelsConnectNumOfDefinedStoragePools, /* 0.10.0 */
- .connectListDefinedStoragePools = parallelsConnectListDefinedStoragePools,
/* 0.10.0 */
- .storagePoolLookupByName = parallelsStoragePoolLookupByName, /* 0.10.0
*/
- .storagePoolLookupByUUID = parallelsStoragePoolLookupByUUID, /* 0.10.0
*/
- .storagePoolLookupByVolume = parallelsStoragePoolLookupByVolume, /* 0.10.0
*/
- .storagePoolDefineXML = parallelsStoragePoolDefineXML, /* 0.10.0 */
- .storagePoolUndefine = parallelsStoragePoolUndefine, /* 0.10.0 */
- .storagePoolCreate = parallelsStoragePoolCreate, /* 0.10.0 */
- .storagePoolDestroy = parallelsStoragePoolDestroy, /* 0.10.0 */
- .storagePoolRefresh = parallelsStoragePoolRefresh, /* 0.10.0 */
- .storagePoolGetInfo = parallelsStoragePoolGetInfo, /* 0.10.0 */
- .storagePoolGetXMLDesc = parallelsStoragePoolGetXMLDesc, /* 0.10.0 */
- .storagePoolGetAutostart = parallelsStoragePoolGetAutostart, /* 0.10.0
*/
- .storagePoolSetAutostart = parallelsStoragePoolSetAutostart, /* 0.10.0
*/
- .storagePoolNumOfVolumes = parallelsStoragePoolNumOfVolumes, /*
0.10.0 */
- .storagePoolListVolumes = parallelsStoragePoolListVolumes, /* 0.10.0
*/
-
- .storageVolLookupByName = parallelsStorageVolLookupByName, /* 0.10.0 */
- .storageVolLookupByKey = parallelsStorageVolLookupByKey, /* 0.10.0 */
- .storageVolLookupByPath = parallelsStorageVolLookupByPath, /* 0.10.0 */
- .storageVolCreateXML = parallelsStorageVolCreateXML, /* 0.10.0 */
- .storageVolCreateXMLFrom = parallelsStorageVolCreateXMLFrom, /* 0.10.0 */
- .storageVolDelete = parallelsStorageVolDelete, /* 0.10.0 */
- .storageVolGetInfo = parallelsStorageVolGetInfo, /* 0.10.0 */
- .storageVolGetXMLDesc = parallelsStorageVolGetXMLDesc, /* 0.10.0 */
- .storageVolGetPath = parallelsStorageVolGetPath, /* 0.10.0 */
- .storagePoolIsActive = parallelsStoragePoolIsActive, /* 0.10.0 */
- .storagePoolIsPersistent = parallelsStoragePoolIsPersistent, /* 0.10.0
*/
+ .connectNumOfStoragePools = vzConnectNumOfStoragePools, /* 0.10.0 */
+ .connectListStoragePools = vzConnectListStoragePools, /* 0.10.0 */
+ .connectNumOfDefinedStoragePools = vzConnectNumOfDefinedStoragePools,
/* 0.10.0 */
+ .connectListDefinedStoragePools = vzConnectListDefinedStoragePools, /*
0.10.0 */
+ .storagePoolLookupByName = vzStoragePoolLookupByName, /* 0.10.0 */
+ .storagePoolLookupByUUID = vzStoragePoolLookupByUUID, /* 0.10.0 */
+ .storagePoolLookupByVolume = vzStoragePoolLookupByVolume, /* 0.10.0 */
+ .storagePoolDefineXML = vzStoragePoolDefineXML, /* 0.10.0 */
+ .storagePoolUndefine = vzStoragePoolUndefine, /* 0.10.0 */
+ .storagePoolCreate = vzStoragePoolCreate, /* 0.10.0 */
+ .storagePoolDestroy = vzStoragePoolDestroy, /* 0.10.0 */
+ .storagePoolRefresh = vzStoragePoolRefresh, /* 0.10.0 */
+ .storagePoolGetInfo = vzStoragePoolGetInfo, /* 0.10.0 */
+ .storagePoolGetXMLDesc = vzStoragePoolGetXMLDesc, /* 0.10.0 */
+ .storagePoolGetAutostart = vzStoragePoolGetAutostart, /* 0.10.0 */
+ .storagePoolSetAutostart = vzStoragePoolSetAutostart, /* 0.10.0 */
+ .storagePoolNumOfVolumes = vzStoragePoolNumOfVolumes, /* 0.10.0 */
+ .storagePoolListVolumes = vzStoragePoolListVolumes, /* 0.10.0 */
+
+ .storageVolLookupByName = vzStorageVolLookupByName, /* 0.10.0 */
+ .storageVolLookupByKey = vzStorageVolLookupByKey, /* 0.10.0 */
+ .storageVolLookupByPath = vzStorageVolLookupByPath, /* 0.10.0 */
+ .storageVolCreateXML = vzStorageVolCreateXML, /* 0.10.0 */
+ .storageVolCreateXMLFrom = vzStorageVolCreateXMLFrom, /* 0.10.0 */
+ .storageVolDelete = vzStorageVolDelete, /* 0.10.0 */
+ .storageVolGetInfo = vzStorageVolGetInfo, /* 0.10.0 */
+ .storageVolGetXMLDesc = vzStorageVolGetXMLDesc, /* 0.10.0 */
+ .storageVolGetPath = vzStorageVolGetPath, /* 0.10.0 */
+ .storagePoolIsActive = vzStoragePoolIsActive, /* 0.10.0 */
+ .storagePoolIsPersistent = vzStoragePoolIsPersistent, /* 0.10.0 */
};
diff --git a/src/parallels/parallels_utils.c b/src/parallels/parallels_utils.c
index 540986b..995ef79 100644
--- a/src/parallels/parallels_utils.c
+++ b/src/parallels/parallels_utils.c
@@ -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;
diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h
index 5db65bd..ce540b6 100644
--- a/src/parallels/parallels_utils.h
+++ b/src/parallels/parallels_utils.h
@@ -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) \
--
2.1.0
--
libvir-list mailing list
libvir-list@redhat.com
https://www.redhat.com/mailman/listinfo/libvir-list
