static char * parallelsConnectGetCapabilities(virConnectPtr conn) { parallelsConnPtr privconn = conn->privateData; char *xml; parallelsDriverLock(privconn); xml = virCapabilitiesFormatXML(privconn->caps); parallelsDriverUnlock(privconn); return xml; }
static virStoragePoolPtr parallelsStoragePoolDefineXML(virConnectPtr conn, const char *xml, unsigned int flags) { parallelsConnPtr privconn = conn->privateData; virStoragePoolDefPtr def; virStoragePoolObjPtr pool = NULL; virStoragePoolPtr ret = NULL; virCheckFlags(0, NULL); parallelsDriverLock(privconn); if (!(def = virStoragePoolDefParseString(xml))) goto cleanup; if (def->type != VIR_STORAGE_POOL_DIR) { virReportError(VIR_ERR_NO_SUPPORT, "%s", _("Only local directories are supported")); goto cleanup; } if (virStoragePoolObjIsDuplicate(&privconn->pools, def, 0) < 0) goto cleanup; if (virStoragePoolSourceFindDuplicate(&privconn->pools, def) < 0) goto cleanup; if (parallelsStoragePoolGetAlloc(def)) goto cleanup; if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def))) goto cleanup; if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) { virStoragePoolObjRemove(&privconn->pools, pool); def = NULL; goto cleanup; } def = NULL; if (VIR_STRDUP(pool->configFile, "\0") < 0) goto cleanup; ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid, NULL, NULL); cleanup: virStoragePoolDefFree(def); if (pool) virStoragePoolObjUnlock(pool); parallelsDriverUnlock(privconn); return ret; }
static virStorageVolPtr parallelsStorageVolLookupByPath(virConnectPtr conn, const char *path) { parallelsConnPtr privconn = conn->privateData; virStorageVolPtr ret = NULL; parallelsDriverLock(privconn); ret = parallelsStorageVolLookupByPathLocked(conn, path); parallelsDriverUnlock(privconn); return ret; }
static int parallelsConnectNumOfStoragePools(virConnectPtr conn) { parallelsConnPtr privconn = conn->privateData; int numActive = 0; size_t i; parallelsDriverLock(privconn); for (i = 0; i < privconn->pools.count; i++) if (virStoragePoolObjIsActive(privconn->pools.objs[i])) numActive++; parallelsDriverUnlock(privconn); return numActive; }
static int parallelsListAllNetworks(virConnectPtr conn, virNetworkPtr **nets, unsigned int flags) { parallelsConnPtr privconn = conn->privateData; int ret = -1; virCheckFlags(VIR_CONNECT_LIST_NETWORKS_FILTERS_ALL, -1); parallelsDriverLock(privconn); ret = virNetworkList(conn, privconn->networks, nets, flags); parallelsDriverUnlock(privconn); return ret; }
static int parallelsNumDefinedNetworks(virConnectPtr conn) { int ninactive = 0, i; parallelsConnPtr privconn = conn->privateData; parallelsDriverLock(privconn); for (i = 0 ; i < privconn->networks.count ; i++) { virNetworkObjLock(privconn->networks.objs[i]); if (!virNetworkObjIsActive(privconn->networks.objs[i])) ninactive++; virNetworkObjUnlock(privconn->networks.objs[i]); } parallelsDriverUnlock(privconn); return ninactive; }
static int parallelsStorageVolDelete(virStorageVolPtr vol, unsigned int flags) { parallelsConnPtr privconn = vol->conn->privateData; virStoragePoolObjPtr privpool; virStorageVolDefPtr privvol; int ret = -1; virCheckFlags(0, -1); parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(vol->pool); goto cleanup; } privvol = virStorageVolDefFindByName(privpool, vol->name); if (privvol == NULL) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), vol->name); goto cleanup; } if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, _("storage pool '%s' is not active"), vol->pool); goto cleanup; } if (parallelsStorageVolDefRemove(privpool, privvol)) goto cleanup; ret = 0; cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static int parallelsStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int maxnames) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; int n = 0; size_t i = 0; memset(names, 0, maxnames * sizeof(*names)); parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(pool->name); goto error; } if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, _("storage pool '%s' is not active"), pool->name); goto error; } for (i = 0; i < privpool->volumes.count && n < maxnames; i++) { if (VIR_STRDUP(names[n++], privpool->volumes.objs[i]->name) < 0) goto error; } virStoragePoolObjUnlock(privpool); return n; error: for (n = 0; n < maxnames; n++) VIR_FREE(names[i]); if (privpool) virStoragePoolObjUnlock(privpool); return -1; }
static int parallelsStorageVolGetInfo(virStorageVolPtr vol, virStorageVolInfoPtr info) { parallelsConnPtr privconn = vol->conn->privateData; virStoragePoolObjPtr privpool; virStorageVolDefPtr privvol; int ret = -1; parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(vol->pool); goto cleanup; } privvol = virStorageVolDefFindByName(privpool, vol->name); if (privvol == NULL) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), vol->name); goto cleanup; } if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, _("storage pool '%s' is not active"), vol->pool); goto cleanup; } memset(info, 0, sizeof(*info)); info->type = parallelsStorageVolTypeForPool(privpool->def->type); info->capacity = privvol->target.capacity; info->allocation = privvol->target.allocation; ret = 0; cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static virStorageVolPtr parallelsStorageVolLookupByName(virStoragePoolPtr pool, const char *name) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; virStorageVolDefPtr privvol; virStorageVolPtr ret = NULL; parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(pool->name); goto cleanup; } if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, _("storage pool '%s' is not active"), pool->name); goto cleanup; } privvol = virStorageVolDefFindByName(privpool, name); if (!privvol) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), name); goto cleanup; } ret = virGetStorageVol(pool->conn, privpool->def->name, privvol->name, privvol->key, NULL, NULL); cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static int parallelsNetworkIsPersistent(virNetworkPtr net) { parallelsConnPtr privconn = net->conn->privateData; virNetworkObjPtr obj; int ret = -1; parallelsDriverLock(privconn); obj = virNetworkFindByUUID(&privconn->networks, net->uuid); parallelsDriverUnlock(privconn); if (!obj) { virReportError(VIR_ERR_NO_NETWORK, NULL); goto cleanup; } ret = obj->persistent; cleanup: if (obj) virNetworkObjUnlock(obj); return ret; }
static int parallelsStoragePoolIsActive(virStoragePoolPtr pool) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr obj; int ret = -1; parallelsDriverLock(privconn); obj = virStoragePoolObjFindByUUID(&privconn->pools, pool->uuid); parallelsDriverUnlock(privconn); if (!obj) { virReportError(VIR_ERR_NO_STORAGE_POOL, NULL); goto cleanup; } ret = virStoragePoolObjIsActive(obj); cleanup: if (obj) virStoragePoolObjUnlock(obj); return ret; }
static virStorageVolPtr parallelsStorageVolCreateXML(virStoragePoolPtr pool, const char *xmldesc, unsigned int flags) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; virStorageVolPtr ret = NULL; virStorageVolDefPtr privvol = NULL; virCheckFlags(0, NULL); parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(pool->name); goto cleanup; } if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, _("storage pool '%s' is not active"), pool->name); goto cleanup; } privvol = parallelsStorageVolDefineXML(privpool, xmldesc, NULL, true); if (!privvol) goto cleanup; ret = virGetStorageVol(pool->conn, privpool->def->name, privvol->name, privvol->key, NULL, NULL); cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static char * parallelsStorageVolGetPath(virStorageVolPtr vol) { parallelsConnPtr privconn = vol->conn->privateData; virStoragePoolObjPtr privpool; virStorageVolDefPtr privvol; char *ret = NULL; parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, vol->pool); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(vol->pool); goto cleanup; } privvol = virStorageVolDefFindByName(privpool, vol->name); if (privvol == NULL) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), vol->name); goto cleanup; } if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, _("storage pool '%s' is not active"), vol->pool); goto cleanup; } ignore_value(VIR_STRDUP(ret, privvol->target.path)); cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static virNetworkPtr parallelsNetworkLookupByName(virConnectPtr conn, const char *name) { parallelsConnPtr privconn = conn->privateData; virNetworkObjPtr network; virNetworkPtr ret = NULL; parallelsDriverLock(privconn); network = virNetworkFindByName(&privconn->networks, name); parallelsDriverUnlock(privconn); if (!network) { virReportError(VIR_ERR_NO_NETWORK, _("no network with matching name '%s'"), name); goto cleanup; } ret = virGetNetwork(conn, network->def->name, network->def->uuid); cleanup: if (network) virNetworkObjUnlock(network); return ret; }
static virStoragePoolPtr parallelsStoragePoolLookupByName(virConnectPtr conn, const char *name) { parallelsConnPtr privconn = conn->privateData; virStoragePoolObjPtr pool; virStoragePoolPtr ret = NULL; parallelsDriverLock(privconn); pool = virStoragePoolObjFindByName(&privconn->pools, name); parallelsDriverUnlock(privconn); if (pool == NULL) { virReportError(VIR_ERR_NO_STORAGE_POOL, NULL); goto cleanup; } ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid, NULL, NULL); cleanup: if (pool) virStoragePoolObjUnlock(pool); return ret; }
static int parallelsNetworkGetAutostart(virNetworkPtr net, int *autostart) { parallelsConnPtr privconn = net->conn->privateData; virNetworkObjPtr network; int ret = -1; parallelsDriverLock(privconn); network = virNetworkFindByUUID(&privconn->networks, net->uuid); parallelsDriverUnlock(privconn); if (!network) { virReportError(VIR_ERR_NO_NETWORK, "%s", _("no network with matching uuid")); goto cleanup; } *autostart = network->autostart; ret = 0; cleanup: if (network) virNetworkObjUnlock(network); return ret; }
static virStorageVolPtr parallelsStorageVolCreateXMLFrom(virStoragePoolPtr pool, const char *xmldesc, virStorageVolPtr clonevol, unsigned int flags) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; virStorageVolDefPtr privvol = NULL, origvol = NULL; virStorageVolPtr ret = NULL; virCheckFlags(0, NULL); parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(pool->name); goto cleanup; } if (!virStoragePoolObjIsActive(privpool)) { virReportError(VIR_ERR_OPERATION_INVALID, _("storage pool '%s' is not active"), pool->name); goto cleanup; } privvol = virStorageVolDefParseString(privpool->def, xmldesc); if (privvol == NULL) goto cleanup; if (virStorageVolDefFindByName(privpool, privvol->name)) { virReportError(VIR_ERR_OPERATION_FAILED, "%s", _("storage vol already exists")); goto cleanup; } origvol = virStorageVolDefFindByName(privpool, clonevol->name); if (!origvol) { virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching name '%s'"), clonevol->name); goto cleanup; } /* Make sure enough space */ if ((privpool->def->allocation + privvol->target.allocation) > privpool->def->capacity) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Not enough free space in pool for volume '%s'"), privvol->name); goto cleanup; } privpool->def->available = (privpool->def->capacity - privpool->def->allocation); if (virAsprintf(&privvol->target.path, "%s/%s", privpool->def->target.path, privvol->name) == -1) goto cleanup; if (VIR_STRDUP(privvol->key, privvol->target.path) < 0) goto cleanup; privpool->def->allocation += privvol->target.allocation; privpool->def->available = (privpool->def->capacity - privpool->def->allocation); if (VIR_APPEND_ELEMENT_COPY(privpool->volumes.objs, privpool->volumes.count, privvol) < 0) goto cleanup; ret = virGetStorageVol(pool->conn, privpool->def->name, privvol->name, privvol->key, NULL, NULL); privvol = NULL; cleanup: virStorageVolDefFree(privvol); if (privpool) virStoragePoolObjUnlock(privpool); return ret; }