On Tue, May 09, 2017 at 11:30:15AM -0400, John Ferlan wrote:
A virStoragePoolObjPtr will be an 'obj'.
A virStoragePoolPtr will be a 'pool'.
A virStorageVolPtr will be a 'vol'.
A virStorageVolDefPtr will be a 'voldef'.
Signed-off-by: John Ferlan <jferlan(a)redhat.com>
---
src/storage/storage_driver.c | 1158 +++++++++++++++++++++---------------------
src/storage/storage_driver.h | 4 +-
2 files changed, 582 insertions(+), 580 deletions(-)
diff --git a/src/storage/storage_driver.c b/src/storage/storage_driver.c
index 2103ed1..6122396 100644
--- a/src/storage/storage_driver.c
+++ b/src/storage/storage_driver.c
@@ -87,45 +87,45 @@ static void storageDriverUnlock(void)
* pools are removed.
*/
static void
-virStoragePoolUpdateInactive(virStoragePoolObjPtr *poolptr)
+virStoragePoolUpdateInactive(virStoragePoolObjPtr *objptr)
{
- virStoragePoolObjPtr pool = *poolptr;
+ virStoragePoolObjPtr obj = *objptr;
- if (pool->configFile == NULL) {
- virStoragePoolObjRemove(&driver->pools, pool);
- *poolptr = NULL;
- } else if (pool->newDef) {
- virStoragePoolDefFree(pool->def);
- pool->def = pool->newDef;
- pool->newDef = NULL;
+ if (obj->configFile == NULL) {
+ virStoragePoolObjRemove(&driver->pools, obj);
+ *objptr = NULL;
+ } else if (obj->newDef) {
+ virStoragePoolDefFree(obj->def);
+ obj->def = obj->newDef;
+ obj->newDef = NULL;
}
}
static void
-storagePoolUpdateState(virStoragePoolObjPtr pool)
+storagePoolUpdateState(virStoragePoolObjPtr obj)
{
bool active = false;
virStorageBackendPtr backend;
char *stateFile;
if (!(stateFile = virFileBuildPath(driver->stateDir,
- pool->def->name, ".xml")))
+ obj->def->name, ".xml")))
goto cleanup;
- if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
+ if ((backend = virStorageBackendForType(obj->def->type)) == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Missing backend %d"), pool->def->type);
+ _("Missing backend %d"), obj->def->type);
goto cleanup;
}
/* Backends which do not support 'checkPool' are considered
* inactive by default. */
if (backend->checkPool &&
- backend->checkPool(pool, &active) < 0) {
+ backend->checkPool(obj, &active) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Failed to initialize storage pool '%s':
%s"),
- pool->def->name, virGetLastErrorMessage());
+ obj->def->name, virGetLastErrorMessage());
active = false;
}
@@ -134,21 +134,21 @@ storagePoolUpdateState(virStoragePoolObjPtr pool)
* continue with other pools.
*/
if (active) {
- virStoragePoolObjClearVols(pool);
- if (backend->refreshPool(NULL, pool) < 0) {
+ virStoragePoolObjClearVols(obj);
+ if (backend->refreshPool(NULL, obj) < 0) {
if (backend->stopPool)
- backend->stopPool(NULL, pool);
+ backend->stopPool(NULL, obj);
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Failed to restart storage pool '%s':
%s"),
- pool->def->name, virGetLastErrorMessage());
+ obj->def->name, virGetLastErrorMessage());
active = false;
}
}
- pool->active = active;
+ obj->active = active;
- if (!pool->active)
- virStoragePoolUpdateInactive(&pool);
+ if (!obj->active)
+ virStoragePoolUpdateInactive(&obj);
cleanup:
if (!active && stateFile)
@@ -164,11 +164,11 @@ storagePoolUpdateAllState(void)
size_t i;
for (i = 0; i < driver->pools.count; i++) {
- virStoragePoolObjPtr pool = driver->pools.objs[i];
+ virStoragePoolObjPtr obj = driver->pools.objs[i];
- virStoragePoolObjLock(pool);
- storagePoolUpdateState(pool);
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjLock(obj);
+ storagePoolUpdateState(obj);
+ virStoragePoolObjUnlock(obj);
}
}
@@ -186,24 +186,24 @@ storageDriverAutostart(void)
/* Ignoring NULL conn - let backends decide */
for (i = 0; i < driver->pools.count; i++) {
- virStoragePoolObjPtr pool = driver->pools.objs[i];
+ virStoragePoolObjPtr obj = driver->pools.objs[i];
virStorageBackendPtr backend;
bool started = false;
- virStoragePoolObjLock(pool);
- if ((backend = virStorageBackendForType(pool->def->type)) == NULL) {
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjLock(obj);
+ if ((backend = virStorageBackendForType(obj->def->type)) == NULL) {
+ virStoragePoolObjUnlock(obj);
continue;
}
- if (pool->autostart &&
- !virStoragePoolObjIsActive(pool)) {
+ if (obj->autostart &&
+ !virStoragePoolObjIsActive(obj)) {
if (backend->startPool &&
- backend->startPool(conn, pool) < 0) {
+ backend->startPool(conn, obj) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Failed to autostart storage pool '%s':
%s"),
- pool->def->name, virGetLastErrorMessage());
- virStoragePoolObjUnlock(pool);
+ obj->def->name, virGetLastErrorMessage());
+ virStoragePoolObjUnlock(obj);
continue;
}
started = true;
@@ -212,25 +212,25 @@ storageDriverAutostart(void)
if (started) {
char *stateFile;
- virStoragePoolObjClearVols(pool);
+ virStoragePoolObjClearVols(obj);
stateFile = virFileBuildPath(driver->stateDir,
- pool->def->name, ".xml");
+ obj->def->name, ".xml");
if (!stateFile ||
- virStoragePoolSaveState(stateFile, pool->def) < 0 ||
- backend->refreshPool(conn, pool) < 0) {
+ virStoragePoolSaveState(stateFile, obj->def) < 0 ||
+ backend->refreshPool(conn, obj) < 0) {
if (stateFile)
unlink(stateFile);
if (backend->stopPool)
- backend->stopPool(conn, pool);
+ backend->stopPool(conn, obj);
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Failed to autostart storage pool '%s':
%s"),
- pool->def->name, virGetLastErrorMessage());
+ obj->def->name, virGetLastErrorMessage());
} else {
- pool->active = true;
+ obj->active = true;
}
VIR_FREE(stateFile);
}
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
}
virObjectUnref(conn);
@@ -391,10 +391,10 @@ static virStoragePoolObjPtr
storagePoolObjFindByUUID(const unsigned char *uuid,
const char *name)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
char uuidstr[VIR_UUID_STRING_BUFLEN];
- if (!(pool = virStoragePoolObjFindByUUID(&driver->pools, uuid))) {
+ if (!(obj = virStoragePoolObjFindByUUID(&driver->pools, uuid))) {
virUUIDFormat(uuid, uuidstr);
if (name)
virReportError(VIR_ERR_NO_STORAGE_POOL,
@@ -406,7 +406,7 @@ storagePoolObjFindByUUID(const unsigned char *uuid,
uuidstr);
}
- return pool;
+ return obj;
}
@@ -426,15 +426,15 @@ virStoragePoolObjFromStoragePool(virStoragePoolPtr pool)
static virStoragePoolObjPtr
storagePoolObjFindByName(const char *name)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
storageDriverLock();
- if (!(pool = virStoragePoolObjFindByName(&driver->pools, name)))
+ if (!(obj = virStoragePoolObjFindByName(&driver->pools, name)))
virReportError(VIR_ERR_NO_STORAGE_POOL,
_("no storage pool with matching name '%s'"),
name);
storageDriverUnlock();
- return pool;
+ return obj;
}
@@ -442,65 +442,63 @@ static virStoragePoolPtr
storagePoolLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
- virStoragePoolObjPtr pool;
- virStoragePoolPtr ret = NULL;
+ virStoragePoolObjPtr obj;
+ virStoragePoolPtr pool = NULL;
storageDriverLock();
- pool = storagePoolObjFindByUUID(uuid, NULL);
+ obj = storagePoolObjFindByUUID(uuid, NULL);
storageDriverUnlock();
- if (!pool)
+ if (!obj)
return NULL;
- if (virStoragePoolLookupByUUIDEnsureACL(conn, pool->def) < 0)
+ if (virStoragePoolLookupByUUIDEnsureACL(conn, obj->def) < 0)
goto cleanup;
- ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,
- NULL, NULL);
+ pool = virGetStoragePool(conn, obj->def->name, obj->def->uuid, NULL,
NULL);
cleanup:
- virStoragePoolObjUnlock(pool);
- return ret;
+ virStoragePoolObjUnlock(obj);
+ return pool;
}
static virStoragePoolPtr
storagePoolLookupByName(virConnectPtr conn,
const char *name)
{
- virStoragePoolObjPtr pool;
- virStoragePoolPtr ret = NULL;
+ virStoragePoolObjPtr obj;
+ virStoragePoolPtr pool = NULL;
- if (!(pool = storagePoolObjFindByName(name)))
+ if (!(obj = storagePoolObjFindByName(name)))
return NULL;
- if (virStoragePoolLookupByNameEnsureACL(conn, pool->def) < 0)
+ if (virStoragePoolLookupByNameEnsureACL(conn, obj->def) < 0)
goto cleanup;
- ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,
- NULL, NULL);
+ pool = virGetStoragePool(conn, obj->def->name, obj->def->uuid, NULL,
NULL);
cleanup:
- virStoragePoolObjUnlock(pool);
- return ret;
+ virStoragePoolObjUnlock(obj);
+ return pool;
}
static virStoragePoolPtr
storagePoolLookupByVolume(virStorageVolPtr vol)
{
- virStoragePoolObjPtr pool;
- virStoragePoolPtr ret = NULL;
+ virStoragePoolObjPtr obj;
+ virStoragePoolPtr pool = NULL;
- if (!(pool = storagePoolObjFindByName(vol->pool)))
+ if (!(obj = storagePoolObjFindByName(vol->pool)))
return NULL;
- if (virStoragePoolLookupByVolumeEnsureACL(vol->conn, pool->def) < 0)
+ if (virStoragePoolLookupByVolumeEnsureACL(vol->conn, obj->def) < 0)
goto cleanup;
- ret = virGetStoragePool(vol->conn, pool->def->name, pool->def->uuid,
- NULL, NULL);
+ pool = virGetStoragePool(vol->conn, obj->def->name, obj->def->uuid,
+ NULL, NULL);
cleanup:
- virStoragePoolObjUnlock(pool);
- return ret;
+ virStoragePoolObjUnlock(obj);
+ return pool;
}
static int
@@ -613,7 +611,8 @@ storageConnectFindStoragePoolSources(virConnectPtr conn,
}
-static int storagePoolIsActive(virStoragePoolPtr pool)
+static int
+storagePoolIsActive(virStoragePoolPtr pool)
{
virStoragePoolObjPtr obj;
int ret = -1;
@@ -631,7 +630,9 @@ static int storagePoolIsActive(virStoragePoolPtr pool)
return ret;
}
-static int storagePoolIsPersistent(virStoragePoolPtr pool)
+
+static int
+storagePoolIsPersistent(virStoragePoolPtr pool)
{
virStoragePoolObjPtr obj;
int ret = -1;
@@ -656,8 +657,8 @@ storagePoolCreateXML(virConnectPtr conn,
unsigned int flags)
{
virStoragePoolDefPtr def;
- virStoragePoolObjPtr pool = NULL;
- virStoragePoolPtr ret = NULL;
+ virStoragePoolObjPtr obj = NULL;
+ virStoragePoolPtr pool = NULL;
virStorageBackendPtr backend;
virObjectEventPtr event = NULL;
char *stateFile = NULL;
@@ -686,7 +687,7 @@ storagePoolCreateXML(virConnectPtr conn,
if ((backend = virStorageBackendForType(def->type)) == NULL)
goto cleanup;
- if (!(pool = virStoragePoolObjAssignDef(&driver->pools, def)))
+ if (!(obj = virStoragePoolObjAssignDef(&driver->pools, def)))
goto cleanup;
def = NULL;
@@ -698,56 +699,55 @@ storagePoolCreateXML(virConnectPtr conn,
if (build_flags ||
(flags & VIR_STORAGE_POOL_CREATE_WITH_BUILD)) {
- if (backend->buildPool(conn, pool, build_flags) < 0) {
- virStoragePoolObjRemove(&driver->pools, pool);
- pool = NULL;
+ if (backend->buildPool(conn, obj, build_flags) < 0) {
+ virStoragePoolObjRemove(&driver->pools, obj);
+ obj = NULL;
goto cleanup;
}
}
}
if (backend->startPool &&
- backend->startPool(conn, pool) < 0) {
- virStoragePoolObjRemove(&driver->pools, pool);
- pool = NULL;
+ backend->startPool(conn, obj) < 0) {
+ virStoragePoolObjRemove(&driver->pools, obj);
+ obj = NULL;
goto cleanup;
}
stateFile = virFileBuildPath(driver->stateDir,
- pool->def->name, ".xml");
+ obj->def->name, ".xml");
- virStoragePoolObjClearVols(pool);
- if (!stateFile || virStoragePoolSaveState(stateFile, pool->def) < 0 ||
- backend->refreshPool(conn, pool) < 0) {
+ virStoragePoolObjClearVols(obj);
+ if (!stateFile || virStoragePoolSaveState(stateFile, obj->def) < 0 ||
+ backend->refreshPool(conn, obj) < 0) {
if (stateFile)
unlink(stateFile);
if (backend->stopPool)
- backend->stopPool(conn, pool);
- virStoragePoolObjRemove(&driver->pools, pool);
- pool = NULL;
+ backend->stopPool(conn, obj);
+ virStoragePoolObjRemove(&driver->pools, obj);
+ obj = NULL;
goto cleanup;
}
- event = virStoragePoolEventLifecycleNew(pool->def->name,
- pool->def->uuid,
+ event = virStoragePoolEventLifecycleNew(obj->def->name,
+ obj->def->uuid,
VIR_STORAGE_POOL_EVENT_STARTED,
0);
- VIR_INFO("Creating storage pool '%s'", pool->def->name);
- pool->active = true;
+ VIR_INFO("Creating storage pool '%s'", obj->def->name);
+ obj->active = true;
- ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,
- NULL, NULL);
+ pool = virGetStoragePool(conn, obj->def->name, obj->def->uuid, NULL,
NULL);
cleanup:
VIR_FREE(stateFile);
virStoragePoolDefFree(def);
if (event)
virObjectEventStateQueue(driver->storageEventState, event);
- if (pool)
- virStoragePoolObjUnlock(pool);
+ if (obj)
+ virStoragePoolObjUnlock(obj);
storageDriverUnlock();
- return ret;
+ return pool;
}
static virStoragePoolPtr
@@ -756,8 +756,8 @@ storagePoolDefineXML(virConnectPtr conn,
unsigned int flags)
{
virStoragePoolDefPtr def;
- virStoragePoolObjPtr pool = NULL;
- virStoragePoolPtr ret = NULL;
+ virStoragePoolObjPtr obj = NULL;
+ virStoragePoolPtr pool = NULL;
virObjectEventPtr event = NULL;
virCheckFlags(0, NULL);
@@ -781,13 +781,13 @@ storagePoolDefineXML(virConnectPtr conn,
if (virStorageBackendForType(def->type) == NULL)
goto cleanup;
- if (!(pool = virStoragePoolObjAssignDef(&driver->pools, def)))
+ if (!(obj = virStoragePoolObjAssignDef(&driver->pools, def)))
goto cleanup;
- if (virStoragePoolObjSaveDef(driver, pool, def) < 0) {
- virStoragePoolObjRemove(&driver->pools, pool);
+ if (virStoragePoolObjSaveDef(driver, obj, def) < 0) {
+ virStoragePoolObjRemove(&driver->pools, obj);
def = NULL;
- pool = NULL;
+ obj = NULL;
goto cleanup;
}
@@ -797,86 +797,85 @@ storagePoolDefineXML(virConnectPtr conn,
def = NULL;
- VIR_INFO("Defining storage pool '%s'", pool->def->name);
- ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,
- NULL, NULL);
+ VIR_INFO("Defining storage pool '%s'", obj->def->name);
+ pool = virGetStoragePool(conn, obj->def->name, obj->def->uuid, NULL,
NULL);
cleanup:
if (event)
virObjectEventStateQueue(driver->storageEventState, event);
virStoragePoolDefFree(def);
- if (pool)
- virStoragePoolObjUnlock(pool);
+ if (obj)
+ virStoragePoolObjUnlock(obj);
storageDriverUnlock();
- return ret;
+ return pool;
}
static int
-storagePoolUndefine(virStoragePoolPtr obj)
+storagePoolUndefine(virStoragePoolPtr pool)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virObjectEventPtr event = NULL;
int ret = -1;
storageDriverLock();
- if (!(pool = storagePoolObjFindByUUID(obj->uuid, obj->name)))
+ if (!(obj = storagePoolObjFindByUUID(pool->uuid, pool->name)))
goto cleanup;
- if (virStoragePoolUndefineEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolUndefineEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if (virStoragePoolObjIsActive(pool)) {
+ if (virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("storage pool '%s' is still active"),
- pool->def->name);
+ obj->def->name);
goto cleanup;
}
- if (pool->asyncjobs > 0) {
+ if (obj->asyncjobs > 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("pool '%s' has asynchronous jobs running."),
- pool->def->name);
+ obj->def->name);
goto cleanup;
}
- if (virStoragePoolObjDeleteDef(pool) < 0)
+ if (virStoragePoolObjDeleteDef(obj) < 0)
goto cleanup;
- if (unlink(pool->autostartLink) < 0 &&
+ if (unlink(obj->autostartLink) < 0 &&
errno != ENOENT &&
errno != ENOTDIR) {
char ebuf[1024];
VIR_ERROR(_("Failed to delete autostart link '%s': %s"),
- pool->autostartLink, virStrerror(errno, ebuf, sizeof(ebuf)));
+ obj->autostartLink, virStrerror(errno, ebuf, sizeof(ebuf)));
}
- VIR_FREE(pool->configFile);
- VIR_FREE(pool->autostartLink);
+ VIR_FREE(obj->configFile);
+ VIR_FREE(obj->autostartLink);
- event = virStoragePoolEventLifecycleNew(pool->def->name,
- pool->def->uuid,
+ event = virStoragePoolEventLifecycleNew(obj->def->name,
+ obj->def->uuid,
VIR_STORAGE_POOL_EVENT_UNDEFINED,
0);
- VIR_INFO("Undefining storage pool '%s'", pool->def->name);
- virStoragePoolObjRemove(&driver->pools, pool);
- pool = NULL;
+ VIR_INFO("Undefining storage pool '%s'", obj->def->name);
+ virStoragePoolObjRemove(&driver->pools, obj);
+ obj = NULL;
ret = 0;
cleanup:
if (event)
virObjectEventStateQueue(driver->storageEventState, event);
- if (pool)
- virStoragePoolObjUnlock(pool);
+ if (obj)
+ virStoragePoolObjUnlock(obj);
storageDriverUnlock();
return ret;
}
static int
-storagePoolCreate(virStoragePoolPtr obj,
+storagePoolCreate(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virStorageBackendPtr backend;
virObjectEventPtr event = NULL;
int ret = -1;
@@ -890,19 +889,19 @@ storagePoolCreate(virStoragePoolPtr obj,
VIR_EXCLUSIVE_FLAGS_RET(VIR_STORAGE_POOL_BUILD_OVERWRITE,
VIR_STORAGE_POOL_BUILD_NO_OVERWRITE, -1);
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return -1;
- if (virStoragePoolCreateEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolCreateEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
+ if ((backend = virStorageBackendForType(obj->def->type)) == NULL)
goto cleanup;
- if (virStoragePoolObjIsActive(pool)) {
+ if (virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("storage pool '%s' is already active"),
- pool->def->name);
+ obj->def->name);
goto cleanup;
}
@@ -914,117 +913,117 @@ storagePoolCreate(virStoragePoolPtr obj,
if (build_flags ||
(flags & VIR_STORAGE_POOL_CREATE_WITH_BUILD)) {
- if (backend->buildPool(obj->conn, pool, build_flags) < 0)
+ if (backend->buildPool(pool->conn, obj, build_flags) < 0)
goto cleanup;
}
}
- VIR_INFO("Starting up storage pool '%s'", pool->def->name);
+ VIR_INFO("Starting up storage pool '%s'", obj->def->name);
if (backend->startPool &&
- backend->startPool(obj->conn, pool) < 0)
+ backend->startPool(pool->conn, obj) < 0)
goto cleanup;
stateFile = virFileBuildPath(driver->stateDir,
- pool->def->name, ".xml");
+ obj->def->name, ".xml");
- virStoragePoolObjClearVols(pool);
- if (!stateFile || virStoragePoolSaveState(stateFile, pool->def) < 0 ||
- backend->refreshPool(obj->conn, pool) < 0) {
+ virStoragePoolObjClearVols(obj);
+ if (!stateFile || virStoragePoolSaveState(stateFile, obj->def) < 0 ||
+ backend->refreshPool(pool->conn, obj) < 0) {
if (stateFile)
unlink(stateFile);
if (backend->stopPool)
- backend->stopPool(obj->conn, pool);
+ backend->stopPool(pool->conn, obj);
goto cleanup;
}
- event = virStoragePoolEventLifecycleNew(pool->def->name,
- pool->def->uuid,
+ event = virStoragePoolEventLifecycleNew(obj->def->name,
+ obj->def->uuid,
VIR_STORAGE_POOL_EVENT_STARTED,
0);
- pool->active = true;
+ obj->active = true;
ret = 0;
cleanup:
VIR_FREE(stateFile);
if (event)
virObjectEventStateQueue(driver->storageEventState, event);
- if (pool)
- virStoragePoolObjUnlock(pool);
+ if (obj)
+ virStoragePoolObjUnlock(obj);
return ret;
}
static int
-storagePoolBuild(virStoragePoolPtr obj,
+storagePoolBuild(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virStorageBackendPtr backend;
int ret = -1;
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return -1;
- if (virStoragePoolBuildEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolBuildEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
+ if ((backend = virStorageBackendForType(obj->def->type)) == NULL)
goto cleanup;
- if (virStoragePoolObjIsActive(pool)) {
+ if (virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("storage pool '%s' is already active"),
- pool->def->name);
+ obj->def->name);
goto cleanup;
}
if (backend->buildPool &&
- backend->buildPool(obj->conn, pool, flags) < 0)
+ backend->buildPool(pool->conn, obj, flags) < 0)
goto cleanup;
ret = 0;
cleanup:
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
return ret;
}
static int
-storagePoolDestroy(virStoragePoolPtr obj)
+storagePoolDestroy(virStoragePoolPtr pool)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virStorageBackendPtr backend;
virObjectEventPtr event = NULL;
char *stateFile = NULL;
int ret = -1;
storageDriverLock();
- if (!(pool = storagePoolObjFindByUUID(obj->uuid, obj->name)))
+ if (!(obj = storagePoolObjFindByUUID(pool->uuid, pool->name)))
goto cleanup;
- if (virStoragePoolDestroyEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolDestroyEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
+ if ((backend = virStorageBackendForType(obj->def->type)) == NULL)
goto cleanup;
- VIR_INFO("Destroying storage pool '%s'", pool->def->name);
+ VIR_INFO("Destroying storage pool '%s'", obj->def->name);
- if (!virStoragePoolObjIsActive(pool)) {
+ if (!virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
- _("storage pool '%s' is not active"),
pool->def->name);
+ _("storage pool '%s' is not active"),
obj->def->name);
goto cleanup;
}
- if (pool->asyncjobs > 0) {
+ if (obj->asyncjobs > 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("pool '%s' has asynchronous jobs running."),
- pool->def->name);
+ obj->def->name);
goto cleanup;
}
if (!(stateFile = virFileBuildPath(driver->stateDir,
- pool->def->name,
+ obj->def->name,
".xml")))
goto cleanup;
@@ -1032,67 +1031,67 @@ storagePoolDestroy(virStoragePoolPtr obj)
VIR_FREE(stateFile);
if (backend->stopPool &&
- backend->stopPool(obj->conn, pool) < 0)
+ backend->stopPool(pool->conn, obj) < 0)
goto cleanup;
- virStoragePoolObjClearVols(pool);
+ virStoragePoolObjClearVols(obj);
- event = virStoragePoolEventLifecycleNew(pool->def->name,
- pool->def->uuid,
+ event = virStoragePoolEventLifecycleNew(obj->def->name,
+ obj->def->uuid,
VIR_STORAGE_POOL_EVENT_STOPPED,
0);
- pool->active = false;
+ obj->active = false;
- virStoragePoolUpdateInactive(&pool);
+ virStoragePoolUpdateInactive(&obj);
ret = 0;
cleanup:
if (event)
virObjectEventStateQueue(driver->storageEventState, event);
- if (pool)
- virStoragePoolObjUnlock(pool);
+ if (obj)
+ virStoragePoolObjUnlock(obj);
storageDriverUnlock();
return ret;
}
static int
-storagePoolDelete(virStoragePoolPtr obj,
+storagePoolDelete(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virStorageBackendPtr backend;
char *stateFile = NULL;
int ret = -1;
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return -1;
- if (virStoragePoolDeleteEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolDeleteEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
+ if ((backend = virStorageBackendForType(obj->def->type)) == NULL)
goto cleanup;
- VIR_INFO("Deleting storage pool '%s'", pool->def->name);
+ VIR_INFO("Deleting storage pool '%s'", obj->def->name);
- if (virStoragePoolObjIsActive(pool)) {
+ if (virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("storage pool '%s' is still active"),
- pool->def->name);
+ obj->def->name);
goto cleanup;
}
- if (pool->asyncjobs > 0) {
+ if (obj->asyncjobs > 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("pool '%s' has asynchronous jobs running."),
- pool->def->name);
+ obj->def->name);
goto cleanup;
}
if (!(stateFile = virFileBuildPath(driver->stateDir,
- pool->def->name,
+ obj->def->name,
".xml")))
goto cleanup;
@@ -1104,22 +1103,22 @@ storagePoolDelete(virStoragePoolPtr obj,
"%s", _("pool does not support pool
deletion"));
goto cleanup;
}
- if (backend->deletePool(obj->conn, pool, flags) < 0)
+ if (backend->deletePool(pool->conn, obj, flags) < 0)
goto cleanup;
ret = 0;
cleanup:
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
return ret;
}
static int
-storagePoolRefresh(virStoragePoolPtr obj,
+storagePoolRefresh(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virStorageBackendPtr backend;
int ret = -1;
virObjectEventPtr event = NULL;
@@ -1127,165 +1126,165 @@ storagePoolRefresh(virStoragePoolPtr obj,
virCheckFlags(0, -1);
storageDriverLock();
- if (!(pool = storagePoolObjFindByUUID(obj->uuid, obj->name)))
+ if (!(obj = storagePoolObjFindByUUID(pool->uuid, pool->name)))
goto cleanup;
- if (virStoragePoolRefreshEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolRefreshEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
+ if ((backend = virStorageBackendForType(obj->def->type)) == NULL)
goto cleanup;
- if (!virStoragePoolObjIsActive(pool)) {
+ if (!virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
- _("storage pool '%s' is not active"),
pool->def->name);
+ _("storage pool '%s' is not active"),
obj->def->name);
goto cleanup;
}
- if (pool->asyncjobs > 0) {
+ if (obj->asyncjobs > 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("pool '%s' has asynchronous jobs running."),
- pool->def->name);
+ obj->def->name);
goto cleanup;
}
- virStoragePoolObjClearVols(pool);
- if (backend->refreshPool(obj->conn, pool) < 0) {
+ virStoragePoolObjClearVols(obj);
+ if (backend->refreshPool(pool->conn, obj) < 0) {
if (backend->stopPool)
- backend->stopPool(obj->conn, pool);
+ backend->stopPool(pool->conn, obj);
- event = virStoragePoolEventLifecycleNew(pool->def->name,
- pool->def->uuid,
+ event = virStoragePoolEventLifecycleNew(obj->def->name,
+ obj->def->uuid,
VIR_STORAGE_POOL_EVENT_STOPPED,
0);
- pool->active = false;
+ obj->active = false;
- virStoragePoolUpdateInactive(&pool);
+ virStoragePoolUpdateInactive(&obj);
goto cleanup;
}
- event = virStoragePoolEventRefreshNew(pool->def->name,
- pool->def->uuid);
+ event = virStoragePoolEventRefreshNew(obj->def->name,
+ obj->def->uuid);
ret = 0;
cleanup:
if (event)
virObjectEventStateQueue(driver->storageEventState, event);
- if (pool)
- virStoragePoolObjUnlock(pool);
+ if (obj)
+ virStoragePoolObjUnlock(obj);
storageDriverUnlock();
return ret;
}
static int
-storagePoolGetInfo(virStoragePoolPtr obj,
+storagePoolGetInfo(virStoragePoolPtr pool,
virStoragePoolInfoPtr info)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
int ret = -1;
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return -1;
- if (virStoragePoolGetInfoEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolGetInfoEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if (virStorageBackendForType(pool->def->type) == NULL)
+ if (virStorageBackendForType(obj->def->type) == NULL)
goto cleanup;
memset(info, 0, sizeof(virStoragePoolInfo));
- if (pool->active)
+ if (obj->active)
info->state = VIR_STORAGE_POOL_RUNNING;
else
info->state = VIR_STORAGE_POOL_INACTIVE;
- info->capacity = pool->def->capacity;
- info->allocation = pool->def->allocation;
- info->available = pool->def->available;
+ info->capacity = obj->def->capacity;
+ info->allocation = obj->def->allocation;
+ info->available = obj->def->available;
ret = 0;
cleanup:
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
return ret;
}
static char *
-storagePoolGetXMLDesc(virStoragePoolPtr obj,
+storagePoolGetXMLDesc(virStoragePoolPtr pool,
unsigned int flags)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virStoragePoolDefPtr def;
char *ret = NULL;
virCheckFlags(VIR_STORAGE_XML_INACTIVE, NULL);
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return NULL;
- if (virStoragePoolGetXMLDescEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolGetXMLDescEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if ((flags & VIR_STORAGE_XML_INACTIVE) && pool->newDef)
- def = pool->newDef;
+ if ((flags & VIR_STORAGE_XML_INACTIVE) && obj->newDef)
+ def = obj->newDef;
else
- def = pool->def;
+ def = obj->def;
ret = virStoragePoolDefFormat(def);
cleanup:
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
return ret;
}
static int
-storagePoolGetAutostart(virStoragePoolPtr obj,
+storagePoolGetAutostart(virStoragePoolPtr pool,
int *autostart)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
int ret = -1;
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return -1;
- if (virStoragePoolGetAutostartEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolGetAutostartEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if (!pool->configFile) {
+ if (!obj->configFile) {
*autostart = 0;
} else {
- *autostart = pool->autostart;
+ *autostart = obj->autostart;
}
+
ret = 0;
cleanup:
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
return ret;
}
static int
-storagePoolSetAutostart(virStoragePoolPtr obj,
+storagePoolSetAutostart(virStoragePoolPtr pool,
int autostart)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
int ret = -1;
storageDriverLock();
- if (!(pool = storagePoolObjFindByUUID(obj->uuid, obj->name)))
+ if (!(obj = storagePoolObjFindByUUID(pool->uuid, pool->name)))
goto cleanup;
- if (virStoragePoolSetAutostartEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolSetAutostartEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if (!pool->configFile) {
+ if (!obj->configFile) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("pool has no config file"));
- goto cleanup;
}
autostart = (autostart != 0);
- if (pool->autostart != autostart) {
+ if (obj->autostart != autostart) {
if (autostart) {
if (virFileMakePath(driver->autostartDir) < 0) {
virReportSystemError(errno,
@@ -1294,85 +1293,86 @@ storagePoolSetAutostart(virStoragePoolPtr obj,
goto cleanup;
}
- if (symlink(pool->configFile, pool->autostartLink) < 0) {
+ if (symlink(obj->configFile, obj->autostartLink) < 0) {
virReportSystemError(errno,
_("Failed to create symlink '%s' to
'%s'"),
- pool->autostartLink, pool->configFile);
+ obj->autostartLink, obj->configFile);
goto cleanup;
}
} else {
- if (unlink(pool->autostartLink) < 0 &&
+ if (unlink(obj->autostartLink) < 0 &&
errno != ENOENT && errno != ENOTDIR) {
virReportSystemError(errno,
_("Failed to delete symlink
'%s'"),
- pool->autostartLink);
+ obj->autostartLink);
goto cleanup;
}
}
- pool->autostart = autostart;
+ obj->autostart = autostart;
}
+
ret = 0;
cleanup:
- if (pool)
- virStoragePoolObjUnlock(pool);
+ if (obj)
+ virStoragePoolObjUnlock(obj);
storageDriverUnlock();
return ret;
}
static int
-storagePoolNumOfVolumes(virStoragePoolPtr obj)
+storagePoolNumOfVolumes(virStoragePoolPtr pool)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
int ret = -1;
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return -1;
- if (virStoragePoolNumOfVolumesEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolNumOfVolumesEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if (!virStoragePoolObjIsActive(pool)) {
+ if (!virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
- _("storage pool '%s' is not active"),
pool->def->name);
+ _("storage pool '%s' is not active"),
obj->def->name);
goto cleanup;
}
- ret = virStoragePoolObjNumOfVolumes(&pool->volumes, obj->conn,
pool->def,
+ ret = virStoragePoolObjNumOfVolumes(&obj->volumes, pool->conn,
obj->def,
virStoragePoolNumOfVolumesCheckACL);
cleanup:
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
return ret;
}
static int
-storagePoolListVolumes(virStoragePoolPtr obj,
+storagePoolListVolumes(virStoragePoolPtr pool,
char **const names,
int maxnames)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
int n = -1;
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return -1;
- if (virStoragePoolListVolumesEnsureACL(obj->conn, pool->def) < 0)
+ if (virStoragePoolListVolumesEnsureACL(pool->conn, obj->def) < 0)
goto cleanup;
- if (!virStoragePoolObjIsActive(pool)) {
+ if (!virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
- _("storage pool '%s' is not active"),
pool->def->name);
+ _("storage pool '%s' is not active"),
obj->def->name);
goto cleanup;
}
- n = virStoragePoolObjVolumeGetNames(&pool->volumes, obj->conn,
pool->def,
+ n = virStoragePoolObjVolumeGetNames(&obj->volumes, pool->conn,
obj->def,
virStoragePoolListVolumesCheckACL,
names, maxnames);
cleanup:
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
return n;
}
@@ -1411,40 +1411,40 @@ storagePoolListAllVolumes(virStoragePoolPtr pool,
}
static virStorageVolPtr
-storageVolLookupByName(virStoragePoolPtr obj,
+storageVolLookupByName(virStoragePoolPtr pool,
const char *name)
{
- virStoragePoolObjPtr pool;
- virStorageVolDefPtr vol;
- virStorageVolPtr ret = NULL;
+ virStoragePoolObjPtr obj;
+ virStorageVolDefPtr voldef;
+ virStorageVolPtr vol = NULL;
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return NULL;
- if (!virStoragePoolObjIsActive(pool)) {
+ if (!virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
- _("storage pool '%s' is not active"),
pool->def->name);
+ _("storage pool '%s' is not active"),
obj->def->name);
goto cleanup;
}
- vol = virStorageVolDefFindByName(pool, name);
+ voldef = virStorageVolDefFindByName(obj, name);
- if (!vol) {
+ if (!voldef) {
virReportError(VIR_ERR_NO_STORAGE_VOL,
_("no storage vol with matching name '%s'"),
name);
goto cleanup;
}
- if (virStorageVolLookupByNameEnsureACL(obj->conn, pool->def, vol) < 0)
+ if (virStorageVolLookupByNameEnsureACL(pool->conn, obj->def, voldef) < 0)
goto cleanup;
- ret = virGetStorageVol(obj->conn, pool->def->name, vol->name,
vol->key,
- NULL, NULL);
+ vol = virGetStorageVol(pool->conn, obj->def->name, voldef->name,
+ voldef->key, NULL, NULL);
cleanup:
- virStoragePoolObjUnlock(pool);
- return ret;
+ virStoragePoolObjUnlock(obj);
+ return vol;
}
@@ -1453,39 +1453,39 @@ storageVolLookupByKey(virConnectPtr conn,
const char *key)
{
size_t i;
- virStorageVolPtr ret = NULL;
+ virStorageVolPtr vol = NULL;
storageDriverLock();
- for (i = 0; i < driver->pools.count && !ret; i++) {
+ for (i = 0; i < driver->pools.count && !vol; i++) {
virStoragePoolObjLock(driver->pools.objs[i]);
if (virStoragePoolObjIsActive(driver->pools.objs[i])) {
- virStorageVolDefPtr vol =
+ virStorageVolDefPtr voldef =
virStorageVolDefFindByKey(driver->pools.objs[i], key);
- if (vol) {
+ if (voldef) {
virStoragePoolDefPtr def = driver->pools.objs[i]->def;
- if (virStorageVolLookupByKeyEnsureACL(conn, def, vol) < 0) {
+ if (virStorageVolLookupByKeyEnsureACL(conn, def, voldef) < 0) {
virStoragePoolObjUnlock(driver->pools.objs[i]);
goto cleanup;
}
- ret = virGetStorageVol(conn,
+ vol = virGetStorageVol(conn,
def->name,
- vol->name,
- vol->key,
+ voldef->name,
+ voldef->key,
NULL, NULL);
}
}
virStoragePoolObjUnlock(driver->pools.objs[i]);
}
- if (!ret)
+ if (!vol)
virReportError(VIR_ERR_NO_STORAGE_VOL,
_("no storage vol with matching key %s"), key);
cleanup:
storageDriverUnlock();
- return ret;
+ return vol;
}
static virStorageVolPtr
@@ -1493,7 +1493,7 @@ storageVolLookupByPath(virConnectPtr conn,
const char *path)
{
size_t i;
- virStorageVolPtr ret = NULL;
+ virStorageVolPtr vol = NULL;
char *cleanpath;
cleanpath = virFileSanitizePath(path);
@@ -1501,19 +1501,19 @@ storageVolLookupByPath(virConnectPtr conn,
return NULL;
storageDriverLock();
- for (i = 0; i < driver->pools.count && !ret; i++) {
- virStoragePoolObjPtr pool = driver->pools.objs[i];
- virStorageVolDefPtr vol;
+ for (i = 0; i < driver->pools.count && !vol; i++) {
+ virStoragePoolObjPtr obj = driver->pools.objs[i];
+ virStorageVolDefPtr voldef;
char *stable_path = NULL;
- virStoragePoolObjLock(pool);
+ virStoragePoolObjLock(obj);
- if (!virStoragePoolObjIsActive(pool)) {
- virStoragePoolObjUnlock(pool);
+ if (!virStoragePoolObjIsActive(obj)) {
+ virStoragePoolObjUnlock(obj);
continue;
}
- switch ((virStoragePoolType) pool->def->type) {
+ switch ((virStoragePoolType) obj->def->type) {
case VIR_STORAGE_POOL_DIR:
case VIR_STORAGE_POOL_FS:
case VIR_STORAGE_POOL_NETFS:
@@ -1523,7 +1523,7 @@ storageVolLookupByPath(virConnectPtr conn,
case VIR_STORAGE_POOL_SCSI:
case VIR_STORAGE_POOL_MPATH:
case VIR_STORAGE_POOL_VSTORAGE:
- stable_path = virStorageBackendStablePath(pool,
+ stable_path = virStorageBackendStablePath(obj,
cleanpath,
false);
if (stable_path == NULL) {
@@ -1531,8 +1531,8 @@ storageVolLookupByPath(virConnectPtr conn,
* getting the stable path for some of the pools.
*/
VIR_WARN("Failed to get stable path for pool
'%s'",
- pool->def->name);
- virStoragePoolObjUnlock(pool);
+ obj->def->name);
+ virStoragePoolObjUnlock(obj);
continue;
}
break;
@@ -1543,30 +1543,30 @@ storageVolLookupByPath(virConnectPtr conn,
case VIR_STORAGE_POOL_ZFS:
case VIR_STORAGE_POOL_LAST:
if (VIR_STRDUP(stable_path, path) < 0) {
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
goto cleanup;
}
break;
}
- vol = virStorageVolDefFindByPath(pool, stable_path);
+ voldef = virStorageVolDefFindByPath(obj, stable_path);
VIR_FREE(stable_path);
- if (vol) {
- if (virStorageVolLookupByPathEnsureACL(conn, pool->def, vol) < 0) {
- virStoragePoolObjUnlock(pool);
+ if (voldef) {
+ if (virStorageVolLookupByPathEnsureACL(conn, obj->def, voldef) < 0) {
+ virStoragePoolObjUnlock(obj);
goto cleanup;
}
- ret = virGetStorageVol(conn, pool->def->name,
- vol->name, vol->key,
+ vol = virGetStorageVol(conn, obj->def->name,
+ voldef->name, voldef->key,
NULL, NULL);
}
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
}
- if (!ret) {
+ if (!vol) {
if (STREQ(path, cleanpath)) {
virReportError(VIR_ERR_NO_STORAGE_VOL,
_("no storage vol with matching path
'%s'"), path);
@@ -1580,7 +1580,7 @@ storageVolLookupByPath(virConnectPtr conn,
cleanup:
VIR_FREE(cleanpath);
storageDriverUnlock();
- return ret;
+ return vol;
}
virStoragePoolPtr
@@ -1588,7 +1588,7 @@ storagePoolLookupByTargetPath(virConnectPtr conn,
const char *path)
{
size_t i;
- virStoragePoolPtr ret = NULL;
+ virStoragePoolPtr pool = NULL;
char *cleanpath;
cleanpath = virFileSanitizePath(path);
@@ -1596,49 +1596,49 @@ storagePoolLookupByTargetPath(virConnectPtr conn,
return NULL;
storageDriverLock();
- for (i = 0; i < driver->pools.count && !ret; i++) {
- virStoragePoolObjPtr pool = driver->pools.objs[i];
+ for (i = 0; i < driver->pools.count && !pool; i++) {
+ virStoragePoolObjPtr obj = driver->pools.objs[i];
- virStoragePoolObjLock(pool);
+ virStoragePoolObjLock(obj);
- if (!virStoragePoolObjIsActive(pool)) {
- virStoragePoolObjUnlock(pool);
+ if (!virStoragePoolObjIsActive(obj)) {
+ virStoragePoolObjUnlock(obj);
continue;
}
- if (STREQ(path, pool->def->target.path)) {
- ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,
- NULL, NULL);
+ if (STREQ(path, obj->def->target.path)) {
+ pool = virGetStoragePool(conn, obj->def->name, obj->def->uuid,
+ NULL, NULL);
}
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
}
storageDriverUnlock();
- if (!ret) {
+ if (!pool) {
virReportError(VIR_ERR_NO_STORAGE_VOL,
_("no storage pool with matching target path
'%s'"),
path);
}
VIR_FREE(cleanpath);
- return ret;
+ return pool;
}
static void
-storageVolRemoveFromPool(virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol)
+storageVolRemoveFromPool(virStoragePoolObjPtr obj,
+ virStorageVolDefPtr voldef)
{
size_t i;
- for (i = 0; i < pool->volumes.count; i++) {
- if (pool->volumes.objs[i] == vol) {
+ for (i = 0; i < obj->volumes.count; i++) {
+ if (obj->volumes.objs[i] == voldef) {
VIR_INFO("Deleting volume '%s' from storage pool
'%s'",
- vol->name, pool->def->name);
- virStorageVolDefFree(vol);
+ voldef->name, obj->def->name);
+ virStorageVolDefFree(voldef);
- VIR_DELETE_ELEMENT(pool->volumes.objs, i, pool->volumes.count);
+ VIR_DELETE_ELEMENT(obj->volumes.objs, i, obj->volumes.count);
break;
}
}
@@ -1646,10 +1646,10 @@ storageVolRemoveFromPool(virStoragePoolObjPtr pool,
static int
-storageVolDeleteInternal(virStorageVolPtr obj,
+storageVolDeleteInternal(virStorageVolPtr vol,
virStorageBackendPtr backend,
- virStoragePoolObjPtr pool,
- virStorageVolDefPtr vol,
+ virStoragePoolObjPtr obj,
+ virStorageVolDefPtr voldef,
unsigned int flags,
bool updateMeta)
{
@@ -1662,7 +1662,7 @@ storageVolDeleteInternal(virStorageVolPtr obj,
goto cleanup;
}
- if (backend->deleteVol(obj->conn, pool, vol, flags) < 0)
+ if (backend->deleteVol(vol->conn, obj, voldef, flags) < 0)
goto cleanup;
/* Update pool metadata - don't update meta data from error paths
@@ -1670,13 +1670,13 @@ storageVolDeleteInternal(virStorageVolPtr obj,
* Ignore the disk backend since it updates the pool values.
*/
if (updateMeta) {
- if (pool->def->type != VIR_STORAGE_POOL_DISK) {
- pool->def->allocation -= vol->target.allocation;
- pool->def->available += vol->target.allocation;
+ if (obj->def->type != VIR_STORAGE_POOL_DISK) {
+ obj->def->allocation -= voldef->target.allocation;
+ obj->def->available += voldef->target.allocation;
}
}
- storageVolRemoveFromPool(pool, vol);
+ storageVolRemoveFromPool(obj, voldef);
ret = 0;
cleanup:
@@ -1685,109 +1685,109 @@ storageVolDeleteInternal(virStorageVolPtr obj,
static virStorageVolDefPtr
-virStorageVolDefFromVol(virStorageVolPtr obj,
- virStoragePoolObjPtr *pool,
+virStorageVolDefFromVol(virStorageVolPtr vol,
+ virStoragePoolObjPtr *obj,
virStorageBackendPtr *backend)
{
- virStorageVolDefPtr vol = NULL;
+ virStorageVolDefPtr voldef = NULL;
- if (!(*pool = storagePoolObjFindByName(obj->pool)))
+ if (!(*obj = storagePoolObjFindByName(vol->pool)))
return NULL;
- if (!virStoragePoolObjIsActive(*pool)) {
+ if (!virStoragePoolObjIsActive(*obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("storage pool '%s' is not active"),
- (*pool)->def->name);
+ (*obj)->def->name);
goto error;
}
- if (!(vol = virStorageVolDefFindByName(*pool, obj->name))) {
+ if (!(voldef = virStorageVolDefFindByName(*obj, vol->name))) {
virReportError(VIR_ERR_NO_STORAGE_VOL,
_("no storage vol with matching name '%s'"),
- obj->name);
+ vol->name);
goto error;
}
if (backend) {
- if (!(*backend = virStorageBackendForType((*pool)->def->type)))
+ if (!(*backend = virStorageBackendForType((*obj)->def->type)))
goto error;
}
- return vol;
+ return voldef;
error:
- virStoragePoolObjUnlock(*pool);
- *pool = NULL;
+ virStoragePoolObjUnlock(*obj);
+ *obj = NULL;
return NULL;
}
static int
-storageVolDelete(virStorageVolPtr obj,
+storageVolDelete(virStorageVolPtr vol,
unsigned int flags)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virStorageBackendPtr backend;
- virStorageVolDefPtr vol = NULL;
+ virStorageVolDefPtr voldef = NULL;
int ret = -1;
- if (!(vol = virStorageVolDefFromVol(obj, &pool, &backend)))
+ if (!(voldef = virStorageVolDefFromVol(vol, &obj, &backend)))
return -1;
- if (virStorageVolDeleteEnsureACL(obj->conn, pool->def, vol) < 0)
+ if (virStorageVolDeleteEnsureACL(vol->conn, obj->def, voldef) < 0)
goto cleanup;
- if (vol->in_use) {
+ if (voldef->in_use) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("volume '%s' is still in use."),
- vol->name);
+ voldef->name);
goto cleanup;
}
- if (vol->building) {
+ if (voldef->building) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("volume '%s' is still being allocated."),
- vol->name);
+ voldef->name);
goto cleanup;
}
- if (storageVolDeleteInternal(obj, backend, pool, vol, flags, true) < 0)
+ if (storageVolDeleteInternal(vol, backend, obj, voldef, flags, true) < 0)
goto cleanup;
ret = 0;
cleanup:
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
return ret;
}
static virStorageVolPtr
-storageVolCreateXML(virStoragePoolPtr obj,
+storageVolCreateXML(virStoragePoolPtr pool,
const char *xmldesc,
unsigned int flags)
{
- virStoragePoolObjPtr pool;
+ virStoragePoolObjPtr obj;
virStorageBackendPtr backend;
virStorageVolDefPtr voldef = NULL;
- virStorageVolPtr ret = NULL, volobj = NULL;
+ virStorageVolPtr vol = NULL, volobj = NULL;
The @volobj should be also renamed, I would rename it like this:
@ret -> @vol
@volobj -> @newvol
and ...
virCheckFlags(VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA, NULL);
- if (!(pool = virStoragePoolObjFromStoragePool(obj)))
+ if (!(obj = virStoragePoolObjFromStoragePool(pool)))
return NULL;
- if (!virStoragePoolObjIsActive(pool)) {
+ if (!virStoragePoolObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_INVALID,
- _("storage pool '%s' is not active"),
pool->def->name);
+ _("storage pool '%s' is not active"),
obj->def->name);
goto cleanup;
}
- if ((backend = virStorageBackendForType(pool->def->type)) == NULL)
+ if ((backend = virStorageBackendForType(obj->def->type)) == NULL)
goto cleanup;
- voldef = virStorageVolDefParseString(pool->def, xmldesc,
+ voldef = virStorageVolDefParseString(obj->def, xmldesc,
VIR_VOL_XML_PARSE_OPT_CAPACITY);
if (voldef == NULL)
goto cleanup;
@@ -1799,10 +1799,10 @@ storageVolCreateXML(virStoragePoolPtr obj,
goto cleanup;
}
- if (virStorageVolCreateXMLEnsureACL(obj->conn, pool->def, voldef) < 0)
+ if (virStorageVolCreateXMLEnsureACL(pool->conn, obj->def, voldef) < 0)
goto cleanup;
- if (virStorageVolDefFindByName(pool, voldef->name)) {
+ if (virStorageVolDefFindByName(obj, voldef->name)) {
virReportError(VIR_ERR_STORAGE_VOL_EXIST,
_("'%s'"), voldef->name);
goto cleanup;
@@ -1815,21 +1815,21 @@ storageVolCreateXML(virStoragePoolPtr obj,
goto cleanup;
}
- if (VIR_REALLOC_N(pool->volumes.objs,
- pool->volumes.count+1) < 0)
+ if (VIR_REALLOC_N(obj->volumes.objs,
+ obj->volumes.count + 1) < 0)
goto cleanup;
/* Wipe any key the user may have suggested, as volume creation
* will generate the canonical key. */
VIR_FREE(voldef->key);
- if (backend->createVol(obj->conn, pool, voldef) < 0)
+ if (backend->createVol(pool->conn, obj, voldef) < 0)
goto cleanup;
- pool->volumes.objs[pool->volumes.count++] = voldef;
- volobj = virGetStorageVol(obj->conn, pool->def->name, voldef->name,
+ obj->volumes.objs[obj->volumes.count++] = voldef;
+ volobj = virGetStorageVol(pool->conn, obj->def->name, voldef->name,
voldef->key, NULL, NULL);
if (!volobj) {
- pool->volumes.count--;
+ obj->volumes.count--;
goto cleanup;
}
@@ -1850,24 +1850,24 @@ storageVolCreateXML(virStoragePoolPtr obj,
memcpy(buildvoldef, voldef, sizeof(*voldef));
/* Drop the pool lock during volume allocation */
- pool->asyncjobs++;
+ obj->asyncjobs++;
voldef->building = true;
- virStoragePoolObjUnlock(pool);
+ virStoragePoolObjUnlock(obj);
- buildret = backend->buildVol(obj->conn, pool, buildvoldef, flags);
+ buildret = backend->buildVol(pool->conn, obj, buildvoldef, flags);
VIR_FREE(buildvoldef);
storageDriverLock();
- virStoragePoolObjLock(pool);
+ virStoragePoolObjLock(obj);
storageDriverUnlock();
voldef->building = false;
- pool->asyncjobs--;
+ obj->asyncjobs--;
if (buildret < 0) {
/* buildVol handles deleting volume on failure */
- storageVolRemoveFromPool(pool, voldef);
+ storageVolRemoveFromPool(obj, voldef);
voldef = NULL;
goto cleanup;
}
@@ -1875,8 +1875,8 @@ storageVolCreateXML(virStoragePoolPtr obj,
}
if (backend->refreshVol &&
- backend->refreshVol(obj->conn, pool, voldef) < 0) {
- storageVolDeleteInternal(volobj, backend, pool, voldef,
+ backend->refreshVol(pool->conn, obj, voldef) < 0) {
+ storageVolDeleteInternal(volobj, backend, obj, voldef,
0, false);
voldef = NULL;
goto cleanup;
@@ -1885,35 +1885,39 @@ storageVolCreateXML(virStoragePoolPtr obj,
/* Update pool metadata ignoring the disk backend since
* it updates the pool values.
*/
- if (pool->def->type != VIR_STORAGE_POOL_DISK) {
- pool->def->allocation += voldef->target.allocation;
- pool->def->available -= voldef->target.allocation;
+ if (obj->def->type != VIR_STORAGE_POOL_DISK) {
+ obj->def->allocation += voldef->target.allocation;
+ obj->def->available -= voldef->target.allocation;
}
VIR_INFO("Creating volume '%s' in storage pool '%s'",
- volobj->name, pool->def->name);
- ret = volobj;
+ volobj->name, obj->def->name);
+ vol = volobj;
volobj = NULL;
voldef = NULL;
cleanup:
virObjectUnref(volobj);
virStorageVolDefFree(voldef);
- if (pool)
- virStoragePoolObjUnlock(pool);
- return ret;
+ if (obj)
+ virStoragePoolObjUnlock(obj);
+ return vol;
}
static virStorageVolPtr
-storageVolCreateXMLFrom(virStoragePoolPtr obj,
+storageVolCreateXMLFrom(virStoragePoolPtr pool,
const char *xmldesc,
- virStorageVolPtr vobj,
+ virStorageVolPtr volsrc,
unsigned int flags)
{
- virStoragePoolObjPtr pool, origpool = NULL;
+ virStoragePoolObjPtr obj;
+ virStoragePoolObjPtr objsrc = NULL;
virStorageBackendPtr backend;
- virStorageVolDefPtr origvol = NULL, newvol = NULL, shadowvol = NULL;
- virStorageVolPtr ret = NULL, volobj = NULL;
+ virStorageVolDefPtr voldefsrc = NULL;
+ virStorageVolDefPtr voldef = NULL;
+ virStorageVolDefPtr shadowvol = NULL;
+ virStorageVolPtr volobj = NULL;
+ virStorageVolPtr vol = NULL;
... same here.
Pavel