goto error;
# endif
# ifdef WITH_PARALLELS
- if (parallelsRegister() == -1)
+ if (vzRegister() == -1)
goto error;
# endif
#endif
#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;
}
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)
{
}
static int
-parallelsDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
+vzDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
const virDomainDef *def,
virCapsPtr caps ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED)
}
-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;
if (prlsdkConnect(privconn) < 0)
goto err_free;
- if (!(privconn->caps = parallelsBuildCapabilities()))
+ if (!(privconn->caps = vzBuildCapabilities()))
goto error;
- if (!(privconn->xmlopt = virDomainXMLOptionNew(¶llelsDomainDefParserConfig,
+ if (!(privconn->xmlopt = virDomainXMLOptionNew(&vzDomainDefParserConfig,
NULL, NULL)))
goto error;
}
static virDrvOpenStatus
-parallelsConnectOpen(virConnectPtr conn,
+vzConnectOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
unsigned int flags)
{
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;
}
}
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);
conn->privateData = NULL;
prlsdkDeinit();
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
virMutexDestroy(&privconn->lock);
VIR_FREE(privconn);
}
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;
}
/* 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;
}
}
-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);
}
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];
}
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,
}
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);
}
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)));
}
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;
}
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);
}
static char *
-parallelsDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
+vzDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
virDomainDefPtr def;
virDomainObjPtr privdom;
/* Flags checked by virDomainDefFormat */
- if (!(privdom = parallelsDomObjFromDomain(domain)))
+ if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup;
def = (flags & VIR_DOMAIN_XML_INACTIVE) &&
}
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;
}
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;
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;
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)
static int
-parallelsDomainGetVcpus(virDomainPtr domain,
+vzDomainGetVcpus(virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char *cpumaps,
int v, maxcpu, hostcpus;
int ret = -1;
- if (!(privdom = parallelsDomObjFromDomain(domain)))
+ if (!(privdom = vzDomObjFromDomain(domain)))
goto cleanup;
if (!virDomainObjIsActive(privdom)) {
static int
-parallelsNodeGetCPUMap(virConnectPtr conn ATTRIBUTE_UNUSED,
+vzNodeGetCPUMap(virConnectPtr conn ATTRIBUTE_UNUSED,
unsigned char **cpumap,
unsigned int *online,
unsigned int flags)
}
static int
-parallelsConnectDomainEventRegisterAny(virConnectPtr conn,
+vzConnectDomainEventRegisterAny(virConnectPtr conn,
virDomainPtr domain,
int eventID,
virConnectDomainEventGenericCallback callback,
virFreeCallback freecb)
{
int ret = -1;
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
if (virDomainEventStateRegisterID(conn,
privconn->domainEventState,
domain, eventID,
}
static int
-parallelsConnectDomainEventDeregisterAny(virConnectPtr conn,
+vzConnectDomainEventDeregisterAny(virConnectPtr conn,
int callbackID)
{
- parallelsConnPtr privconn = conn->privateData;
+ vzConnPtr privconn = conn->privateData;
int ret = -1;
if (virObjectEventStateDeregisterID(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);
}
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);
}
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;
virCheckFlags(0, -1);
- if (!(dom = parallelsDomObjFromDomain(domain)))
+ if (!(dom = vzDomObjFromDomain(domain)))
return -1;
state = virDomainObjGetState(dom, &reason);
}
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;
virCheckFlags(VIR_DOMAIN_SAVE_RUNNING |
VIR_DOMAIN_SAVE_PAUSED, -1);
- if (!(dom = parallelsDomObjFromDomain(domain)))
+ if (!(dom = vzDomObjFromDomain(domain)))
return -1;
state = virDomainObjGetState(dom, &reason);
}
static int
-parallelsDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags)
+vzDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags)
{
virDomainObjPtr dom = NULL;
int state, reason;
virCheckFlags(0, -1);
- if (!(dom = parallelsDomObjFromDomain(domain)))
+ if (!(dom = vzDomObjFromDomain(domain)))
return -1;
state = virDomainObjGetState(dom, &reason);
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;
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)) {
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;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
- privdom = parallelsDomObjFromDomain(dom);
+ privdom = vzDomObjFromDomain(dom);
if (privdom == NULL)
return -1;
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;
}
static int
-parallelsDomainBlockStats(virDomainPtr domain, const char *path,
+vzDomainBlockStats(virDomainPtr domain, const char *path,
virDomainBlockStatsPtr stats)
{
virDomainObjPtr dom = NULL;
size_t i;
int idx;
- if (!(dom = parallelsDomObjFromDomainRef(domain)))
+ if (!(dom = vzDomObjFromDomainRef(domain)))
return -1;
if (*path) {
}
static int
-parallelsDomainBlockStatsFlags(virDomainPtr domain,
+vzDomainBlockStatsFlags(virDomainPtr domain,
const char *path,
virTypedParameterPtr params,
int *nparams,
/* 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) {
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 = ¶llelsStorageDriver,
- .networkDriver = ¶llelsNetworkDriver,
+ .storageDriver = &vzStorageDriver,
+ .networkDriver = &vzNetworkDriver,
};
/* Parallels domain type backward compatibility*/
static virConnectDriver parallelsConnectDriver;
/**
- * parallelsRegister:
+ * vzRegister:
*
- * Registers the parallels driver
+ * Registers the vz driver
*/
int
-parallelsRegister(void)
+vzRegister(void)
{
char *prlctl_path;
#ifndef PARALLELS_DRIVER_H
# define PARALLELS_DRIVER_H
-int parallelsRegister(void);
+int vzRegister(void);
#endif
#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;
int ret = -1;
if (!(ifname = virJSONValueObjectGetString(jobj, "Bound To"))) {
- parallelsParseError();
+ vzParseError();
goto cleanup;
}
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;
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;
}
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;
}
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;
}
}
static int
-parallelsLoadNetwork(parallelsConnPtr privconn, virJSONValuePtr jobj)
+vzLoadNetwork(vzConnPtr privconn, virJSONValuePtr jobj)
{
int ret = -1;
virNetworkObjPtr net = NULL;
goto cleanup;
if (!(tmp = virJSONValueObjectGetString(jobj, "Network ID"))) {
- parallelsParseError();
+ vzParseError();
goto cleanup;
}
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))
} 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))
goto cleanup;
}
} else {
- parallelsParseError();
+ vzParseError();
goto cleanup;
}
}
static int
-parallelsAddRoutedNetwork(parallelsConnPtr privconn)
+vzAddRoutedNetwork(vzConnPtr privconn)
{
virNetworkObjPtr net = NULL;
virNetworkDefPtr def;
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;
}
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);
if (!(privconn->networks = virNetworkObjListNew()))
goto error;
- if (parallelsLoadNetworks(conn->privateData) < 0)
+ if (vzLoadNetworks(conn->privateData) < 0)
goto error;
return VIR_DRV_OPEN_SUCCESS;
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;
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,
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,
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;
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;
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;
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;
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;
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;
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 */
};
};
int
-prlsdkConnect(parallelsConnPtr privconn)
+prlsdkConnect(vzConnPtr privconn)
{
PRL_RESULT ret;
PRL_HANDLE job = PRL_INVALID_HANDLE;
}
void
-prlsdkDisconnect(parallelsConnPtr privconn)
+prlsdkDisconnect(vzConnPtr privconn)
{
PRL_HANDLE job;
}
static int
-prlsdkSdkDomainLookup(parallelsConnPtr privconn,
+prlsdkSdkDomainLookup(vzConnPtr privconn,
const char *id,
unsigned int flags,
PRL_HANDLE *sdkdom)
}
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;
static void
prlsdkDomObjFreePrivate(void *p)
{
- parallelsDomObjPtr pdom = p;
+ vzDomObjPtr pdom = p;
if (!pdom)
return;
* 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;
}
int
-prlsdkLoadDomains(parallelsConnPtr privconn)
+prlsdkLoadDomains(vzConnPtr privconn)
{
PRL_HANDLE job = PRL_INVALID_HANDLE;
PRL_HANDLE result;
}
virDomainObjPtr
-prlsdkAddDomain(parallelsConnPtr privconn, const unsigned char *uuid)
+prlsdkAddDomain(vzConnPtr privconn, const unsigned char *uuid)
{
PRL_HANDLE sdkdom = PRL_INVALID_HANDLE;
virDomainObjPtr dom;
}
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))
return retdom ? 0 : -1;
}
-static int prlsdkSendEvent(parallelsConnPtr privconn,
+static int prlsdkSendEvent(vzConnPtr privconn,
virDomainObjPtr dom,
virDomainEventType lvEventType,
int lvEventTypeDetails)
}
static void
-prlsdkHandleVmStateEvent(parallelsConnPtr privconn,
+prlsdkHandleVmStateEvent(vzConnPtr privconn,
PRL_HANDLE prlEvent,
unsigned char *uuid)
{
PRL_HANDLE eventParam = PRL_INVALID_HANDLE;
PRL_INT32 domainState;
virDomainObjPtr dom = NULL;
- parallelsDomObjPtr pdom;
+ vzDomObjPtr pdom;
virDomainEventType lvEventType = 0;
int lvEventTypeDetails = 0;
}
static void
-prlsdkHandleVmConfigEvent(parallelsConnPtr privconn,
+prlsdkHandleVmConfigEvent(vzConnPtr privconn,
unsigned char *uuid)
{
virDomainObjPtr dom = NULL;
}
static void
-prlsdkHandleVmAddedEvent(parallelsConnPtr privconn,
+prlsdkHandleVmAddedEvent(vzConnPtr privconn,
unsigned char *uuid)
{
virDomainObjPtr dom = NULL;
}
static void
-prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn,
+prlsdkHandleVmRemovedEvent(vzConnPtr privconn,
unsigned char *uuid)
{
virDomainObjPtr dom = NULL;
#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);
}
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];
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;
}
-int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn)
+int prlsdkSubscribeToPCSEvents(vzConnPtr privconn)
{
PRL_RESULT pret = PRL_ERR_UNINITIALIZED;
return -1;
}
-void prlsdkUnsubscribeFromPCSEvents(parallelsConnPtr privconn)
+void prlsdkUnsubscribeFromPCSEvents(vzConnPtr privconn)
{
PRL_RESULT ret = PRL_ERR_UNINITIALIZED;
ret = PrlSrv_UnregEventHandler(privconn->server,
}
int
-prlsdkDomainChangeStateLocked(parallelsConnPtr privconn,
+prlsdkDomainChangeStateLocked(vzConnPtr privconn,
virDomainObjPtr dom,
prlsdkChangeStateFunc chstate)
{
- parallelsDomObjPtr pdom;
+ vzDomObjPtr pdom;
PRL_RESULT pret;
virErrorNumber virerr;
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);
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 */
}
static int prlsdkAddNet(PRL_HANDLE sdkdom,
- parallelsConnPtr privconn,
+ vzConnPtr privconn,
virDomainNetDefPtr net,
bool isCt)
{
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;
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);
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);
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;
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;
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;
}
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;
int
prlsdkDomainManagedSaveRemove(virDomainObjPtr dom)
{
- parallelsDomObjPtr privdom = dom->privateData;
+ vzDomObjPtr privdom = dom->privateData;
PRL_HANDLE job;
job = PrlVm_DropSuspendedState(privdom->sdkdom);
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;
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);
prlsdkDomainChangeState(virDomainPtr domain,
prlsdkChangeStateFunc chstate);
int
-prlsdkDomainChangeStateLocked(parallelsConnPtr privconn,
+prlsdkDomainChangeStateLocked(vzConnPtr privconn,
virDomainObjPtr dom,
prlsdkChangeStateFunc chstate);
int
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
#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;
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);
}
static int
-parallelsFindVolumes(virStoragePoolObjPtr pool)
+vzFindVolumes(virStoragePoolObjPtr pool)
{
DIR *dir;
struct dirent *ent;
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);
/*
* 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;
}
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;
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)) {
* 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;
}
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)
{
}
-static int parallelsDiskDescParse(const char *path, virStorageVolDefPtr def)
+static int vzDiskDescParse(const char *path, virStorageVolDefPtr def)
{
xmlDocPtr xml;
int ret = -1;
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,
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)))
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;
/* 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;
}
}
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;
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++) {
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]);
}
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);
}
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]);
}
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]);
}
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;
}
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);
}
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);
}
static virStoragePoolPtr
-parallelsStoragePoolLookupByVolume(virStorageVolPtr vol)
+vzStoragePoolLookupByVolume(virStorageVolPtr vol)
{
- return parallelsStoragePoolLookupByName(vol->conn, vol->pool);
+ return vzStoragePoolLookupByName(vol->conn, vol->pool);
}
/*
* fields in pool definition.
*/
static int
-parallelsStoragePoolGetAlloc(virStoragePoolDefPtr def)
+vzStoragePoolGetAlloc(virStoragePoolDefPtr def)
{
struct statvfs sb;
}
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;
if (virStoragePoolSourceFindDuplicate(conn, &privconn->pools, def) < 0)
goto cleanup;
- if (parallelsStoragePoolGetAlloc(def))
+ if (vzStoragePoolGetAlloc(def))
goto cleanup;
if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def)))
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;
}
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;
}
}
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;
}
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;
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
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])) {
}
virStoragePoolObjUnlock(privconn->pools.objs[i]);
}
- parallelsDriverUnlock(privconn);
+ vzDriverUnlock(privconn);
if (!ret)
virReportError(VIR_ERR_NO_STORAGE_VOL,
}
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;
}
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)
{
goto cleanup;
if (is_new) {
- xml_path = parallelsAddFileExt(privvol->target.path, ".xml");
+ xml_path = vzAddFileExt(privvol->target.path, ".xml");
if (!xml_path)
goto cleanup;
}
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;
}
goto cleanup;
}
- privvol = parallelsStorageVolDefineXML(privpool, xmldesc, NULL, true);
+ privvol = vzStorageVolDefineXML(privpool, xmldesc, NULL, true);
if (!privvol)
goto cleanup;
}
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;
}
return ret;
}
-int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool,
+int vzStorageVolDefRemove(virStoragePoolObjPtr privpool,
virStorageVolDefPtr privvol)
{
int ret = -1;
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;
}
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;
}
}
- if (parallelsStorageVolDefRemove(privpool, privvol))
+ if (vzStorageVolDefRemove(privpool, privvol))
goto cleanup;
ret = 0;
static int
-parallelsStorageVolTypeForPool(int pooltype)
+vzStorageVolTypeForPool(int pooltype)
{
switch (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;
}
}
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;
}
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;
}
}
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;
}
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 */
};
#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
* 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);
}
/**
- * parallelsDomObjFromDomainRef:
+ * vzDomObjFromDomainRef:
* @domain: Domain pointer that has to be looked up
*
* This function looks up @domain and returns the appropriate virDomainObjPtr
* 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);
}
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;
* pointer to virJSONValue or NULL in case of error.
*/
virJSONValuePtr
-parallelsParseOutput(const char *binary, ...)
+vzParseOutput(const char *binary, ...)
{
char *outbuf;
virJSONValuePtr jobj = NULL;
int ret;
va_start(list, binary);
- ret = parallelsDoCmdRun(&outbuf, binary, list);
+ ret = vzDoCmdRun(&outbuf, binary, list);
va_end(list);
if (ret)
return NULL;
* 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;
* 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;
* 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;
# 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); \
# define PARALLELS_REQUIRED_BRIDGED_NETWORK "Bridged"
# define PARALLELS_BRIDGED_NETWORK_TYPE "bridged"
-struct _parallelsConn {
+struct _vzConn {
virMutex lock;
/* Immutable pointer, self-locking APIs */
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
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) \
projects / libvirt.git / commitdiff