Re: [libvirt] [PATCH 08/19] storage: Use consistent variable names for driver

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@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