virStorageVolPtr parallelsStorageVolLookupByPathLocked(virConnectPtr conn, const char *path) { parallelsConnPtr privconn = conn->privateData; size_t i; virStorageVolPtr ret = NULL; for (i = 0; i < privconn->pools.count; i++) { virStoragePoolObjLock(privconn->pools.objs[i]); if (virStoragePoolObjIsActive(privconn->pools.objs[i])) { virStorageVolDefPtr privvol = virStorageVolDefFindByPath(privconn->pools.objs[i], path); if (privvol) { ret = virGetStorageVol(conn, privconn->pools.objs[i]->def->name, privvol->name, privvol->key, NULL, NULL); virStoragePoolObjUnlock(privconn->pools.objs[i]); break; } } virStoragePoolObjUnlock(privconn->pools.objs[i]); } if (!ret) virReportError(VIR_ERR_NO_STORAGE_VOL, _("no storage vol with matching path '%s'"), path); return ret; }
static int parallelsConnectListDefinedStoragePools(virConnectPtr conn, char **const names, int nnames) { parallelsConnPtr privconn = conn->privateData; int n = 0; size_t i; parallelsDriverLock(privconn); memset(names, 0, sizeof(*names) * nnames); for (i = 0; i < privconn->pools.count && n < nnames; i++) { virStoragePoolObjLock(privconn->pools.objs[i]); if (!virStoragePoolObjIsActive(privconn->pools.objs[i]) && VIR_STRDUP(names[n++], privconn->pools.objs[i]->def->name) < 0) { virStoragePoolObjUnlock(privconn->pools.objs[i]); goto error; } virStoragePoolObjUnlock(privconn->pools.objs[i]); } parallelsDriverUnlock(privconn); return n; error: for (n = 0; n < nnames; n++) VIR_FREE(names[n]); parallelsDriverUnlock(privconn); return -1; }
static int parallelsStoragePoolDestroy(virStoragePoolPtr pool) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; int ret = -1; parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); 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; } if (privpool->configFile == NULL) { virStoragePoolObjRemove(&privconn->pools, privpool); privpool = NULL; } ret = 0; cleanup: if (privpool) virStoragePoolObjUnlock(privpool); parallelsDriverUnlock(privconn); return ret; }
static int parallelsStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; int ret = -1; virCheckFlags(0, -1); 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; } ret = 0; cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static int parallelsStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; int ret = -1; parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(pool->name); goto cleanup; } memset(info, 0, sizeof(virStoragePoolInfo)); if (privpool->active) info->state = VIR_STORAGE_POOL_RUNNING; else info->state = VIR_STORAGE_POOL_INACTIVE; info->capacity = privpool->def->capacity; info->allocation = privpool->def->allocation; info->available = privpool->def->available; ret = 0; cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static char * parallelsStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; char *ret = NULL; virCheckFlags(0, NULL); parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(pool->name); goto cleanup; } ret = virStoragePoolDefFormat(privpool->def); cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static int parallelsStoragePoolGetAutostart(virStoragePoolPtr pool, int *autostart) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; int ret = -1; parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(pool->name); goto cleanup; } if (!privpool->configFile) { *autostart = 0; } else { *autostart = privpool->autostart; } ret = 0; cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static int parallelsStoragePoolSetAutostart(virStoragePoolPtr pool, int autostart) { parallelsConnPtr privconn = pool->conn->privateData; virStoragePoolObjPtr privpool; int ret = -1; parallelsDriverLock(privconn); privpool = virStoragePoolObjFindByName(&privconn->pools, pool->name); parallelsDriverUnlock(privconn); if (privpool == NULL) { parallelsPoolNotFoundError(pool->name); goto cleanup; } if (!privpool->configFile) { virReportError(VIR_ERR_INVALID_ARG, "%s", _("pool has no config file")); goto cleanup; } privpool->autostart = (autostart != 0); ret = 0; cleanup: if (privpool) virStoragePoolObjUnlock(privpool); return ret; }
static virStoragePoolObjPtr parallelsPoolCreateByPath(virConnectPtr conn, const char *path) { parallelsConnPtr privconn = conn->privateData; virStoragePoolObjListPtr pools = &privconn->pools; virStoragePoolDefPtr def; virStoragePoolObjPtr pool = NULL; if (VIR_ALLOC(def) < 0) goto no_memory; if (!(def->name = parallelsMakePoolName(conn, path))) goto error; if (VIR_ALLOC_N(def->uuid, VIR_UUID_BUFLEN)) goto no_memory; if (virUUIDGenerate(def->uuid)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Can't generate UUID")); goto error; } def->type = VIR_STORAGE_POOL_DIR; if (VIR_STRDUP(def->target.path, path) < 0) goto error; if (!(pool = virStoragePoolObjAssignDef(pools, def))) goto error; if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) { virStoragePoolObjRemove(pools, pool); goto error; } virStoragePoolObjUnlock(pool); return pool; no_memory: virReportOOMError(); error: virStoragePoolDefFree(def); if (pool) virStoragePoolObjUnlock(pool); return NULL; }
static int parallelsLoadPools(virConnectPtr conn) { parallelsConnPtr privconn = conn->privateData; virStorageDriverStatePtr storageState = conn->storagePrivateData; char *base = NULL; size_t i; if (VIR_STRDUP(base, SYSCONFDIR "/libvirt") < 0) goto error; /* Configuration path is /etc/libvirt/parallels-storage/... . */ if (virAsprintf(&storageState->configDir, "%s/parallels-storage", base) == -1) goto out_of_memory; if (virAsprintf(&storageState->autostartDir, "%s/parallels-storage/autostart", base) == -1) goto out_of_memory; VIR_FREE(base); if (virStoragePoolLoadAllConfigs(&privconn->pools, storageState->configDir, storageState->autostartDir) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Failed to load pool configs")); goto error; } if (virDomainObjListForEach(privconn->domains, parallelsPoolsAdd, conn) < 0) goto error; for (i = 0; i < privconn->pools.count; i++) { virStoragePoolObjLock(privconn->pools.objs[i]); virStoragePoolObjPtr pool; pool = privconn->pools.objs[i]; pool->active = 1; if (parallelsStoragePoolGetAlloc(pool->def) < 0) goto error; if (parallelsFindVolumes(pool) < 0) goto error; virStoragePoolObjUnlock(privconn->pools.objs[i]); } return 0; out_of_memory: virReportOOMError(); error: VIR_FREE(base); return -1; }
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 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 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 parallelsConnectNumOfDefinedStoragePools(virConnectPtr conn) { parallelsConnPtr privconn = conn->privateData; int numInactive = 0; size_t i; parallelsDriverLock(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); return numInactive; }
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 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 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 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 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; }