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