Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy@xxxxxxxxxxxxx>
---
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 25dbc84..af00155 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -67,6 +67,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 e2a2128..8fc6582 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 \
@@ -2401,6 +2403,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 2b6adb4..6f1f11b 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); \
@@ -457,6 +499,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.
@@ -596,6 +639,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
@@ -687,6 +769,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 419c33d..2efaab1 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -979,9 +979,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 e01604c..7420e40 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;
LIBVIRT_2.2.0 {
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
--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list