[libvirt] [PATCH RFC v3 13/15] FSPool: driver methods implementation

Friday, 2 December 2016

Signed-off-by: Olga Krishtal <okrishtal(a)virtuozzo.com&gt;
---
 src/fs/fs_driver.c | 1723 +++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 1515 insertions(+), 208 deletions(-)

diff --git a/src/fs/fs_driver.c b/src/fs/fs_driver.c
index 98d91fa..f913ce5 100644
--- a/src/fs/fs_driver.c
+++ b/src/fs/fs_driver.c
@@ -82,314 +82,1621 @@ virFSBackendForType(int type)
 }
 
 /* General fspool/item implementation */
+
 static int
-fsConnectListAllFSPools(virConnectPtr conn ATTRIBUTE_UNUSED,
-                        virFSPoolPtr **fspools ATTRIBUTE_UNUSED,
+fsConnectListAllFSPools(virConnectPtr conn,
+                        virFSPoolPtr **fspools,
                         unsigned int flags)
 {
-    virCheckFlags(0, -1);
+    int ret = -1;
 
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    virCheckFlags(VIR_CONNECT_LIST_FSPOOLS_FILTERS_ALL, -1);
+
+    if (virConnectListAllFSPoolsEnsureACL(conn) < 0)
+        goto cleanup;
+
+    fsDriverLock();
+    ret = virFSPoolObjListExport(conn, driver->fspools, fspools,
+                                 virConnectListAllFSPoolsCheckACL,
+                                 flags);
+    fsDriverUnlock();
+
+ cleanup:
+    return ret;
 
-    return -1;
 }
 
 static virFSPoolPtr
-fsPoolLookupByName(virConnectPtr conn ATTRIBUTE_UNUSED,
-                   const char *name ATTRIBUTE_UNUSED)
+fsPoolLookupByName(virConnectPtr conn,
+                   const char *name)
 {
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    virFSPoolObjPtr fspool;
+    virFSPoolPtr ret = NULL;
 
-    return NULL;
+    fsDriverLock();
+    fspool = virFSPoolObjFindByName(&driver->fspools, name);
+    fsDriverUnlock();
+
+    if (!fspool) {
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching name '%s'"), name);
+        return NULL;
+    }
+
+    if (virFSPoolLookupByNameEnsureACL(conn, fspool->def) < 0)
+        goto cleanup;
+
+    ret = virGetFSPool(conn, fspool->def->name, fspool->def->uuid,
+                       NULL, NULL);
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
 }
 
 static virFSPoolPtr
-fsPoolLookupByUUID(virConnectPtr conn ATTRIBUTE_UNUSED,
-                   const unsigned char *uuid ATTRIBUTE_UNUSED)
+fsPoolLookupByUUID(virConnectPtr conn,
+                   const unsigned char *uuid)
 {
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    virFSPoolObjPtr fspool;
+    virFSPoolPtr ret = NULL;
 
-    return NULL;
+    fsDriverLock();
+    fspool = virFSPoolObjFindByUUID(&driver->fspools, uuid);
+    fsDriverUnlock();
+
+    if (!fspool) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching uuid '%s'"),
uuidstr);
+        return NULL;
+    }
+
+    if (virFSPoolLookupByUUIDEnsureACL(conn, fspool->def) < 0)
+        goto cleanup;
+
+    ret = virGetFSPool(conn, fspool->def->name, fspool->def->uuid,
+                       NULL, NULL);
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
 }
 
 static virFSPoolPtr
-fsPoolLookupByItem(virFSItemPtr item ATTRIBUTE_UNUSED)
+fsPoolLookupByItem(virFSItemPtr item)
 {
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    virFSPoolObjPtr fspool;
+    virFSPoolPtr ret = NULL;
 
-    return NULL;
+    fsDriverLock();
+    fspool = virFSPoolObjFindByName(&driver->fspools, item->pool);
+    fsDriverUnlock();
+
+    if (!fspool) {
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching name '%s'"),
+                       item->pool);
+        return NULL;
+    }
+
+    if (virFSPoolLookupByItemEnsureACL(item->conn, fspool->def) < 0)
+        goto cleanup;
+
+    ret = virGetFSPool(item->conn, fspool->def->name, fspool->def->uuid,
+                            NULL, NULL);
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
 }
 
 static virFSPoolPtr
