[libvirt] [PATCH 2/7] fspool: usual driver based implementation of filesystem pools API

Nikolay Shirokovskiy nshirokovskiy at virtuozzo.com
Mon Jul 11 08:28:05 UTC 2016


From: Olga Krishtal <okrishtal at virtuozzo.com>

Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy at virtuozzo.com>
---
 include/libvirt/virterror.h |    8 +
 po/POTFILES.in              |    1 +
 src/Makefile.am             |    3 +
 src/datatypes.c             |  154 ++++
 src/datatypes.h             |   94 +++
 src/driver-fs.h             |  210 ++++++
 src/driver.h                |    1 +
 src/libvirt-fs.c            | 1715 +++++++++++++++++++++++++++++++++++++++++++
 src/libvirt_private.syms    |    4 +
 src/libvirt_public.syms     |   46 ++
 src/util/virerror.c         |   37 +
 11 files changed, 2273 insertions(+)
 create mode 100644 src/driver-fs.h
 create mode 100644 src/libvirt-fs.c

diff --git a/include/libvirt/virterror.h b/include/libvirt/virterror.h
index 2ec560e..39cddca 100644
--- a/include/libvirt/virterror.h
+++ b/include/libvirt/virterror.h
@@ -132,6 +132,8 @@ typedef enum {
 
     VIR_FROM_PERF = 65,         /* Error from perf */
 
+    VIR_FROM_FSPOOL = 66,       /* Error from fs pool */
+
 # ifdef VIR_ENUM_SENTINELS
     VIR_ERR_DOMAIN_LAST
 # endif
@@ -315,6 +317,12 @@ typedef enum {
     VIR_ERR_AUTH_UNAVAILABLE = 94,	/* authentication unavailable */
     VIR_ERR_NO_SERVER = 95,             /* Server was not found */
     VIR_ERR_NO_CLIENT = 96,             /* Client was not found */
+    VIR_ERR_INVALID_FS_POOL = 97,        /* invalid fspool object */
+    VIR_ERR_INVALID_FS_ITEM = 98,        /* invalid fspool object */
+    VIR_WAR_NO_FS_POOL = 99,             /* failed to start fspool */
+    VIR_ERR_NO_FS_POOL = 100,            /* fspool not found */
+    VIR_ERR_NO_FS_ITEM = 101,            /* fstem not found */
+    VIR_ERR_FS_ITEM_EXIST = 102,         /* fspool item already exists */
 } virErrorNumber;
 
 /**
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 0539366..6c04343 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -65,6 +65,7 @@ src/internal.h
 src/libvirt-admin.c
 src/libvirt-domain-snapshot.c
 src/libvirt-domain.c
+src/libvirt-fs.c
 src/libvirt-host.c
 src/libvirt-lxc.c
 src/libvirt-network.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 0214995..f963345 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -209,6 +209,7 @@ DRIVER_SOURCES =							\
 		driver-secret.h						\
 		driver-state.h						\
 		driver-storage.h					\
+		driver-fs.h 						\
 		driver-stream.h						\
 		internal.h						\
 		$(DATATYPES_SOURCES)					\
@@ -225,6 +226,7 @@ DRIVER_SOURCES =							\
 		libvirt-secret.c	 				\
 		libvirt-storage.c	 				\
 		libvirt-stream.c	 				\
+		libvirt-fs.c						\
 		locking/lock_manager.c locking/lock_manager.h		\
 		locking/lock_driver.h					\
 		locking/lock_driver_nop.h locking/lock_driver_nop.c	\
@@ -2394,6 +2396,7 @@ libvirt_setuid_rpc_client_la_SOURCES = 		\
 		libvirt-storage.c		\
 		libvirt-stream.c		\
 		libvirt-lxc.c			\
+		libvirt-fs.c			\
 		$(NULL)
 
 libvirt_setuid_rpc_client_la_LDFLAGS =		\
diff --git a/src/datatypes.c b/src/datatypes.c
index ff0c46f..465a8bf 100644
--- a/src/datatypes.c
+++ b/src/datatypes.c
@@ -45,6 +45,8 @@ virClassPtr virSecretClass;
 virClassPtr virStreamClass;
 virClassPtr virStorageVolClass;
 virClassPtr virStoragePoolClass;
+virClassPtr virFsPoolClass;
+virClassPtr virFsItemClass;
 
 static void virConnectDispose(void *obj);
 static void virConnectCloseCallbackDataDispose(void *obj);
@@ -58,6 +60,8 @@ static void virSecretDispose(void *obj);
 static void virStreamDispose(void *obj);
 static void virStorageVolDispose(void *obj);
 static void virStoragePoolDispose(void *obj);
+static void virFsItemDispose(void *obj);
+static void virFsPoolDispose(void *obj);
 
 virClassPtr virAdmConnectClass;
 virClassPtr virAdmConnectCloseCallbackDataClass;
@@ -96,6 +100,8 @@ virDataTypesOnceInit(void)
     DECLARE_CLASS(virStream);
     DECLARE_CLASS(virStorageVol);
     DECLARE_CLASS(virStoragePool);
+    DECLARE_CLASS(virFsItem);
+    DECLARE_CLASS(virFsPool);
 
     DECLARE_CLASS_LOCKABLE(virAdmConnect);
     DECLARE_CLASS_LOCKABLE(virAdmConnectCloseCallbackData);
@@ -597,7 +603,155 @@ virStorageVolDispose(void *obj)
     virObjectUnref(vol->conn);
 }
 
+/**
+ * virGetFsPool:
+ * @conn: the hypervisor connection
+ * @name: pointer to the fs pool name
+ * @uuid: pointer to the uuid
+ * @privateData: pointer to driver specific private data
+ * @freeFunc: private data cleanup function pointer specific to driver
+ *
+ * Allocates a new storage pool object. When the object is no longer needed,
+ * virObjectUnref() must be called in order to not leak data.
+ *
+ * Returns a pointer to the storage pool object, or NULL on error.
+ */
+virFsPoolPtr
+virGetFsPool(virConnectPtr conn, const char *name,
+             const unsigned char *uuid,
+             void *privateData, virFreeCallback freeFunc)
+{
+    virFsPoolPtr ret = NULL;
 
+    if (virDataTypesInitialize() < 0)
+        return NULL;
+
+    virCheckConnectGoto(conn, error);
+    virCheckNonNullArgGoto(name, error);
+    virCheckNonNullArgGoto(uuid, error);
+
+    if (!(ret = virObjectNew(virFsPoolClass)))
+        goto error;
+
+    if (VIR_STRDUP(ret->name, name) < 0)
+        goto error;
+
+    ret->conn = virObjectRef(conn);
+    memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
+
+    /* set the driver specific data */
+    ret->privateData = privateData;
+    ret->privateDataFreeFunc = freeFunc;
+
+    return ret;
+
+ error:
+    virObjectUnref(ret);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolDispose:
+ * @obj: the fs pool to release
+ *
+ * Unconditionally release all memory associated with fs pool.
+ * The pool object must not be used once this method returns.
+ *
+ * It will also unreference the associated connection object,
+ * which may also be released if its ref count hits zero.
+ */
+static void
+virFsPoolDispose(void *obj)
+{
+    virFsPoolPtr fspool = obj;
+    char uuidstr[VIR_UUID_STRING_BUFLEN];
+
+    virUUIDFormat(fspool->uuid, uuidstr);
+    VIR_DEBUG("release fs pool %p %s %s", fspool, fspool->name, uuidstr);
+
+    if (fspool->privateDataFreeFunc)
+        fspool->privateDataFreeFunc(fspool->privateData);
+
+    VIR_FREE(fspool->name);
+    virObjectUnref(fspool->conn);
+}
+
+
+/**
+ * virGetFsItem:
+ * @conn: the hypervisor connection
+ * @pool: fspool owning the item
+ * @name: pointer to the fsitem name
+ * @key: pointer to unique key of the fsitem
+ * @privateData: pointer to driver specific private data
+ * @freeFunc: private data cleanup function pointer specific to driver
+ *
+ * Allocates a new fsitem object. When the object is no longer needed,
+ * virObjectUnref() must be called in order to not leak data.
+ *
+ * Returns a pointer to the fsitem object, or NULL on error.
+ */
+virFsItemPtr
+virGetFsItem(virConnectPtr conn, const char *fspool, const char *name,
+             const char *key, void *privateData, virFreeCallback freeFunc)
+{
+    virFsItemPtr ret = NULL;
+
+    if (virDataTypesInitialize() < 0)
+        return NULL;
+
+    virCheckConnectGoto(conn, error);
+    virCheckNonNullArgGoto(fspool, error);
+    virCheckNonNullArgGoto(name, error);
+    virCheckNonNullArgGoto(key, error);
+
+    if (!(ret = virObjectNew(virFsItemClass)))
+        goto error;
+
+    if (VIR_STRDUP(ret->fspool, fspool) < 0 ||
+        VIR_STRDUP(ret->name, name) < 0 ||
+        VIR_STRDUP(ret->key, key) < 0)
+        goto error;
+
+    ret->conn = virObjectRef(conn);
+
+    /* set driver specific data */
+    ret->privateData = privateData;
+    ret->privateDataFreeFunc = freeFunc;
+
+    return ret;
+
+ error:
+    virObjectUnref(ret);
+    return NULL;
+}
+
+
+/**
+ * virFsItemDispose:
+ * @obj: the fsitem to release
+ *
+ * Unconditionally release all memory associated with a fsitem.
+ * The fsitem object must not be used once this method returns.
+ *
+ * It will also unreference the associated connection object,
+ * which may also be released if its ref count hits zero.
+ */
+static void
+virFsItemDispose(void *obj)
+{
+    virFsItemPtr fsitem = obj;
+    VIR_DEBUG("release vol %p %s", fsitem, fsitem->name);
+
+    if (fsitem->privateDataFreeFunc)
+        fsitem->privateDataFreeFunc(fsitem->privateData);
+
+    VIR_FREE(fsitem->key);
+    VIR_FREE(fsitem->name);
+    VIR_FREE(fsitem->fspool);
+    virObjectUnref(fsitem->conn);
+}
 /**
  * virGetNodeDevice:
  * @conn: the hypervisor connection
diff --git a/src/datatypes.h b/src/datatypes.h
index 996506b..5142e07 100644
--- a/src/datatypes.h
+++ b/src/datatypes.h
@@ -40,6 +40,8 @@ extern virClassPtr virSecretClass;
 extern virClassPtr virStreamClass;
 extern virClassPtr virStorageVolClass;
 extern virClassPtr virStoragePoolClass;
+extern virClassPtr virFsItemClass;
+extern virClassPtr virFsPoolClass;
 
 extern virClassPtr virAdmConnectClass;
 extern virClassPtr virAdmServerClass;
@@ -182,6 +184,46 @@ extern virClassPtr virAdmClientClass;
         }                                                               \
     } while (0)
 
+# define virCheckFsPoolReturn(obj, retval)                              \
+    do {                                                                \
+        virFsPoolPtr _pool = (obj);                                     \
+        if (!virObjectIsClass(_pool, virFsPoolClass) ||                 \
+            !virObjectIsClass(_pool->conn, virConnectClass)) {          \
+            virReportErrorHelper(VIR_FROM_FSPOOL,                       \
+                                 VIR_ERR_INVALID_FS_POOL,               \
+                                 __FILE__, __FUNCTION__, __LINE__,      \
+                                 __FUNCTION__);                         \
+            virDispatchError(NULL);                                     \
+            return retval;                                              \
+        }                                                               \
+    } while (0)
+
+# define virCheckFsItemReturn(obj, retval)                              \
+    do {                                                                \
+        virFsItemPtr _item = (obj);                                     \
+        if (!virObjectIsClass(_item, virFsItemClass) ||                 \
+            !virObjectIsClass(_item->conn, virConnectClass)) {          \
+            virReportErrorHelper(VIR_FROM_FSPOOL,                       \
+                                 VIR_ERR_INVALID_FS_ITEM,               \
+                                 __FILE__, __FUNCTION__, __LINE__,      \
+                                 __FUNCTION__);                         \
+            virDispatchError(NULL);                                     \
+            return retval;                                              \
+        }                                                               \
+    } while (0)
+# define virCheckFsItemGoto(obj, label)                                 \
+    do {                                                                \
+        virFsItemPtr _item = (obj);                                     \
+        if (!virObjectIsClass(_item, virFsItemClass) ||                 \
+            !virObjectIsClass(_item->conn, virConnectClass)) {          \
+            virReportErrorHelper(VIR_FROM_FSPOOL,                       \
+                                 VIR_ERR_INVALID_FS_ITEM,                \
+                                 __FILE__, __FUNCTION__, __LINE__,      \
+                                 __FUNCTION__);                         \
+            goto label;                                                 \
+        }                                                               \
+    } while (0)
+
 # define virCheckNodeDeviceReturn(obj, retval)                          \
     do {                                                                \
         virNodeDevicePtr _node = (obj);                                 \
@@ -444,6 +486,7 @@ struct _virConnect {
     virNodeDeviceDriverPtr nodeDeviceDriver;
     virSecretDriverPtr secretDriver;
     virNWFilterDriverPtr nwfilterDriver;
+    virFsDriverPtr fsDriver;
 
     /* Private data pointer which can be used by driver and
      * network driver as they wish.
@@ -583,6 +626,45 @@ struct _virStorageVol {
 };
 
 /**
+* _virFsPool:
+*
+* Internal structure associated to a fs pool
+*/
+struct _virFsPool {
+    virObject object;
+    virConnectPtr conn;                  /* pointer back to the connection */
+    char *name;                          /* the storage pool external name */
+    unsigned char uuid[VIR_UUID_BUFLEN]; /* the storage pool unique identifier */
+
+    /* Private data pointer which can be used by driver as they wish.
+     * Cleanup function pointer can be hooked to provide custom cleanup
+     * operation.
+     */
+    void *privateData;
+    virFreeCallback privateDataFreeFunc;
+};
+
+/**
+* _virFsItem:
+*
+* Internal structure associated to a fs pool item
+*/
+struct _virFsItem {
+    virObject object;
+    virConnectPtr conn;                  /* pointer back to the connection */
+    char *fspool;                          /* Pool name of owner */
+    char *name;                          /* the storage vol external name */
+    char *key;                           /* unique key for storage vol */
+
+    /* Private data pointer which can be used by driver as they wish.
+     * Cleanup function pointer can be hooked to provide custom cleanup
+     * operation.
+     */
+    void *privateData;
+    virFreeCallback privateDataFreeFunc;
+};
+
+/**
  * _virNodeDevice:
  *
  * Internal structure associated with a node device
@@ -674,6 +756,18 @@ virStorageVolPtr virGetStorageVol(virConnectPtr conn,
                                     const char *key,
                                     void *privateData,
                                     virFreeCallback freeFunc);
+virFsPoolPtr virGetFsPool(virConnectPtr conn,
+                          const char *name,
+                          const unsigned char *uuid,
+                          void *privateData,
+                          virFreeCallback freeFunc);
+virFsItemPtr virGetFsItem(virConnectPtr conn,
+                          const char *pool,
+                          const char *name,
+                          const char *key,
+                          void *privateData,
+                          virFreeCallback freeFunc);
+
 virNodeDevicePtr virGetNodeDevice(virConnectPtr conn,
                                   const char *name);
 virSecretPtr virGetSecret(virConnectPtr conn,
diff --git a/src/driver-fs.h b/src/driver-fs.h
new file mode 100644
index 0000000..1aecb3c
--- /dev/null
+++ b/src/driver-fs.h
@@ -0,0 +1,210 @@
+/*
+ * driver-fs.h: entry points for fs drivers
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __VIR_DRIVER_FS_H__
+# define __VIR_DRIVER_FS_H__
+
+# ifndef __VIR_DRIVER_H_INCLUDES___
+#  error "Don't include this file directly, only use driver.h"
+# endif
+
+typedef int
+(*virDrvConnectNumOfFsPools)(virConnectPtr conn);
+
+typedef int
+(*virDrvConnectListFsPools)(virConnectPtr conn,
+                            char **const names,
+                            int maxnames);
+
+typedef int
+(*virDrvConnectNumOfDefinedFsPools)(virConnectPtr conn);
+
+typedef int
+(*virDrvConnectListDefinedFsPools)(virConnectPtr conn,
+                                   char **const names,
+                                   int maxnames);
+
+typedef int
+(*virDrvConnectListAllFsPools)(virConnectPtr conn,
+                               virFsPoolPtr **pools,
+                               unsigned int flags);
+
+typedef virFsPoolPtr
+(*virDrvFsPoolLookupByName)(virConnectPtr conn,
+                            const char *name);
+
+typedef virFsPoolPtr
+(*virDrvFsPoolLookupByUUID)(virConnectPtr conn,
+                            const unsigned char *uuid);
+typedef virFsPoolPtr
+(*virDrvFsPoolLookupByItem)(virFsItemPtr item);
+
+typedef virFsPoolPtr
+(*virDrvFsPoolCreateXML)(virConnectPtr conn,
+                         const char *xmlDesc,
+                         unsigned int flags);
+
+typedef virFsPoolPtr
+(*virDrvFsPoolDefineXML)(virConnectPtr conn,
+                         const char *xmlDesc,
+                         unsigned int flags);
+
+typedef int
+(*virDrvFsPoolUndefine)(virFsPoolPtr fspool);
+
+typedef int
+(*virDrvFsPoolBuild)(virFsPoolPtr fspool,
+                     unsigned int flags);
+
+typedef int
+(*virDrvFsPoolCreate)(virFsPoolPtr fspool,
+                     unsigned int flags);
+typedef int
+(*virDrvFsPoolDestroy)(virFsPoolPtr fspool);
+typedef int
+(*virDrvFsPoolRefresh)(virFsPoolPtr fspool,
+                       unsigned int flags);
+
+typedef int
+(*virDrvFsPoolDelete)(virFsPoolPtr fspool,
+                      unsigned int flags);
+
+typedef int
+(*virDrvFsPoolGetInfo)(virFsPoolPtr item,
+                       virFsPoolInfoPtr info);
+
+typedef char *
+(*virDrvFsPoolGetXMLDesc)(virFsPoolPtr fspool,
+                          unsigned int flags);
+typedef int
+(*virDrvFsPoolGetAutostart)(virFsPoolPtr fspool,
+                            int *autostart);
+typedef int
+(*virDrvFsPoolSetAutostart)(virFsPoolPtr fspool,
+                            int autostart);
+
+typedef int
+(*virDrvFsPoolNumOfItems)(virFsPoolPtr fspool);
+
+typedef int
+(*virDrvFsPoolListItems)(virFsPoolPtr fspool,
+                           char **const names,
+                           int maxnames);
+
+typedef int
+(*virDrvFsPoolListAllItems)(virFsPoolPtr fspool,
+                            virFsItemPtr **items,
+                            unsigned int flags);
+
+typedef virFsItemPtr
+(*virDrvFsItemLookupByName)(virFsPoolPtr fspool,
+                            const char *name);
+
+typedef virFsItemPtr
+(*virDrvFsItemLookupByKey)(virConnectPtr fspool,
+                           const char *key);
+
+typedef virFsItemPtr
+(*virDrvFsItemLookupByPath)(virConnectPtr fspool,
+                            const char *path);
+
+typedef virFsItemPtr
+(*virDrvFsItemCreateXML)(virFsPoolPtr fspool,
+                         const char *xmldesc,
+                         unsigned int flags);
+
+typedef int
+(*virDrvFsItemDelete)(virFsItemPtr item,
+                      unsigned int flags);
+
+
+typedef int
+(*virDrvFsItemGetInfo)(virFsItemPtr item,
+                       virFsItemInfoPtr info);
+
+typedef char *
+(*virDrvFsItemGetXMLDesc)(virFsItemPtr fspool,
+                          unsigned int flags);
+
+typedef char *
+(*virDrvFsItemGetPath)(virFsItemPtr item);
+
+typedef virFsItemPtr
+(*virDrvFsItemCreateXMLFrom)(virFsPoolPtr fspool,
+                             const char *xmldesc,
+                             virFsItemPtr cloneitem,
+                             unsigned int flags);
+
+typedef struct _virFsDriver virFsDriver;
+typedef virFsDriver *virFsDriverPtr;
+
+typedef int
+(*virDrvFsPoolIsActive)(virFsPoolPtr fspool);
+
+typedef int
+(*virDrvFsPoolIsPersistent)(virFsPoolPtr fspool);
+
+
+
+/**
+ * _virFsDriver:
+ *
+ * Structure associated to a storage driver, defining the various
+ * entry points for it.
+ */
+struct _virFsDriver {
+    const char *name; /* the name of the driver */
+    virDrvConnectNumOfFsPools connectNumOfFsPools;
+    virDrvConnectListFsPools connectListFsPools;
+    virDrvConnectNumOfDefinedFsPools connectNumOfDefinedFsPools;
+    virDrvConnectListDefinedFsPools connectListDefinedFsPools;
+    virDrvConnectListAllFsPools connectListAllFsPools;
+    virDrvFsPoolLookupByName fsPoolLookupByName;
+    virDrvFsPoolLookupByUUID fsPoolLookupByUUID;
+    virDrvFsPoolLookupByItem fsPoolLookupByItem;
+    virDrvFsPoolCreateXML fsPoolCreateXML;
+    virDrvFsPoolDefineXML fsPoolDefineXML;
+    virDrvFsPoolBuild fsPoolBuild;
+    virDrvFsPoolUndefine fsPoolUndefine;
+    virDrvFsPoolCreate fsPoolCreate;
+    virDrvFsPoolDestroy fsPoolDestroy;
+    virDrvFsPoolDelete fsPoolDelete;
+    virDrvFsPoolRefresh fsPoolRefresh;
+    virDrvFsPoolGetInfo fsPoolGetInfo;
+    virDrvFsPoolGetXMLDesc fsPoolGetXMLDesc;
+    virDrvFsPoolGetAutostart fsPoolGetAutostart;
+    virDrvFsPoolSetAutostart fsPoolSetAutostart;
+    virDrvFsPoolNumOfItems fsPoolNumOfItems;
+    virDrvFsPoolListItems fsPoolListItems;
+    virDrvFsPoolListAllItems fsPoolListAllItems;
+    virDrvFsItemLookupByName fsItemLookupByName;
+    virDrvFsItemLookupByKey fsItemLookupByKey;
+    virDrvFsItemLookupByPath fsItemLookupByPath;
+    virDrvFsItemCreateXML fsItemCreateXML;
+    virDrvFsItemCreateXMLFrom fsItemCreateXMLFrom;
+    virDrvFsItemDelete fsItemDelete;
+    virDrvFsItemGetInfo fsItemGetInfo;
+    virDrvFsItemGetXMLDesc fsItemGetXMLDesc;
+    virDrvFsItemGetPath fsItemGetPath;
+    virDrvFsPoolIsActive fsPoolIsActive;
+    virDrvFsPoolIsPersistent fsPoolIsPersistent;
+};
+
+
+#endif /* __VIR_DRIVER_STORAGE_H__ */
diff --git a/src/driver.h b/src/driver.h
index e4e382b..fb93083 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -72,6 +72,7 @@ typedef enum {
 # include "driver-state.h"
 # include "driver-stream.h"
 # include "driver-storage.h"
+# include "driver-fs.h"
 
 # undef __VIR_DRIVER_H_INCLUDES___
 
diff --git a/src/libvirt-fs.c b/src/libvirt-fs.c
new file mode 100644
index 0000000..4432cfd
--- /dev/null
+++ b/src/libvirt-fs.c
@@ -0,0 +1,1715 @@
+/*
+ * libvirt-fs.c: entry points for virFs{Pool, Item}Ptr APIs
+ *
+ * Copyright (C) 2006-2015 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include "datatypes.h"
+#include "virlog.h"
+
+VIR_LOG_INIT("libvirt.fs");
+
+#define VIR_FROM_THIS VIR_FROM_FSPOOL
+
+
+/**
+ * virFsPoolGetConnect:
+ * @fspool: pointer to a fspool
+ *
+ * Provides the connection pointer associated with fspool.  The
+ * reference counter on the connection is not increased by this
+ * call.
+ * Returns the virConnectPtr or NULL in case of failure.
+ */
+virConnectPtr
+virFsPoolGetConnect(virFsPoolPtr fspool)
+{
+    VIR_DEBUG("fspool=%p", fspool);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, NULL);
+
+    return fspool->conn;
+}
+
+
+/**
+ * virConnectListAllFsPools:
+ * @conn: Pointer to the hypervisor connection.
+ * @fspools: Pointer to a variable to store the array containing fspool
+ *         objects or NULL if the list is not required (just returns number
+ *         of fspools).
+ * @flags: bitwise-OR of virConnectListAllFsPoolsFlags.
+ *
+ * Collect the list of fspools, and allocate an array to store those
+ * objects. This API solves the race inherent between
+ * virConnectListFsPools and virConnectListDefinedFsPools.
+ *
+ * Normally, all fspools are returned; however, @flags can be used to
+ * filter the results for a smaller list of targeted fspools.  The valid
+ * flags are divided into groups, where each group contains bits that
+ * describe mutually exclusive attributes of a fspool, and where all bits
+ * within a group describe all possible fspools.
+ *
+ * The only group (at the moment) of @flags is provided to filter the fspools by the types,
+ * the flags include:
+ * VIR_CONNECT_LIST_FS_POOLS_DIR
+ * VIR_CONNECT_LIST_FS_POOLS_VOLUME
+ * VIR_CONNECT_LIST_FS_POOLS_NETFS
+ *
+ * Returns the number of fs fspools found or -1 and sets @fspools to
+ * NULL in case of error.  On success, the array stored into @fspools is
+ * guaranteed to have an extra allocated element set to NULL but not included
+ * in the return count, to make iteration easier.  The caller is responsible
+ * for calling virFsPoolFree() on each array element, then calling
+ * free() on @fspools.
+ */
+int
+virConnectListAllFsPools(virConnectPtr conn,
+                         virFsPoolPtr **fspools,
+                         unsigned int flags)
+{
+    VIR_DEBUG("conn=%p, fspools=%p, flags=%x", conn, fspools, flags);
+
+    virResetLastError();
+
+    if (fspools)
+        *fspools = NULL;
+
+    virCheckConnectReturn(conn, -1);
+
+    if (conn->fsDriver &&
+        conn->fsDriver->connectListAllFsPools) {
+        int ret;
+        ret = conn->fsDriver->connectListAllFsPools(conn, fspools, flags);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return -1;
+}
+
+
+/**
+ * virConnectNumOfFsPools:
+ * @conn: pointer to hypervisor connection
+ *
+ * Provides the number of active fspools
+ *
+ * Returns the number of fspools found, or -1 on error
+ */
+int
+virConnectNumOfFsPools(virConnectPtr conn)
+{
+    VIR_DEBUG("conn=%p", conn);
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, -1);
+
+    if (conn->fsDriver && conn->fsDriver->connectNumOfFsPools) {
+        int ret;
+        ret = conn->fsDriver->connectNumOfFsPools(conn);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return -1;
+}
+
+
+/**
+ * virConnectListFsPools:
+ * @conn: pointer to hypervisor connection
+ * @names: array of char * to fill with fspool names (allocated by caller)
+ * @maxnames: size of the names array
+ *
+ * Provides the list of names of active fspools up to maxnames.
+ * If there are more than maxnames, the remaining names will be silently
+ * ignored.
+ *
+ * For more control over the results, see virConnectListAllFsPools().
+ *
+ * Returns the number of fspools found or -1 in case of error.  Note that
+ * this command is inherently racy; a fspool can be started between a call to
+ * virConnectNumOfFsPools() and this call; you are only guaranteed
+ * that all currently active fspools were listed if the return is less than
+ * @maxnames. The client must call free() on each returned name.
+ */
+int
+virConnectListFsPools(virConnectPtr conn,
+                      char **const names,
+                      int maxnames)
+{
+    VIR_DEBUG("conn=%p, names=%p, maxnames=%d", conn, names, maxnames);
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, -1);
+    virCheckNonNullArgGoto(names, error);
+    virCheckNonNegativeArgGoto(maxnames, error);
+
+    if (conn->fsDriver && conn->fsDriver->connectListFsPools) {
+        int ret;
+        ret = conn->fsDriver->connectListFsPools(conn, names, maxnames);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return -1;
+}
+
+
+/**
+ * virConnectNumOfDefinedFsPools:
+ * @conn: pointer to hypervisor connection
+ *
+ * Provides the number of inactive fs fspools
+ *
+ * Returns the number of fspools found, or -1 on error
+ */
+int
+virConnectNumOfDefinedFsPools(virConnectPtr conn)
+{
+    VIR_DEBUG("conn=%p", conn);
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, -1);
+
+    if (conn->fsDriver && conn->fsDriver->connectNumOfDefinedFsPools) {
+        int ret;
+        ret = conn->fsDriver->connectNumOfDefinedFsPools(conn);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return -1;
+}
+
+
+/**
+ * virConnectListDefinedFsPools:
+ * @conn: pointer to hypervisor connection
+ * @names: array of char * to fill with fspool names (allocated by caller)
+ * @maxnames: size of the names array
+ *
+ * Provides the list of names of inactive fspools up to maxnames.
+ * If there are more than maxnames, the remaining names will be silently
+ * ignored.
+ *
+ * For more control over the results, see virConnectListAllFsPools().
+ *
+ * Returns the number of names provided in the array or -1 in case of error.
+ * Note that this command is inherently racy; a fspool can be defined between
+ * a call to virConnectNumOfDefinedFsPools() and this call; you are only
+ * guaranteed that all currently defined fspools were listed if the return
+ * is less than @maxnames.  The client must call free() on each returned name.
+ */
+int
+virConnectListDefinedFsPools(virConnectPtr conn,
+                             char **const names,
+                             int maxnames)
+{
+    VIR_DEBUG("conn=%p, names=%p, maxnames=%d", conn, names, maxnames);
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, -1);
+    virCheckNonNullArgGoto(names, error);
+    virCheckNonNegativeArgGoto(maxnames, error);
+
+    if (conn->fsDriver && conn->fsDriver->connectListDefinedFsPools) {
+        int ret;
+        ret = conn->fsDriver->connectListDefinedFsPools(conn, names, maxnames);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return -1;
+}
+
+/**
+ * virFsPoolLookupByName:
+ * @conn: pointer to hypervisor connection
+ * @name: name of fspool to fetch
+ *
+ * Fetch fspool based on its unique name
+ *
+ * virFsPoolFree should be used to free the resources after the
+ * fs fspool object is no longer needed.
+ *
+ * Returns a virFsPoolPtr object, or NULL if no matching fspool is found
+ */
+virFsPoolPtr
+virFsPoolLookupByName(virConnectPtr conn,
+                      const char *name)
+{
+    VIR_DEBUG("conn=%p, name=%s", conn, NULLSTR(name));
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, NULL);
+    virCheckNonNullArgGoto(name, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolLookupByName) {
+        virFsPoolPtr ret;
+        ret = conn->fsDriver->fsPoolLookupByName(conn, name);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolLookupByUUID:
+ * @conn: pointer to hypervisor connection
+ * @uuid: globally unique id of fspool to fetch
+ *
+ * Fetch a fspool based on its globally unique id
+ *
+ * virFsPoolFree should be used to free the resources after the
+ * fs fspool object is no longer needed.
+ *
+ * Returns a virFsPoolPtr object, or NULL if no matching fspool is found
+ */
+virFsPoolPtr
+virFsPoolLookupByUUID(virConnectPtr conn,
+                      const unsigned char *uuid)
+{
+    VIR_UUID_DEBUG(conn, uuid);
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, NULL);
+    virCheckNonNullArgGoto(uuid, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolLookupByUUID) {
+        virFsPoolPtr ret;
+        ret = conn->fsDriver->fsPoolLookupByUUID(conn, uuid);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolLookupByUUIDString:
+ * @conn: pointer to hypervisor connection
+ * @uuidstr: globally unique id of fspool to fetch
+ *
+ * Fetch a fs fspool based on its globally unique id
+ *
+ * virFsPoolFree should be used to free the resources after the
+ * fs fspool object is no longer needed.
+ *
+ * Returns a virFsPoolPtr object, or NULL if no matching fspool is found
+ */
+virFsPoolPtr
+virFsPoolLookupByUUIDString(virConnectPtr conn,
+                            const char *uuidstr)
+{
+    unsigned char uuid[VIR_UUID_BUFLEN];
+    VIR_DEBUG("conn=%p, uuidstr=%s", conn, NULLSTR(uuidstr));
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, NULL);
+    virCheckNonNullArgGoto(uuidstr, error);
+
+    if (virUUIDParse(uuidstr, uuid) < 0) {
+        virReportInvalidArg(uuidstr,
+                            _("uuidstr in %s must be a valid UUID"),
+                            __FUNCTION__);
+        goto error;
+    }
+
+    return virFsPoolLookupByUUID(conn, uuid);
+
+ error:
+    virDispatchError(conn);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolLookupByItem:
+ * @item: pointer to fspool item
+ *
+ * Fetch a fspool which contains a particular item
+ *
+ * virFsPoolFree should be used to free the resources after the
+ * fspool object is no longer needed.
+ *
+ * Returns a virFsPoolPtr object, or NULL if no matching fspool is found
+ */
+virFsPoolPtr
+virFsPoolLookupByItem(virFsItemPtr item)
+{
+    VIR_DEBUG("item=%p", item);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, NULL);
+
+    if (item->conn->fsDriver && item->conn->fsDriver->fsPoolLookupByItem) {
+        virFsPoolPtr ret;
+        ret = item->conn->fsDriver->fsPoolLookupByItem(item);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(item->conn);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolCreateXML:
+ * @conn: pointer to hypervisor connection
+ * @xmlDesc: XML description for new fspool
+ * @flags: bitwise-OR of virFsPoolCreateFlags
+ *
+ * Create a new fspool based on its XML description. The
+ * fspool is not persistent, so its definition will disappear
+ * when it is destroyed, or if the host is restarted
+ *
+ * virFsPoolFree should be used to free the resources after the
+ *fspool object is no longer needed.
+ *
+ * Returns a virFsPoolPtr object, or NULL if creation failed
+ */
+virFsPoolPtr
+virFsPoolCreateXML(virConnectPtr conn,
+                   const char *xmlDesc,
+                   unsigned int flags)
+{
+    VIR_DEBUG("conn=%p, xmlDesc=%s, flags=%x", conn, NULLSTR(xmlDesc), flags);
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, NULL);
+    virCheckNonNullArgGoto(xmlDesc, error);
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolCreateXML) {
+        virFsPoolPtr ret;
+        ret = conn->fsDriver->fsPoolCreateXML(conn, xmlDesc, flags);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolDefineXML:
+ * @conn: pointer to hypervisor connection
+ * @xml: XML description for new fspool
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * Define an inactive persistent fspool or modify an existing persistent
+ * one from the XML description.
+ *
+ * virFsPoolFree should be used to free the resources after the
+ * fspool object is no longer needed.
+ *
+ * Returns a virFsPoolPtr object, or NULL if creation failed
+ */
+virFsPoolPtr
+virFsPoolDefineXML(virConnectPtr conn,
+                   const char *xml,
+                   unsigned int flags)
+{
+    VIR_DEBUG("conn=%p, xml=%s, flags=%x", conn, NULLSTR(xml), flags);
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, NULL);
+    virCheckReadOnlyGoto(conn->flags, error);
+    virCheckNonNullArgGoto(xml, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolDefineXML) {
+        virFsPoolPtr ret;
+        ret = conn->fsDriver->fsPoolDefineXML(conn, xml, flags);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolBuild:
+ * @fspool: pointer to fspool
+ * @flags: bitwise-OR of virFsPoolBuildFlags
+ *
+ * Build the underlying fspool
+ *
+ * Returns 0 on success, or -1 upon failure
+ */
+int
+virFsPoolBuild(virFsPoolPtr fspool,
+               unsigned int flags)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p, flags=%x", fspool, flags);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    conn = fspool->conn;
+
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolBuild) {
+        int ret;
+        ret = conn->fsDriver->fsPoolBuild(fspool, flags);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+/**
+ * virFsPoolRefresh:
+ * @fspool: pointer to fspool
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * Request that the fspool refresh its list of itemms. This may
+ * involve communicating with a remote server, and/or initializing
+ * new devices at the OS layer
+ *
+ * Returns 0 if the items list was refreshed, -1 on failure
+ */
+int
+virFsPoolRefresh(virFsPoolPtr fspool,
+                 unsigned int flags)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p, flags=%x", fspool, flags);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    conn = fspool->conn;
+
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolRefresh) {
+        int ret;
+        ret = conn->fsDriver->fsPoolRefresh(fspool, flags);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+/**
+ * virFsPoolUndefine:
+ * @fspool: pointer to fspool
+ *
+ * Undefine an inactive fspool
+ *
+ * Returns 0 on success, -1 on failure
+ */
+int
+virFsPoolUndefine(virFsPoolPtr fspool)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p", fspool);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    conn = fspool->conn;
+
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolUndefine) {
+        int ret;
+        ret = conn->fsDriver->fsPoolUndefine(fspool);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+/**
+ * virFsPoolCreate:
+ * @fspool: pointer to fspool
+ * @flags: bitwise-OR of virFsPoolCreateFlags
+ *
+ * Starts an inactive fspool
+ *
+ * Returns 0 on success, or -1 if it could not be started
+ */
+int
+virFsPoolCreate(virFsPoolPtr fspool,
+                     unsigned int flags)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p, flags=%x", fspool, flags);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    conn = fspool->conn;
+
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolCreate) {
+        int ret;
+        ret = conn->fsDriver->fsPoolCreate(fspool, flags);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+/**
+ * virFsPoolDestroy:
+ * @fspool: pointer to fspool
+ *
+ * Destroy an active fspool. This will deactivate the
+ * fspool on the host, but keep any persistent config associated
+ * with it. If it has a persistent config it can later be
+ * restarted with virFsPoolCreate(). This does not free
+ * the associated virFsPoolPtr object.
+ *
+ * Returns 0 on success, or -1 if it could not be destroyed
+ */
+int
+virFsPoolDestroy(virFsPoolPtr fspool)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p", fspool);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    conn = fspool->conn;
+
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolDestroy) {
+        int ret;
+        ret = conn->fsDriver->fsPoolDestroy(fspool);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+/**
+ * virFsPoolDelete:
+ * @fspool: pointer to fspool
+ * @flags: bitwise-OR of virFsPoolDeleteFlags
+ *
+ * Delete the underlying fspool resources. This is
+ * a non-recoverable operation. The virFsPoolPtr object
+ * itself is not free'd.
+ *
+ * Returns 0 on success, or -1 if it could not be obliterate
+ */
+int
+virFsPoolDelete(virFsPoolPtr fspool,
+                unsigned int flags)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p, flags=%x", fspool, flags);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    conn = fspool->conn;
+
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolDelete) {
+        int ret;
+        ret = conn->fsDriver->fsPoolDelete(fspool, flags);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+
+/**
+ * virFsPoolFree:
+ * @fspool: pointer to fspool
+ *
+ * Free a fs fspool object, releasing all memory associated with
+ * it. Does not change the state of the fspool on the host.
+ *
+ * Returns 0 on success, or -1 if it could not be free'd.
+ */
+int
+virFsPoolFree(virFsPoolPtr fspool)
+{
+    VIR_DEBUG("fspool=%p", fspool);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+
+    virObjectUnref(fspool);
+    return 0;
+
+}
+
+
+/**
+ * virFsPoolRef:
+ * @fspool: the fspool to hold a reference on
+ *
+ * Increment the reference count on the fspool. For each
+ * additional call to this method, there shall be a corresponding
+ * call to virFsPoolFree to release the reference count, once
+ * the caller no longer needs the reference to this object.
+ *
+ * This method is typically useful for applications where multiple
+ * threads are using a connection, and it is required that the
+ * connection remain open until all threads have finished using
+ * it. ie, each new thread using a fspool would increment
+ * the reference count.
+ *
+ * Returns 0 in case of success, -1 in case of failure.
+ */
+int
+virFsPoolRef(virFsPoolPtr fspool)
+{
+    VIR_DEBUG("fspool=%p refs=%d", fspool, fspool ? fspool->object.u.s.refs : 0);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+
+    virObjectRef(fspool);
+    return 0;
+}
+
+/**
+ * virFsPoolGetName:
+ * @fspool: pointer to fs fspool
+ *
+ * Fetch the locally unique name of the fs fspool
+ *
+ * Returns the name of the fspool, or NULL on error
+ */
+const char*
+virFsPoolGetName(virFsPoolPtr fspool)
+{
+    VIR_DEBUG("fspool=%p", fspool);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, NULL);
+
+    return fspool->name;
+}
+
+
+/**
+ * virFsPoolGetUUID:
+ * @fspool: pointer to fspool
+ * @uuid: buffer of VIR_UUID_BUFLEN bytes in size
+ *
+ * Fetch the globally unique ID of the fspool
+ *
+ * Returns 0 on success, or -1 on error;
+ */
+int
+virFsPoolGetUUID(virFsPoolPtr fspool,
+                 unsigned char *uuid)
+{
+    VIR_DEBUG("fspool=%p, uuid=%p", fspool, uuid);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    virCheckNonNullArgGoto(uuid, error);
+
+    memcpy(uuid, &fspool->uuid[0], VIR_UUID_BUFLEN);
+
+    return 0;
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+
+/**
+ * virFsPoolGetUUIDString:
+ * @fspool: pointer to fspool
+ * @buf: buffer of VIR_UUID_STRING_BUFLEN bytes in size
+ *
+ * Fetch the globally unique ID of the fspool as a string
+ *
+ * Returns 0 on success, or -1 on error;
+ */
+int
+virFsPoolGetUUIDString(virFsPoolPtr fspool,
+                       char *buf)
+{
+    VIR_DEBUG("fspool=%p, buf=%p", fspool, buf);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    virCheckNonNullArgGoto(buf, error);
+
+    virUUIDFormat(fspool->uuid, buf);
+    return 0;
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+
+/**
+ * virFsPoolGetInfo:
+ * @fspool: pointer to fs fspool
+ * @info: pointer at which to store info
+ *
+ * Get information about the fspool
+ * such as free space / usage summary
+ *
+ * Returns 0 on success, or -1 on failure.
+ */
+int
+virFsPoolGetInfo(virFsPoolPtr fspool,
+                 virFsPoolInfoPtr info)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p, info=%p", fspool, info);
+
+    virResetLastError();
+
+    if (info)
+        memset(info, 0, sizeof(*info));
+
+    virCheckFsPoolReturn(fspool, -1);
+    virCheckNonNullArgGoto(info, error);
+
+    conn = fspool->conn;
+
+    if (conn->fsDriver->fsPoolGetInfo) {
+        int ret;
+        ret = conn->fsDriver->fsPoolGetInfo(fspool, info);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+/**
+ * virFsPoolGetAutostart:
+ * @fspool: pointer to fspool
+ * @autostart: location in which to store autostart flag
+ *
+ * Fetches the value of the autostart flag, which determines
+ * whether the fspool is automatically started at boot time
+ *
+ * Returns 0 on success, -1 on failure
+ */
+int
+virFsPoolGetAutostart(virFsPoolPtr fspool,
+                           int *autostart)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p, autostart=%p", fspool, autostart);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    virCheckNonNullArgGoto(autostart, error);
+
+    conn = fspool->conn;
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolGetAutostart) {
+        int ret;
+        ret = conn->fsDriver->fsPoolGetAutostart(fspool, autostart);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+
+/**
+ * virFsPoolSetAutostart:
+ * @fspool: pointer to fspool
+ * @autostart: new flag setting
+ *
+ * Sets the autostart flag
+ *
+ * Returns 0 on success, -1 on failure
+ */
+int
+virFsPoolSetAutostart(virFsPoolPtr fspool,
+                           int autostart)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p, autostart=%d", fspool, autostart);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    conn = fspool->conn;
+
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolSetAutostart) {
+        int ret;
+        ret = conn->fsDriver->fsPoolSetAutostart(fspool, autostart);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+/**
+ * virFsPoolGetXMLDesc:
+ * @fspool: pointer to fspool
+ * @flags: bitwise-OR of virFsXMLFlags
+ *
+ * Fetch an XML document describing all aspects of the
+ * fs fspool. This is suitable for later feeding back
+ * into the virFsPoolCreateXML method.
+ *
+ * Returns a XML document (caller frees), or NULL on error
+ */
+char *
+virFsPoolGetXMLDesc(virFsPoolPtr fspool,
+                    unsigned int flags)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("fspool=%p, flags=%x", fspool, flags);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, NULL);
+    conn = fspool->conn;
+
+    if (conn->fsDriver && conn->fsDriver->fsPoolGetXMLDesc) {
+        char *ret;
+        ret = conn->fsDriver->fsPoolGetXMLDesc(fspool, flags);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolListAllItems:
+ * @fspool: Pointer to fspool
+ * @items: Pointer to a variable to store the array containing fs item
+ *        objects or NULL if the list is not required (just returns number
+ *        of items).
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * Collect the list of fsitems, and allocate an array to store those
+ * objects.
+ *
+ * Returns the number of fs items found or -1 and sets @items to
+ * NULL in case of error.  On success, the array stored into @items is
+ * guaranteed to have an extra allocated element set to NULL but not included
+ * in the return count, to make iteration easier.  The caller is responsible
+ * for calling virFsItemFree() on each array element, then calling
+ * free() on @items.
+ */
+int
+virFsPoolListAllItems(virFsPoolPtr fspool,
+                      virFsItemPtr **items,
+                      unsigned int flags)
+{
+    VIR_DEBUG("fspool=%p, items=%p, flags=%x", fspool, items, flags);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+
+    if (fspool->conn->fsDriver &&
+        fspool->conn->fsDriver->fsPoolListAllItems) {
+        int ret;
+        ret = fspool->conn->fsDriver->fsPoolListAllItems(fspool, items, flags);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+
+/**
+ * virFsPoolNumOfItems:
+ * @fspool: pointer to fspool
+ *
+ * Fetch the number of items within a fspool
+ *
+ * Returns the number of fspools, or -1 on failure
+ */
+int
+virFsPoolNumOfItems(virFsPoolPtr fspool)
+{
+    VIR_DEBUG("fspool=%p", fspool);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+
+    if (fspool->conn->fsDriver && fspool->conn->fsDriver->fsPoolNumOfItems) {
+        int ret;
+        ret = fspool->conn->fsDriver->fsPoolNumOfItems(fspool);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+
+/**
+ * virFsPoolListItems:
+ * @fspool: pointer to fspool
+ * @names: array in which to fsitem names
+ * @maxnames: size of names array
+ *
+ * Fetch list of fs item names, limiting to
+ * at most maxnames.
+ *
+ * To list the item objects directly, see virFsPoolListAllItems().
+ *
+ * Returns the number of names fetched, or -1 on error
+ */
+int
+virFsPoolListItems(virFsPoolPtr fspool,
+                   char **const names,
+                   int maxnames)
+{
+    VIR_DEBUG("fspool=%p, names=%p, maxnames=%d", fspool, names, maxnames);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+    virCheckNonNullArgGoto(names, error);
+    virCheckNonNegativeArgGoto(maxnames, error);
+
+    if (fspool->conn->fsDriver && fspool->conn->fsDriver->fsPoolListItems) {
+        int ret;
+        ret = fspool->conn->fsDriver->fsPoolListItems(fspool, names, maxnames);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+
+/**
+ * virFsItemGetConnect:
+ * @item: pointer to a fspool
+ *
+ * Provides the connection pointer associated with a fs item.  The
+ * reference counter on the connection is not increased by this
+ * call.
+ *
+ * WARNING: When writing libvirt bindings in other languages, do
+ * not use this function.  Instead, store the connection and
+ * the item object together.
+ *
+ * Returns the virConnectPtr or NULL in case of failure.
+ */
+virConnectPtr
+virFsItemGetConnect(virFsItemPtr item)
+{
+    VIR_DEBUG("item=%p", item);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, NULL);
+
+    return item->conn;
+}
+
+
+/**
+ * virFsItemLookupByName:
+ * @fspool: pointer to fspool
+ * @name: name of fsitem
+ *
+ * Fetch a pointer to a fs item based on its name
+ * within a fspool
+ *
+ * virFsItemFree should be used to free the resources after the
+ * fs item object is no longer needed.
+ *
+ * Returns a fsitem, or NULL if not found / error
+ */
+virFsItemPtr
+virFsItemLookupByName(virFsPoolPtr fspool,
+                      const char *name)
+{
+    VIR_DEBUG("fspool=%p, name=%s", fspool, NULLSTR(name));
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, NULL);
+    virCheckNonNullArgGoto(name, error);
+
+    if (fspool->conn->fsDriver && fspool->conn->fsDriver->fsItemLookupByName) {
+        virFsItemPtr ret;
+        ret = fspool->conn->fsDriver->fsItemLookupByName(fspool, name);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return NULL;
+}
+
+
+/**
+ * virFsItemLookupByKey:
+ * @conn: pointer to hypervisor connection
+ * @key: globally unique key
+ *
+ * Fetch a pointer to a fspool item based on its
+ * globally unique key
+ *
+ * virFsItemFree should be used to free the resources after the
+ * fs item object is no longer needed.
+ *
+ * Returns a fs item, or NULL if not found / error
+ */
+virFsItemPtr
+virFsItemLookupByKey(virConnectPtr conn,
+                     const char *key)
+{
+    VIR_DEBUG("conn=%p, key=%s", conn, NULLSTR(key));
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, NULL);
+    virCheckNonNullArgGoto(key, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsItemLookupByKey) {
+        virFsItemPtr ret;
+        ret = conn->fsDriver->fsItemLookupByKey(conn, key);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return NULL;
+}
+
+
+/**
+ * virFsItemLookupByPath:
+ * @conn: pointer to hypervisor connection
+ * @path: locally unique path
+ *
+ * Fetch a pointer to a fs item based on its
+ * locally (host) unique path
+ *
+ * virFsItemFree should be used to free the resources after the
+ * fs item object is no longer needed.
+ *
+ * Returns a fs item, or NULL if not found / error
+ */
+virFsItemPtr
+virFsItemLookupByPath(virConnectPtr conn,
+                      const char *path)
+{
+    VIR_DEBUG("conn=%p, path=%s", conn, NULLSTR(path));
+
+    virResetLastError();
+
+    virCheckConnectReturn(conn, NULL);
+    virCheckNonNullArgGoto(path, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsItemLookupByPath) {
+        virFsItemPtr ret;
+        ret = conn->fsDriver->fsItemLookupByPath(conn, path);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(conn);
+    return NULL;
+}
+
+
+/**
+ * virFsItemGetName:
+ * @item: pointer to fsitem
+ *
+ * Fetch the fsitem name. This is unique
+ * within the scope of a fspool
+ *
+ * Returns the item name, or NULL on error
+ */
+const char*
+virFsItemGetName(virFsItemPtr item)
+{
+    VIR_DEBUG("item=%p", item);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, NULL);
+
+    return item->name;
+}
+
+
+/**
+ * virFsItemGetKey:
+ * @item: pointer to fspool item
+ *
+ * Fetch the fsitem key. This is globally
+ * unique, so the same item will have the same
+ * key no matter what host it is accessed from
+ *
+ * Returns the item key, or NULL on error
+ */
+const char*
+virFsItemGetKey(virFsItemPtr item)
+{
+    VIR_DEBUG("item=%p", item);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, NULL);
+
+    return item->key;
+}
+
+
+/**
+ * virFsItemCreateXML:
+ * @fspool: pointer to fspool
+ * @xmlDesc: description of item to create
+ * @flags: bitwise-OR of virFsItemCreateFlags
+ *
+ * Create a fs item within a fspool based
+ * on an XML description.
+ *
+ * virFsItemFree should be used to free the resources after the
+ * fs item object is no longer needed.
+ *
+ * Returns the fs item, or NULL on error
+ */
+virFsItemPtr
+virFsItemCreateXML(virFsPoolPtr fspool,
+                   const char *xmlDesc,
+                   unsigned int flags)
+{
+    VIR_DEBUG("fspool=%p, xmlDesc=%s, flags=%x", fspool, NULLSTR(xmlDesc), flags);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, NULL);
+    virCheckNonNullArgGoto(xmlDesc, error);
+    virCheckReadOnlyGoto(fspool->conn->flags, error);
+
+    if (fspool->conn->fsDriver && fspool->conn->fsDriver->fsItemCreateXML) {
+        virFsItemPtr ret;
+        ret = fspool->conn->fsDriver->fsItemCreateXML(fspool, xmlDesc, flags);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return NULL;
+}
+
+
+/**
+ * virFsItemCreateXMLFrom:
+ * @fspool: pointer to parent fspool for the new item
+ * @xmlDesc: description of item to create
+ * @cloneitem: fspool item to use as input
+ * @flags: bitwise-OR of virFsItemCreateFlags
+ *
+ * Create a fs item in the parent fspool, using the
+ * 'cloneitem' item as input. Information for the new
+ * item (name, perms)  are passed via a typical item
+ * XML description.
+ *
+ * virFsItemFree should be used to free the resources after the
+ * fs item object is no longer needed.
+ *
+ * Returns the fs item, or NULL on error
+ */
+virFsItemPtr
+virFsItemCreateXMLFrom(virFsPoolPtr fspool,
+                       const char *xmlDesc,
+                       virFsItemPtr cloneitem,
+                       unsigned int flags)
+{
+    VIR_DEBUG("fspool=%p, xmlDesc=%s, cloneitem=%p, flags=%x",
+              fspool, NULLSTR(xmlDesc), cloneitem, flags);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, NULL);
+    virCheckFsItemGoto(cloneitem, error);
+    virCheckNonNullArgGoto(xmlDesc, error);
+    virCheckReadOnlyGoto(fspool->conn->flags | cloneitem->conn->flags, error);
+
+    if (fspool->conn->fsDriver &&
+        fspool->conn->fsDriver->fsItemCreateXMLFrom) {
+        virFsItemPtr ret;
+        ret = fspool->conn->fsDriver->fsItemCreateXMLFrom(fspool, xmlDesc,
+                                                          cloneitem, flags);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(fspool->conn);
+    return NULL;
+}
+
+/**
+ * virFsItemDelete:
+ * @item: pointer to fspool item
+ * @flags: bitwise-OR of virFsItemDeleteFlags
+ *
+ * Delete the fs item from the fspool
+ *
+ * Returns 0 on success, or -1 on error
+ */
+int
+virFsItemDelete(virFsItemPtr item,
+                unsigned int flags)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("item=%p, flags=%x", item, flags);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, -1);
+    conn = item->conn;
+
+    virCheckReadOnlyGoto(conn->flags, error);
+
+    if (conn->fsDriver && conn->fsDriver->fsItemDelete) {
+        int ret;
+        ret = conn->fsDriver->fsItemDelete(item, flags);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(item->conn);
+    return -1;
+}
+
+/**
+ * virFsItemFree:
+ * @item: pointer to fspool item
+ *
+ * Release the fs item handle. The underlying
+ * fs item continues to exist.
+ *
+ * Returns 0 on success, or -1 on error
+ */
+int
+virFsItemFree(virFsItemPtr item)
+{
+    VIR_DEBUG("item=%p", item);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, -1);
+
+    virObjectUnref(item);
+    return 0;
+}
+
+
+/**
+ * virFsItemRef:
+ * @item: the item to hold a reference on
+ *
+ * Increment the reference count on the item. For each
+ * additional call to this method, there shall be a corresponding
+ * call to virFsItemFree to release the reference count, once
+ * the caller no longer needs the reference to this object.
+ *
+ * This method is typically useful for applications where multiple
+ * threads are using a connection, and it is required that the
+ * connection remain open until all threads have finished using
+ * it. ie, each new thread using a item would increment
+ * the reference count.
+ *
+ * Returns 0 in case of success, -1 in case of failure.
+ */
+int
+virFsItemRef(virFsItemPtr item)
+{
+    VIR_DEBUG("item=%p refs=%d", item, item ? item->object.u.s.refs : 0);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, -1);
+
+    virObjectRef(item);
+    return 0;
+}
+
+
+/**
+ * virFsItemGetInfo:
+ * @item: pointer to fspool item
+ * @info: pointer at which to store info
+ *
+ * Fetches itematile information about the fspool
+ * item such as its current allocation
+ *
+ * Returns 0 on success, or -1 on failure
+ */
+int
+virFsItemGetInfo(virFsItemPtr item,
+                 virFsItemInfoPtr info)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("item=%p, info=%p", item, info);
+
+    virResetLastError();
+
+    if (info)
+        memset(info, 0, sizeof(*info));
+
+    virCheckFsItemReturn(item, -1);
+    virCheckNonNullArgGoto(info, error);
+
+    conn = item->conn;
+
+    if (conn->fsDriver->fsItemGetInfo) {
+        int ret;
+        ret = conn->fsDriver->fsItemGetInfo(item, info);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(item->conn);
+    return -1;
+}
+
+
+/**
+ * virFsItemGetXMLDesc:
+ * @item: pointer to fsitem
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * Fetch an XML document describing all aspects of
+ * the fsitem
+ *
+ * Returns the XML document, or NULL on error
+ */
+char *
+virFsItemGetXMLDesc(virFsItemPtr item,
+                    unsigned int flags)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("item=%p, flags=%x", item, flags);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, NULL);
+    conn = item->conn;
+
+    if (conn->fsDriver && conn->fsDriver->fsItemGetXMLDesc) {
+        char *ret;
+        ret = conn->fsDriver->fsItemGetXMLDesc(item, flags);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(item->conn);
+    return NULL;
+}
+
+
+/**
+ * virFsItemGetPath:
+ * @item: pointer to fspool item
+ *
+ * Fetch the fsitem path. Depending on the fspool
+ * configuration this is either persistent across hosts,
+ * or dynamically assigned at fspool startup. Consult
+ * fspool documentation for information on getting the
+ * persistent naming
+ *
+ * Returns the fs item path, or NULL on error. The
+ * caller must free() the returned path after use.
+ */
+char *
+virFsItemGetPath(virFsItemPtr item)
+{
+    virConnectPtr conn;
+    VIR_DEBUG("item=%p", item);
+
+    virResetLastError();
+
+    virCheckFsItemReturn(item, NULL);
+    conn = item->conn;
+
+    if (conn->fsDriver && conn->fsDriver->fsItemGetPath) {
+        char *ret;
+        ret = conn->fsDriver->fsItemGetPath(item);
+        if (!ret)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+
+ error:
+    virDispatchError(item->conn);
+    return NULL;
+}
+
+
+/**
+ * virFsPoolIsActive:
+ */
+int
+virFsPoolIsActive(virFsPoolPtr fspool)
+{
+    VIR_DEBUG("fspool=%p", fspool);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+
+    if (fspool->conn->fsDriver->fsPoolIsActive) {
+        int ret;
+        ret = fspool->conn->fsDriver->fsPoolIsActive(fspool);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
+
+
+/**
+ * virFsPoolIsPersistent:
+ * @fspool: pointer to the fspool object
+ *
+ * Determine if the fspool has a persistent configuration
+ * which means it will still exist after shutting down
+ *
+ * Returns 1 if persistent, 0 if transient, -1 on error
+ */
+int
+virFsPoolIsPersistent(virFsPoolPtr fspool)
+{
+    VIR_DEBUG("fspool=%p", fspool);
+
+    virResetLastError();
+
+    virCheckFsPoolReturn(fspool, -1);
+
+    if (fspool->conn->fsDriver->fsPoolIsPersistent) {
+        int ret;
+        ret = fspool->conn->fsDriver->fsPoolIsPersistent(fspool);
+        if (ret < 0)
+            goto error;
+        return ret;
+    }
+
+    virReportUnsupportedError();
+ error:
+    virDispatchError(fspool->conn);
+    return -1;
+}
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index de620a8..c59f02a 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -962,9 +962,13 @@ virConnectCloseCallbackDataRegister;
 virConnectCloseCallbackDataUnregister;
 virDomainClass;
 virDomainSnapshotClass;
+virFsItemClass;
+virFsPoolClass;
 virGetConnect;
 virGetDomain;
 virGetDomainSnapshot;
+virGetFsItem;
+virGetFsPool;
 virGetInterface;
 virGetNetwork;
 virGetNodeDevice;
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index b6d2dfd..802a285 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -738,6 +738,52 @@ LIBVIRT_2.0.0 {
         virConnectStoragePoolEventDeregisterAny;
         virDomainGetGuestVcpus;
         virDomainSetGuestVcpus;
+        virFsPoolGetConnect;
+        virConnectNumOfFsPools;
+        virConnectNumOfDefinedFsPools;
+        virConnectListFsPools;
+        virConnectListDefinedFsPools;
+        virConnectListAllFsPools;
+        virFsPoolListAllItems;
+        virFsPoolLookupByName;
+        virFsPoolLookupByUUID;
+        virFsPoolLookupByUUIDString;
+        virFsPoolLookupByItem;
+        virFsPoolCreateXML;
+        virFsPoolDefineXML;
+        virFsPoolUndefine;
+        virFsPoolCreate;
+        virFsPoolBuild;
+        virFsPoolDestroy;
+        virFsPoolDelete;
+        virFsPoolRefresh;
+        virFsPoolFree;
+        virFsPoolGetName;
+        virFsPoolGetUUID;
+        virFsPoolGetUUIDString;
+        virFsPoolGetInfo;
+        virFsPoolGetXMLDesc;
+        virFsPoolSetAutostart;
+        virFsPoolGetAutostart;
+        virFsPoolNumOfItems;
+        virFsPoolListItems;
+        virFsPoolRef;
+        virFsItemRef;
+        virFsItemCreateXMLFrom;
+        virFsItemGetConnect;
+        virFsItemLookupByName;
+        virFsItemLookupByKey;
+        virFsItemLookupByPath;
+        virFsItemCreateXML;
+        virFsItemDelete;
+        virFsItemFree;
+        virFsItemGetName;
+        virFsItemGetKey;
+        virFsItemGetInfo;
+        virFsItemGetXMLDesc;
+        virFsItemGetPath;
+        virFsPoolIsActive;
+        virFsPoolIsPersistent;
 } LIBVIRT_1.3.3;
 
 # .... define new API here using predicted next version number ....
diff --git a/src/util/virerror.c b/src/util/virerror.c
index 1177570..b2d1329 100644
--- a/src/util/virerror.c
+++ b/src/util/virerror.c
@@ -138,6 +138,7 @@ VIR_ENUM_IMPL(virErrorDomain, VIR_ERR_DOMAIN_LAST,
               "Xen XL Config",
 
               "Perf",
+              "Fs Driver"
     )
 
 
@@ -1394,6 +1395,42 @@ virErrorMsg(virErrorNumber error, const char *info)
             else
                 errmsg = _("Client not found: %s");
             break;
+        case VIR_ERR_INVALID_FS_POOL:
+            if (info == NULL)
+                errmsg = _("invalid fspool poiter in");
+            else
+                errmsg = _("invalid fspool pointer in %s");
+            break;
+        case VIR_ERR_INVALID_FS_ITEM:
+            if (info == NULL)
+                errmsg = _("invalid fsitem pointer in");
+            else
+                errmsg = _("invalid fsitem pointer in %s");
+            break;
+        case VIR_WAR_NO_FS_POOL:
+            if (info == NULL)
+                errmsg = _("Failed to find a fs driver");
+            else
+                errmsg = _("Failed to find a fs driver: %s");
+            break;
+        case VIR_ERR_NO_FS_POOL:
+            if (info == NULL)
+                errmsg = _("Fspool not found");
+            else
+                errmsg = _("Fspool not found: %s");
+            break;
+        case VIR_ERR_NO_FS_ITEM:
+            if (info == NULL)
+                errmsg = _("Fspool item not found");
+            else
+                errmsg = _("Fspool item not found: %s");
+            break;
+        case VIR_ERR_FS_ITEM_EXIST:
+            if (info == NULL)
+                errmsg = _("Fspool item exists");
+            else
+                errmsg = _("Fspool item exists: %s");
+            break;
     }
     return errmsg;
 }
-- 
1.8.3.1




More information about the libvir-list mailing list