-fsPoolCreateXML(virConnectPtr conn ATTRIBUTE_UNUSED,
-                const char *xml ATTRIBUTE_UNUSED,
+fsPoolCreateXML(virConnectPtr conn,
+                const char *xml,
                 unsigned int flags)
 {
-    virCheckFlags(0, NULL);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    virFSPoolDefPtr def;
+    virFSPoolObjPtr fspool = NULL;
+    virFSPoolPtr ret = NULL;
+    virFSBackendPtr backend;
+    char *stateFile = NULL;
+    unsigned int build_flags = 0;
 
-    return NULL;
+    virCheckFlags(VIR_FSPOOL_CREATE_WITH_BUILD_OVERWRITE |
+                  VIR_FSPOOL_CREATE_WITH_BUILD_NO_OVERWRITE, NULL);
+
+    VIR_EXCLUSIVE_FLAGS_RET(VIR_FSPOOL_BUILD_OVERWRITE,
+                            VIR_FSPOOL_BUILD_NO_OVERWRITE, NULL);
+
+    fsDriverLock();
+    if (!(def = virFSPoolDefParseString(xml)))
+        goto cleanup;
+
+    if (virFSPoolCreateXMLEnsureACL(conn, def) < 0)
+        goto cleanup;
+
+    if (virFSPoolObjIsDuplicate(&driver->fspools, def, 1) < 0)
+        goto cleanup;
+
+    if (virFSPoolSourceFindDuplicate(conn, &driver->fspools, def) < 0)
+        goto cleanup;
+
+    if ((backend = virFSBackendForType(def->type)) == NULL)
+        goto cleanup;
+
+    if (!(fspool = virFSPoolObjAssignDef(&driver->fspools, def)))
+        goto cleanup;
+    def = NULL;
+
+    if (backend->buildFSpool) {
+        if (flags & VIR_FSPOOL_CREATE_WITH_BUILD_OVERWRITE)
+            build_flags |= VIR_FSPOOL_BUILD_OVERWRITE;
+        else if (flags & VIR_FSPOOL_CREATE_WITH_BUILD_NO_OVERWRITE)
+            build_flags |= VIR_FSPOOL_BUILD_NO_OVERWRITE;
+
+        if (backend->buildFSpool(conn, fspool, build_flags) < 0) {
+            virFSPoolObjRemove(&driver->fspools, fspool);
+            fspool = NULL;
+            goto cleanup;
+            }
+    }
+
+    if (backend->startFSpool &&
+        backend->startFSpool(conn, fspool) < 0) {
+        virFSPoolObjRemove(&driver->fspools, fspool);
+        fspool = NULL;
+        goto cleanup;
+    }
+
+    stateFile = virFileBuildPath(driver->stateDir,
+                                 fspool->def->name, ".xml");
+
+    if (!stateFile || virFSPoolSaveState(stateFile, fspool->def) < 0 ||
+        backend->refreshFSpool(conn, fspool) < 0) {
+        if (stateFile)
+            unlink(stateFile);
+        if (backend->stopFSpool)
+            backend->stopFSpool(conn, fspool);
+        virFSPoolObjRemove(&driver->fspools, fspool);
+        fspool = NULL;
+        goto cleanup;
+    }
+    VIR_INFO("Creating fspool '%s'", fspool->def->name);
+    fspool->active = true;
+
+    ret = virGetFSPool(conn, fspool->def->name, fspool->def->uuid,
+                       NULL, NULL);
+
+ cleanup:
+    VIR_FREE(stateFile);
+    virStoragePoolDefFree(def);
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
 }
 
 static virFSPoolPtr
-fsPoolDefineXML(virConnectPtr conn ATTRIBUTE_UNUSED,
-                const char *xml ATTRIBUTE_UNUSED,
+fsPoolDefineXML(virConnectPtr conn,
+                const char *xml,
                 unsigned int flags)
 {
+    virFSPoolDefPtr def;
+    virFSPoolObjPtr fspool = NULL;
+    virFSPoolPtr ret = NULL;
+
     virCheckFlags(0, NULL);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
 
-    return NULL;
-}
+    fsDriverLock();
+    if (!(def = virFSPoolDefParseString(xml)))
+        goto cleanup;
 
-static int
-fsPoolCreate(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-             unsigned int flags)
-{
-    virCheckFlags(0, -1);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (virFSPoolDefineXMLEnsureACL(conn, def) < 0)
+        goto cleanup;
 
-    return -1;
-}
+    if (virFSPoolObjIsDuplicate(&driver->fspools, def, 0) < 0)
+        goto cleanup;
 
-static int
-fsPoolBuild(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-            unsigned int flags)
-{
-    virCheckFlags(0, -1);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (virFSPoolSourceFindDuplicate(conn, &driver->fspools, def) < 0)
+        goto cleanup;
 
-    return -1;
-}
+    if (virFSBackendForType(def->type) == NULL)
+        goto cleanup;
 
-static int
-fsPoolUndefine(virFSPoolPtr obj ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (!(fspool = virFSPoolObjAssignDef(&driver->fspools, def)))
+        goto cleanup;
 
-    return -1;
-}
+    if (virFSPoolObjSaveDef(driver, fspool, def) < 0) {
+        virFSPoolObjRemove(&driver->fspools, fspool);
+        def = NULL;
+        fspool = NULL;
+        goto cleanup;
+    }
+    def = NULL;
 
-static int
-fsPoolDestroy(virFSPoolPtr obj ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    VIR_INFO("Defining fspool '%s'", fspool->def->name);
+    ret = virGetFSPool(conn, fspool->def->name, fspool->def->uuid,
+                            NULL, NULL);
 
-    return -1;
+ cleanup:
+
+    virStoragePoolDefFree(def);
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
 }
 
-static int
-fsPoolDelete(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-             unsigned int flags)
+static virFSPoolObjPtr
+virFSPoolObjFromFSPool(virFSPoolPtr fspool)
 {
-    virCheckFlags(0, -1);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    char uuidstr[VIR_UUID_STRING_BUFLEN];
+    virFSPoolObjPtr ret;
 
-    return -1;
+    fsDriverLock();
+    if (!(ret = virFSPoolObjFindByUUID(&driver->fspools, fspool->uuid))) {
+        virUUIDFormat(fspool->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, fspool->name);
+    }
+    fsDriverUnlock();
+
+    return ret;
 }
 
 static int
-fsPoolRefresh(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-              unsigned int flags)
+fsPoolCreate(virFSPoolPtr obj,
+             unsigned int flags)
 {
-    virCheckFlags(0, -1);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    int ret = -1;
+    char *stateFile = NULL;
+    unsigned int build_flags = 0;
 
-    return -1;
-}
+    virCheckFlags(VIR_FSPOOL_CREATE_WITH_BUILD_OVERWRITE |
+                  VIR_FSPOOL_CREATE_WITH_BUILD_NO_OVERWRITE, -1);
 
-static int
-fsPoolGetInfo(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-              virFSPoolInfoPtr info ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    VIR_EXCLUSIVE_FLAGS_RET(VIR_FSPOOL_BUILD_OVERWRITE,
+                            VIR_FSPOOL_BUILD_NO_OVERWRITE, -1);
 
-    return -1;
-}
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return -1;
 
-static char *
-fsPoolGetXMLDesc(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-                 unsigned int flags)
-{
-    virCheckFlags(0, NULL);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (virFSPoolCreateEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
 
-    return NULL;
-}
+    if ((backend = virFSBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
 
-static int
-fsPoolGetAutostart(virFSPoolPtr obj ATTRIBUTE_UNUSED, int *autostart  ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is already active"),
+                       fspool->def->name);
+        goto cleanup;
+    }
 
-    return -1;
-}
+    if (backend->buildFSpool) {
+        if (flags & VIR_FSPOOL_CREATE_WITH_BUILD_OVERWRITE)
+            build_flags |= VIR_FSPOOL_BUILD_OVERWRITE;
+        else if (flags & VIR_FSPOOL_CREATE_WITH_BUILD_NO_OVERWRITE)
+            build_flags |= VIR_FSPOOL_BUILD_NO_OVERWRITE;
 
-static int
-fsPoolSetAutostart(virFSPoolPtr obj ATTRIBUTE_UNUSED, int autostart ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+        if (backend->buildFSpool(obj->conn, fspool, build_flags) < 0) {
+            virFSPoolObjRemove(&driver->fspools, fspool);
+            fspool = NULL;
+            goto cleanup;
+        }
+    }
 
-    return -1;
-}
+    VIR_INFO("Starting up fspool '%s'", fspool->def->name);
+    if (backend->startFSpool &&
+        backend->startFSpool(obj->conn, fspool) < 0)
+        goto cleanup;
 
-static int
-fsPoolNumOfItems(virFSPoolPtr obj ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    stateFile = virFileBuildPath(driver->stateDir,
+                                 fspool->def->name, ".xml");
 
-    return -1;
-}
+    virFSPoolObjClearItems(fspool);
+    if (!stateFile || virFSPoolSaveState(stateFile, fspool->def) < 0 ||
+        backend->refreshFSpool(obj->conn, fspool) < 0) {
+        if (stateFile)
+            unlink(stateFile);
+        goto cleanup;
+    }
 
-static int
-fsPoolListItems(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-                char **const names ATTRIBUTE_UNUSED,
-                int maxnames ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    fspool->active = true;
+    ret = 0;
+
+ cleanup:
+    VIR_FREE(stateFile);
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    return ret;
 
-    return -1;
 }
 
 static int
-fsPoolListAllItems(virFSPoolPtr fspool ATTRIBUTE_UNUSED,
-                   virFSItemPtr **items ATTRIBUTE_UNUSED,
-                   unsigned int flags)
+fsPoolBuild(virFSPoolPtr obj,
+            unsigned int flags)
 {
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    int ret = -1;
+
     virCheckFlags(0, -1);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
 
-    return -1;
-}
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return -1;
 
-static virFSItemPtr
-fsItemLookupByName(virFSPoolPtr obj ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (virFSPoolBuildEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
 
-    return NULL;
-}
+    if ((backend = virFSBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
 
-static virFSItemPtr
-fsItemLookupByKey(virConnectPtr conn ATTRIBUTE_UNUSED, const char *key ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is already active"),
+                       fspool->def->name);
+        goto cleanup;
+    }
 
-    return NULL;
-}
+    if (backend->buildFSpool &&
+        backend->buildFSpool(obj->conn, fspool, flags) < 0)
+        goto cleanup;
 
-static virFSItemPtr
-fsItemLookupByPath(virConnectPtr conn ATTRIBUTE_UNUSED,
-                   const char *path ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    ret = 0;
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
 
-    return NULL;
 }
 
-static virFSItemPtr
-fsItemCreateXML(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-                const char *xmldesc ATTRIBUTE_UNUSED,
-                unsigned int flags)
+static int
+fsPoolUndefine(virFSPoolPtr obj)
 {
-    virCheckFlags(0, NULL);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    virFSPoolObjPtr fspool;
+    int ret = -1;
 
-    return NULL;
-}
+    fsDriverLock();
+    if (!(fspool = virFSPoolObjFindByUUID(&driver->fspools, obj->uuid))) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
 
-static virFSItemPtr
-fsItemCreateXMLFrom(virFSPoolPtr obj ATTRIBUTE_UNUSED,
-                    const char *xmldesc ATTRIBUTE_UNUSED,
-                    virFSItemPtr vobj ATTRIBUTE_UNUSED,
-                    unsigned int flags)
-{
-    virCheckFlags(0, NULL);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (virFSPoolUndefineEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
 
-    return NULL;
-}
+    if (virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is still active"),
+                       fspool->def->name);
+        goto cleanup;
+    }
 
-static int
-fsItemGetInfo(virFSItemPtr obj ATTRIBUTE_UNUSED,
-              virFSItemInfoPtr info ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (fspool->asyncjobs > 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fspool '%s' has asynchronous jobs
running."),
+                       fspool->def->name);
+        goto cleanup;
+    }
 
-    return -1;
-}
+    if (virFSPoolObjDeleteDef(fspool) < 0)
+        goto cleanup;
 
-static char *
-fsItemGetXMLDesc(virFSItemPtr obj ATTRIBUTE_UNUSED, unsigned int flags)
-{
-    virCheckFlags(0, NULL);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (unlink(fspool->autostartLink) < 0 &&
+        errno != ENOENT &&
+        errno != ENOTDIR) {
+        char ebuf[1024];
+        VIR_ERROR(_("Failed to delete autostart link '%s': %s"),
+                  fspool->autostartLink, virStrerror(errno, ebuf, sizeof(ebuf)));
+    }
 
-    return NULL;
-}
+    VIR_FREE(fspool->configFile);
+    VIR_FREE(fspool->autostartLink);
 
-static char *
-fsItemGetPath(virFSItemPtr obj ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    VIR_INFO("Undefining fspool '%s'", fspool->def->name);
+    virFSPoolObjRemove(&driver->fspools, fspool);
+    fspool = NULL;
+    ret = 0;
+
+ cleanup:
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
 
-    return NULL;
 }
 
 static int
-fsPoolIsActive(virFSPoolPtr fspool ATTRIBUTE_UNUSED)
+fsPoolDestroy(virFSPoolPtr obj)
 {
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    char *stateFile = NULL;
+    int ret = -1;
 
-    return -1;
-}
+    fsDriverLock();
+    if (!(fspool = virFSPoolObjFindByUUID(&driver->fspools, obj->uuid))) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
 
-static int
-fsPoolIsPersistent(virFSPoolPtr fspool ATTRIBUTE_UNUSED)
-{
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
+    if (virFSPoolDestroyEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
 
-    return -1;
+    if ((backend = virFSBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    VIR_INFO("Destroying fspool '%s'", fspool->def->name);
+
+    if (!virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
fspool->def->name);
+        goto cleanup;
+    }
+
+    if (fspool->asyncjobs > 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fspool '%s' has asynchronous jobs
running."),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (!(stateFile = virFileBuildPath(driver->stateDir,
+                                       fspool->def->name,
+                                       ".xml")))
+        goto cleanup;
+
+    unlink(stateFile);
+    VIR_FREE(stateFile);
+
+    if (backend->stopFSpool &&
+        backend->stopFSpool(obj->conn, fspool) < 0)
+        goto cleanup;
+
+    virFSPoolObjClearItems(fspool);
+
+    fspool->active = false;
+
+    if (fspool->configFile == NULL) {
+        virFSPoolObjRemove(&driver->fspools, fspool);
+        fspool = NULL;
+    } else if (fspool->newDef) {
+        virStoragePoolDefFree(fspool->def);
+        fspool->def = fspool->newDef;
+        fspool->newDef = NULL;
+    }
+
+    ret = 0;
+
+ cleanup:
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
 }
 
 static int
-fsItemDelete(virFSItemPtr obj ATTRIBUTE_UNUSED,
+fsPoolDelete(virFSPoolPtr obj,
              unsigned int flags)
 {
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    char *stateFile = NULL;
+    int ret = -1;
+
     virCheckFlags(0, -1);
-    virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                   _("the operation is not yet supported"));
 
-    return -1;
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return -1;
+
+    if (virFSPoolDeleteEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((backend = virFSBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    VIR_INFO("Deleting fspool '%s'", fspool->def->name);
+
+    if (virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is still active"),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (fspool->asyncjobs > 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fspool '%s' has asynchronous jobs
running."),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (!(stateFile = virFileBuildPath(driver->stateDir,
+                                       fspool->def->name,
+                                       ".xml")))
+        goto cleanup;
+
+    unlink(stateFile);
+    VIR_FREE(stateFile);
+
+    if (!backend->deleteFSpool) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s", _("fspool does not support fspool
deletion"));
+        goto cleanup;
+    }
+    if (backend->deleteFSpool(obj->conn, fspool, flags) < 0)
+        goto cleanup;
+
+    ret = 0;
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolRefresh(virFSPoolPtr obj,
+              unsigned int flags)
+{
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    fsDriverLock();
+    if (!(fspool = virFSPoolObjFindByUUID(&driver->fspools, obj->uuid))) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
+
+    if (virFSPoolRefreshEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((backend = virFSBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    if (!virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
fspool->def->name);
+        goto cleanup;
+    }
+
+    if (fspool->asyncjobs > 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fspool '%s' has asynchronous jobs
running."),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    virFSPoolObjClearItems(fspool);
+    if (backend->refreshFSpool(obj->conn, fspool) < 0) {
+        if (backend->stopFSpool)
+            backend->stopFSpool(obj->conn, fspool);
+
+        fspool->active = false;
+
+        if (fspool->configFile == NULL) {
+            virFSPoolObjRemove(&driver->fspools, fspool);
+            fspool = NULL;
+        }
+        goto cleanup;
+    }
+    ret = 0;
+
+ cleanup:
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
+
+}
+
+static int
+fsPoolGetInfo(virFSPoolPtr obj,
+              virFSPoolInfoPtr info)
+{
+    virFSPoolObjPtr fspool;
+    int ret = -1;
+
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return -1;
+
+    if (virFSPoolGetInfoEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (virFSBackendForType(fspool->def->type) == NULL)
+        goto cleanup;
+
+    memset(info, 0, sizeof(virFSPoolInfo));
+    if (fspool->active)
+        info->state = VIR_FSPOOL_RUNNING;
+    else
+        info->state = VIR_FSPOOL_INACTIVE;
+    info->capacity = fspool->def->capacity;
+    info->allocation = fspool->def->allocation;
+    info->available = fspool->def->available;
+    ret = 0;
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static char *
+fsPoolGetXMLDesc(virFSPoolPtr obj,
+                 unsigned int flags)
+{
+    virFSPoolObjPtr fspool;
+    virFSPoolDefPtr def;
+    char *ret = NULL;
+
+    virCheckFlags(VIR_FS_XML_INACTIVE, NULL);
+
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return NULL;
+
+    if (virFSPoolGetXMLDescEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((flags & VIR_FS_XML_INACTIVE) && fspool->newDef)
+        def = fspool->newDef;
+    else
+        def = fspool->def;
+
+    ret = virFSPoolDefFormat(def);
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolGetAutostart(virFSPoolPtr obj, int *autostart)
+{
+    virFSPoolObjPtr fspool;
+    int ret = -1;
+
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return -1;
+
+    if (virFSPoolGetAutostartEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (!fspool->configFile) {
+        *autostart = 0;
+    } else {
+        *autostart = fspool->autostart;
+    }
+    ret = 0;
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolSetAutostart(virFSPoolPtr obj, int autostart)
+{
+    virFSPoolObjPtr fspool;
+    int ret = -1;
+
+    fsDriverLock();
+    fspool = virFSPoolObjFindByUUID(&driver->fspools, obj->uuid);
+
+    if (!fspool) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                      uuidstr, obj->name);
+        goto cleanup;
+    }
+
+    if (virFSPoolSetAutostartEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (!fspool->configFile) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("fspool has no config file"));
+        goto cleanup;
+    }
+
+    autostart = (autostart != 0);
+
+    if (fspool->autostart != autostart) {
+        if (autostart) {
+            if (virFileMakePath(driver->autostartDir) < 0) {
+                virReportSystemError(errno,
+                                     _("cannot create autostart directory
%s"),
+                                     driver->autostartDir);
+                goto cleanup;
+            }
+
+            if (symlink(fspool->configFile, fspool->autostartLink) < 0) {
+                virReportSystemError(errno,
+                                     _("Failed to create symlink '%s' to
'%s'"),
+                                     fspool->autostartLink, fspool->configFile);
+                goto cleanup;
+            }
+        } else {
+            if (unlink(fspool->autostartLink) < 0 &&
+                errno != ENOENT && errno != ENOTDIR) {
+                virReportSystemError(errno,
+                                     _("Failed to delete symlink
'%s'"),
+                                     fspool->autostartLink);
+                goto cleanup;
+            }
+        }
+        fspool->autostart = autostart;
+    }
+    ret = 0;
+
+ cleanup:
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
+}
+
+static int
+fsPoolNumOfItems(virFSPoolPtr obj)
+{
+    virFSPoolObjPtr fspool;
+    int ret = -1;
+    size_t i;
+
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return -1;
+
+    if (virFSPoolNumOfItemsEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (!virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
fspool->def->name);
+        goto cleanup;
+    }
+    ret = 0;
+    for (i = 0; i < fspool->items.count; i++) {
+        if (virFSPoolNumOfItemsCheckACL(obj->conn, fspool->def,
+                                               fspool->items.objs[i]))
+            ret++;
+    }
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolListItems(virFSPoolPtr obj,
+                char **const names,
+                int maxnames)
+{
+    virFSPoolObjPtr fspool;
+    size_t i;
+    int n = 0;
+
+    memset(names, 0, maxnames * sizeof(*names));
+
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return -1;
+
+    if (virFSPoolListItemsEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (!virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
fspool->def->name);
+        goto cleanup;
+    }
+
+    for (i = 0; i < fspool->items.count && n < maxnames; i++) {
+        if (!virFSPoolListItemsCheckACL(obj->conn, fspool->def,
+                                        fspool->items.objs[i]))
+            continue;
+        if (VIR_STRDUP(names[n++], fspool->items.objs[i]->name) < 0)
+            goto cleanup;
+    }
+
+    virFSPoolObjUnlock(fspool);
+    return n;
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    for (n = 0; n < maxnames; n++)
+        VIR_FREE(names[n]);
+
+    memset(names, 0, maxnames * sizeof(*names));
+    return -1;
+}
+
+static int
+fsPoolListAllItems(virFSPoolPtr fspool,
+                   virFSItemPtr **items,
+                   unsigned int flags)
+{
+    virFSPoolObjPtr obj;
+    size_t i;
+    virFSItemPtr *tmp_items = NULL;
+    virFSItemPtr item = NULL;
+    int nitems = 0;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(obj = virFSPoolObjFromFSPool(fspool)))
+        return -1;
+
+    if (virFSPoolListAllItemsEnsureACL(fspool->conn, obj->def) < 0)
+        goto cleanup;
+
+    if (!virFSPoolObjIsActive(obj)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
obj->def->name);
+        goto cleanup;
+    }
+
+     /* Just returns the items count */
+    if (!items) {
+        ret = obj->items.count;
+        goto cleanup;
+    }
+
+    if (VIR_ALLOC_N(tmp_items, obj->items.count + 1) < 0)
+        goto cleanup;
+
+    for (i = 0; i < obj->items.count; i++) {
+        if (!virFSPoolListAllItemsCheckACL(fspool->conn, obj->def,
+                                                  obj->items.objs[i]))
+            continue;
+        if (!(item = virGetFSItem(fspool->conn, obj->def->name,
+                                  obj->items.objs[i]->name,
+                                  obj->items.objs[i]->key,
+                                  NULL, NULL)))
+            goto cleanup;
+        tmp_items[nitems++] = item;
+    }
+
+    *items = tmp_items;
+    tmp_items = NULL;
+    ret = nitems;
+
+ cleanup:
+    if (tmp_items) {
+        for (i = 0; i < nitems; i++)
+            virObjectUnref(tmp_items[i]);
+        VIR_FREE(tmp_items);
+    }
+
+    virFSPoolObjUnlock(obj);
+
+    return ret;
+}
+
+static virFSItemPtr
+fsItemLookupByName(virFSPoolPtr obj, const char *name)
+{
+    virFSPoolObjPtr fspool;
+    virFSItemDefPtr item;
+    virFSItemPtr ret = NULL;
+
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return NULL;
+
+    if (!virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
fspool->def->name);
+        goto cleanup;
+    }
+
+    item = virFSItemDefFindByName(fspool, name);
+
+    if (!item) {
+        virReportError(VIR_ERR_NO_FSITEM,
+                       _("no fspool item with matching name '%s'"),
+                       name);
+        goto cleanup;
+    }
+
+    if (virFSItemLookupByNameEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    ret = virGetFSItem(obj->conn, fspool->def->name, item->name,
item->key,
+                       NULL, NULL);
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static virFSItemPtr
+fsItemLookupByKey(virConnectPtr conn, const char *key)
+{
+    size_t i;
+    virFSItemPtr ret = NULL;
+
+    fsDriverLock();
+    for (i = 0; i < driver->fspools.count && !ret; i++) {
+        virFSPoolObjLock(driver->fspools.objs[i]);
+        if (virFSPoolObjIsActive(driver->fspools.objs[i])) {
+            virFSItemDefPtr item =
+                virFSItemDefFindByKey(driver->fspools.objs[i], key);
+
+            if (item) {
+                virFSPoolDefPtr def = driver->fspools.objs[i]->def;
+                if (virFSItemLookupByKeyEnsureACL(conn, def, item) < 0) {
+                    virFSPoolObjUnlock(driver->fspools.objs[i]);
+                    goto cleanup;
+                }
+
+                ret = virGetFSItem(conn,
+                                   def->name,
+                                   item->name,
+                                   item->key,
+                                   NULL, NULL);
+            }
+        }
+        virFSPoolObjUnlock(driver->fspools.objs[i]);
+    }
+
+    if (!ret)
+        virReportError(VIR_ERR_NO_FSITEM,
+                       _("no fspool item with matching key %s"), key);
+
+ cleanup:
+    fsDriverUnlock();
+    return ret;
+}
+
+static virFSItemPtr
+fsItemLookupByPath(virConnectPtr conn,
+                   const char *path)
+{
+    size_t i;
+    virFSItemPtr ret = NULL;
+    char *cleanpath;
+
+    cleanpath = virFileSanitizePath(path);
+    if (!cleanpath)
+        return NULL;
+
+    fsDriverLock();
+    for (i = 0; i < driver->fspools.count && !ret; i++) {
+        virFSPoolObjPtr fspool = driver->fspools.objs[i];
+        virFSItemDefPtr item;
+
+        virFSPoolObjLock(fspool);
+
+        if (!virFSPoolObjIsActive(fspool)) {
+           virFSPoolObjUnlock(fspool);
+           continue;
+        }
+
+        item = virFSItemDefFindByPath(fspool, cleanpath);
+
+        if (item) {
+            if (virFSItemLookupByPathEnsureACL(conn, fspool->def, item) < 0) {
+                virFSPoolObjUnlock(fspool);
+                goto cleanup;
+            }
+
+            ret = virGetFSItem(conn, fspool->def->name,
+                               item->name, item->key,
+                               NULL, NULL);
+        }
+
+        virFSPoolObjUnlock(fspool);
+    }
+
+    if (!ret) {
+        if (STREQ(path, cleanpath)) {
+            virReportError(VIR_ERR_NO_FSITEM,
+                           _("no fspool item with matching path '%s'"),
path);
+        } else {
+            virReportError(VIR_ERR_NO_FSITEM,
+                           _("no fspool item with matching path '%s'
(%s)"),
+                           path, cleanpath);
+        }
+    }
+
+ cleanup:
+    VIR_FREE(cleanpath);
+    fsDriverUnlock();
+    return ret;
+}
+
+static void
+fsItemRemoveFromFSPool(virFSPoolObjPtr fspool,
+                       virFSItemDefPtr item)
+{
+    size_t i;
+
+    for (i = 0; i < fspool->items.count; i++) {
+        if (fspool->items.objs[i] == item) {
+            VIR_INFO("Deleting item '%s' from fspool '%s'",
+                     item->name, fspool->def->name);
+            virFSItemDefFree(item);
+
+            VIR_DELETE_ELEMENT(fspool->items.objs, i, fspool->items.count);
+            break;
+        }
+    }
+}
+
+static int
+fsItemDeleteInternal(virFSItemPtr obj,
+                     virFSBackendPtr backend,
+                     virFSPoolObjPtr fspool,
+                     virFSItemDefPtr item,
+                     unsigned int flags)
+{
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!backend->deleteItem) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                  "%s", _("fspool does not support item deletion"));
+        goto cleanup;
+    }
+    if (backend->deleteItem(obj->conn, fspool, item, flags) < 0)
+        goto cleanup;
+
+    fsItemRemoveFromFSPool(fspool, item);
+
+    ret = 0;
+
+ cleanup:
+    return ret;
+}
+
+static virFSItemPtr
+fsItemCreateXML(virFSPoolPtr obj,
+                const char *xmldesc,
+                unsigned int flags)
+{
+
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    virFSItemDefPtr itemdef = NULL;
+    virFSItemPtr ret = NULL, itemobj = NULL;
+
+    virCheckFlags(0, NULL);
+
+    if (!(fspool = virFSPoolObjFromFSPool(obj)))
+        return NULL;
+
+    if (!virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
fspool->def->name);
+        goto cleanup;
+    }
+
+    if ((backend = virFSBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    itemdef = virFSItemDefParseString(fspool->def, xmldesc,
+                                      VIR_ITEM_XML_PARSE_OPT_CAPACITY);
+    if (itemdef == NULL)
+        goto cleanup;
+
+    if (!itemdef->target.capacity && !backend->buildItem) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s", _("item capacity required for this "
+                               "fspool"));
+        goto cleanup;
+    }
+
+    if (virFSItemCreateXMLEnsureACL(obj->conn, fspool->def, itemdef) < 0)
+        goto cleanup;
+
+    if (virFSItemDefFindByName(fspool, itemdef->name)) {
+        virReportError(VIR_ERR_FSITEM_EXIST,
+                       _("'%s'"), itemdef->name);
+        goto cleanup;
+    }
+
+    if (!backend->createItem) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s", _("fspool does not support item "
+                               "creation"));
+        goto cleanup;
+    }
+
+    if (VIR_REALLOC_N(fspool->items.objs,
+                      fspool->items.count+1) < 0)
+        goto cleanup;
+
+    /* Wipe any key the user may have suggested, as item creation
+     * will generate the canonical key.  */
+    VIR_FREE(itemdef->key);
+    if (backend->createItem(obj->conn, fspool, itemdef) < 0)
+        goto cleanup;
+
+    fspool->items.objs[fspool->items.count++] = itemdef;
+    itemobj = virGetFSItem(obj->conn, fspool->def->name, itemdef->name,
+                           itemdef->key, NULL, NULL);
+    if (!itemobj) {
+        fspool->items.count--;
+        goto cleanup;
+    }
+
+
+    if (backend->buildItem) {
+        int buildret;
+        virFSItemDefPtr builditemdef = NULL;
+
+        if (VIR_ALLOC(builditemdef) < 0) {
+            itemdef = NULL;
+            goto cleanup;
+        }
+
+        /* Make a shallow copy of the 'defined' item definition, since the
+         * original allocation value will change as the user polls 'info',
+         * but we only need the initial requested values
+         */
+        memcpy(builditemdef, itemdef, sizeof(*itemdef));
+
+        /* Drop the fspool lock during item allocation */
+        fspool->asyncjobs++;
+        itemdef->building = true;
+        virFSPoolObjUnlock(fspool);
+
+        buildret = backend->buildItem(obj->conn, fspool, builditemdef, flags);
+
+        VIR_FREE(builditemdef);
+
+        fsDriverLock();
+        virFSPoolObjLock(fspool);
+        fsDriverUnlock();
+
+        itemdef->building = false;
+        fspool->asyncjobs--;
+
+        if (buildret < 0) {
+            /* buildItem handles deleting item on failure */
+            fsItemRemoveFromFSPool(fspool, itemdef);
+            itemdef = NULL;
+            goto cleanup;
+        }
+
+    }
+
+    if (backend->refreshItem &&
+        backend->refreshItem(obj->conn, fspool, itemdef) < 0) {
+        fsItemDeleteInternal(itemobj, backend, fspool, itemdef, 0);
+        itemdef = NULL;
+        goto cleanup;
+    }
+
+    /* Update fspool metadata ignoring the disk backend since
+     * it updates the fspool values.
+     */
+
+    VIR_INFO("Creating item '%s' in fspool '%s'",
+             itemobj->name, fspool->def->name);
+    ret = itemobj;
+    itemobj = NULL;
+    itemdef = NULL;
+
+ cleanup:
+    virObjectUnref(itemobj);
+    virFSItemDefFree(itemdef);
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static virFSItemPtr
+fsItemCreateXMLFrom(virFSPoolPtr obj,
+                    const char *xmldesc,
+                    virFSItemPtr vobj,
+                    unsigned int flags)
+{
+    virFSPoolObjPtr fspool, origpool = NULL;
+    virFSBackendPtr backend;
+    virFSItemDefPtr origitem = NULL, newitem = NULL, shadowitem = NULL;
+    virFSItemPtr ret = NULL, itemobj = NULL;
+    int buildret;
+
+    virCheckFlags(0, NULL);
+
+    fsDriverLock();
+    fspool = virFSPoolObjFindByUUID(&driver->fspools, obj->uuid);
+    if (fspool && STRNEQ(obj->name, vobj->pool)) {
+        virFSPoolObjUnlock(fspool);
+        origpool = virFSPoolObjFindByName(&driver->fspools, vobj->pool);
+        virFSPoolObjLock(fspool);
+    }
+    fsDriverUnlock();
+    if (!fspool) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
+
+    if (STRNEQ(obj->name, vobj->pool) && !origpool) {
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching name '%s'"),
+                       vobj->pool);
+        goto cleanup;
+    }
+
+    if (!virFSPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
fspool->def->name);
+        goto cleanup;
+    }
+
+    if (origpool && !virFSPoolObjIsActive(origpool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
+                       origpool->def->name);
+        goto cleanup;
+    }
+
+    if ((backend = virFSBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    origitem = virFSItemDefFindByName(origpool ?
+                                         origpool : fspool, vobj->name);
+    if (!origitem) {
+        virReportError(VIR_ERR_NO_FSITEM,
+                       _("no fsitem with matching name '%s'"),
+                       vobj->name);
+        goto cleanup;
+    }
+
+    newitem = virFSItemDefParseString(fspool->def, xmldesc,
+                                         VIR_VOL_XML_PARSE_NO_CAPACITY);
+    if (newitem == NULL)
+        goto cleanup;
+
+    if (virFSItemCreateXMLFromEnsureACL(obj->conn, fspool->def, newitem) < 0)
+        goto cleanup;
+
+    if (virFSItemDefFindByName(fspool, newitem->name)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fsitem name '%s' already in use."),
+                       newitem->name);
+        goto cleanup;
+    }
+
+    /* Use the original item's capacity in case the new capacity
+     * is less than that, or it was omitted */
+    if (newitem->target.capacity < origitem->target.capacity)
+        newitem->target.capacity = origitem->target.capacity;
+
+    if (!backend->buildItemFrom) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s", _("fspool does not support"
+                               " item creation from an existing item"));
+        goto cleanup;
+    }
+
+    if (origitem->building) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fsitem '%s' is still being allocated."),
+                       origitem->name);
+        goto cleanup;
+    }
+
+    if (backend->refreshItem &&
+        backend->refreshItem(obj->conn, fspool, origitem) < 0)
+        goto cleanup;
+
+    if (VIR_REALLOC_N(fspool->items.objs,
+                      fspool->items.count+1) < 0)
+        goto cleanup;
+
+    /* 'Define' the new item so we get async progress reporting.
+     * Wipe any key the user may have suggested, as item creation
+    * will generate the canonical key.  */
+    VIR_FREE(newitem->key);
+    if (backend->createItem(obj->conn, fspool, newitem) < 0)
+        goto cleanup;
+
+    /* Make a shallow copy of the 'defined' item definition, since the
+     * original allocation value will change as the user polls 'info',
+     * but we only need the initial requested values
+     */
+    if (VIR_ALLOC(shadowitem) < 0)
+        goto cleanup;
+
+    memcpy(shadowitem, newitem, sizeof(*newitem));
+
+    fspool->items.objs[fspool->items.count++] = newitem;
+    itemobj = virGetFSItem(obj->conn, fspool->def->name, newitem->name,
+                              newitem->key, NULL, NULL);
+    if (!itemobj) {
+        fspool->items.count--;
+        goto cleanup;
+    }
+
+    /* Drop the fspool lock during item allocation */
+    fspool->asyncjobs++;
+    newitem->building = true;
+    origitem->in_use++;
+    virFSPoolObjUnlock(fspool);
+
+    if (origpool) {
+        origpool->asyncjobs++;
+        virFSPoolObjUnlock(origpool);
+    }
+
+    buildret = backend->buildItemFrom(obj->conn, fspool, shadowitem, origitem,
flags);
+
+    fsDriverLock();
+    virFSPoolObjLock(fspool);
+    if (origpool)
+        virFSPoolObjLock(origpool);
+    fsDriverUnlock();
+
+    origitem->in_use--;
+    newitem->building = false;
+    fspool->asyncjobs--;
+
+    if (origpool) {
+        origpool->asyncjobs--;
+        virFSPoolObjUnlock(origpool);
+        origpool = NULL;
+    }
+
+    if (buildret < 0 ||
+        (backend->refreshItem &&
+         backend->refreshItem(obj->conn, fspool, newitem) < 0)) {
+        fsItemDeleteInternal(itemobj, backend, fspool, newitem, 0);
+        newitem = NULL;
+       goto cleanup;
+    }
+
+    fspool->def->allocation += newitem->target.allocation;
+    fspool->def->available -= newitem->target.allocation;
+
+    VIR_INFO("Creating item '%s' in fspool '%s'",
+             itemobj->name, fspool->def->name);
+    ret = itemobj;
+   itemobj = NULL;
+    newitem = NULL;
+
+ cleanup:
+    virObjectUnref(itemobj);
+    virFSItemDefFree(newitem);
+    VIR_FREE(shadowitem);
+    if (fspool)
+        virFSPoolObjUnlock(fspool);
+    if (origpool)
+        virFSPoolObjUnlock(origpool);
+    return ret;
+}
+
+static virFSItemDefPtr
+virFSItemDefFromItem(virFSItemPtr obj,
+                     virFSPoolObjPtr *fspool,
+                     virFSBackendPtr *backend)
+{
+    virFSItemDefPtr item = NULL;
+
+    *fspool = NULL;
+
+    fsDriverLock();
+    *fspool = virFSPoolObjFindByName(&driver->fspools, obj->pool);
+    fsDriverUnlock();
+
+    if (!*fspool) {
+        virReportError(VIR_ERR_NO_FSPOOL,
+                       _("no fspool with matching name '%s'"),
+                       obj->pool);
+        return NULL;
+    }
+
+    if (!virFSPoolObjIsActive(*fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
+                       (*fspool)->def->name);
+        goto error;
+    }
+
+    if (!(item = virFSItemDefFindByName(*fspool, obj->name))) {
+        virReportError(VIR_ERR_NO_FSITEM,
+                       _("no fsitem with matching name '%s'"),
+                       obj->name);
+        goto error;
+    }
+
+    if (backend) {
+        if (!(*backend = virFSBackendForType((*fspool)->def->type)))
+            goto error;
+    }
+
+    return item;
+
+ error:
+    virFSPoolObjUnlock(*fspool);
+    *fspool = NULL;
+
+    return NULL;
+}
+
+static int
+fsItemGetInfo(virFSItemPtr obj,
+              virFSItemInfoPtr info)
+{
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    virFSItemDefPtr item;
+    int ret = -1;
+
+    if (!(item = virFSItemDefFromItem(obj, &fspool, &backend)))
+        return -1;
+
+    if (virFSItemGetInfoEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    if (backend->refreshItem &&
+        backend->refreshItem(obj->conn, fspool, item) < 0)
+        goto cleanup;
+
+    memset(info, 0, sizeof(*info));
+    info->type = item->type;
+    info->capacity = item->target.capacity;
+    info->allocation = item->target.allocation;
+    ret = 0;
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static char *
+fsItemGetXMLDesc(virFSItemPtr obj, unsigned int flags)
+{
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    virFSItemDefPtr item;
+    char *ret = NULL;
+
+    virCheckFlags(0, NULL);
+
+    if (!(item = virFSItemDefFromItem(obj, &fspool, &backend)))
+        return NULL;
+
+    if (virFSItemGetXMLDescEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    if (backend->refreshItem &&
+        backend->refreshItem(obj->conn, fspool, item) < 0)
+        goto cleanup;
+
+    ret = virFSItemDefFormat(fspool->def, item);
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+
+    return ret;
+}
+
+static char *
+fsItemGetPath(virFSItemPtr obj)
+{
+    virFSPoolObjPtr fspool;
+    virFSItemDefPtr item;
+    char *ret = NULL;
+
+    if (!(item = virFSItemDefFromItem(obj, &fspool, NULL)))
+        return NULL;
+
+    if (virFSItemGetPathEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    ignore_value(VIR_STRDUP(ret, item->target.path));
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolIsActive(virFSPoolPtr fspool)
+{
+    virFSPoolObjPtr obj;
+    int ret = -1;
+
+    if (!(obj = virFSPoolObjFromFSPool(fspool)))
+        return -1;
+
+    if (virFSPoolIsActiveEnsureACL(fspool->conn, obj->def) < 0)
+        goto cleanup;
+
+    ret = virFSPoolObjIsActive(obj);
+
+ cleanup:
+    virFSPoolObjUnlock(obj);
+    return ret;
+}
+
+static int
+fsPoolIsPersistent(virFSPoolPtr fspool)
+{
+    virFSPoolObjPtr obj;
+    int ret = -1;
+
+    if (!(obj = virFSPoolObjFromFSPool(fspool)))
+        return -1;
+
+    if (virFSPoolIsPersistentEnsureACL(fspool->conn, obj->def) < 0)
+        goto cleanup;
+
+    ret = obj->configFile ? 1 : 0;
+
+ cleanup:
+    virFSPoolObjUnlock(obj);
+    return ret;
+}
+
+static int
+fsItemDelete(virFSItemPtr obj,
+             unsigned int flags)
+{
+    virFSPoolObjPtr fspool;
+    virFSBackendPtr backend;
+    virFSItemDefPtr item = NULL;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(item = virFSItemDefFromItem(obj, &fspool, &backend)))
+        return -1;
+
+    if (virFSItemDeleteEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    if (item->in_use) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("item '%s' is still in use."),
+                       item->name);
+        goto cleanup;
+    }
+
+    if (item->building) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("item '%s' is still being allocated."),
+                       item->name);
+        goto cleanup;
+    }
+
+    if (fsItemDeleteInternal(obj, backend, fspool, item, flags) < 0)
+        goto cleanup;
+
+    ret = 0;
+
+ cleanup:
+    virFSPoolObjUnlock(fspool);
+    return ret;
 }
 
 static virFSDriver fsDriver = {
-- 
1.8.3.1


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

[libvirt] [PATCH RFC v3 13/15] FSPool: driver methods implementation