Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy@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 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

Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy@virtuozzo.com> --- src/access/viraccessdriver.h | 12 ++++ src/access/viraccessdrivernop.c | 19 ++++++ src/access/viraccessdriverpolkit.c | 47 ++++++++++++++ src/access/viraccessdriverstack.c | 49 +++++++++++++++ src/access/viraccessmanager.c | 31 ++++++++++ src/access/viraccessmanager.h | 11 ++++ src/access/viraccessperm.c | 15 ++++- src/access/viraccessperm.h | 124 +++++++++++++++++++++++++++++++++++++ src/libvirt_private.syms | 6 ++ 9 files changed, 313 insertions(+), 1 deletion(-) diff --git a/src/access/viraccessdriver.h b/src/access/viraccessdriver.h index e3050b6..e0d505e 100644 --- a/src/access/viraccessdriver.h +++ b/src/access/viraccessdriver.h @@ -61,6 +61,16 @@ typedef int (*virAccessDriverCheckStorageVolDrv)(virAccessManagerPtr manager, virStorageVolDefPtr vol, virAccessPermStorageVol av); +typedef int (*virAccessDriverCheckFsPoolDrv)(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virAccessPermFsPool av); +typedef int (*virAccessDriverCheckFsItemDrv)(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virFsItemDefPtr item, + virAccessPermFsItem av); + typedef int (*virAccessDriverSetupDrv)(virAccessManagerPtr manager); typedef void (*virAccessDriverCleanupDrv)(virAccessManagerPtr manager); @@ -83,6 +93,8 @@ struct _virAccessDriver { virAccessDriverCheckSecretDrv checkSecret; virAccessDriverCheckStoragePoolDrv checkStoragePool; virAccessDriverCheckStorageVolDrv checkStorageVol; + virAccessDriverCheckFsPoolDrv checkFsPool; + virAccessDriverCheckFsItemDrv checkFsItem; }; diff --git a/src/access/viraccessdrivernop.c b/src/access/viraccessdrivernop.c index 86ceef3..1ed8b35 100644 --- a/src/access/viraccessdrivernop.c +++ b/src/access/viraccessdrivernop.c @@ -103,7 +103,24 @@ virAccessDriverNopCheckStorageVol(virAccessManagerPtr manager ATTRIBUTE_UNUSED, return 1; /* Allow */ } +static int +virAccessDriverNopCheckFsPool(virAccessManagerPtr manager ATTRIBUTE_UNUSED, + const char *driverName ATTRIBUTE_UNUSED, + virFsPoolDefPtr fspool ATTRIBUTE_UNUSED, + virAccessPermFsPool perm ATTRIBUTE_UNUSED) +{ + return 1; /* Allow */ +} +static int +virAccessDriverNopCheckFsItem(virAccessManagerPtr manager ATTRIBUTE_UNUSED, + const char *driverName ATTRIBUTE_UNUSED, + virFsPoolDefPtr fspool ATTRIBUTE_UNUSED, + virFsItemDefPtr item ATTRIBUTE_UNUSED, + virAccessPermFsItem perm ATTRIBUTE_UNUSED) +{ + return 1; /* Allow */ +} virAccessDriver accessDriverNop = { .name = "none", .checkConnect = virAccessDriverNopCheckConnect, @@ -115,4 +132,6 @@ virAccessDriver accessDriverNop = { .checkSecret = virAccessDriverNopCheckSecret, .checkStoragePool = virAccessDriverNopCheckStoragePool, .checkStorageVol = virAccessDriverNopCheckStorageVol, + .checkFsPool = virAccessDriverNopCheckFsPool, + .checkFsItem = virAccessDriverNopCheckFsItem, }; diff --git a/src/access/viraccessdriverpolkit.c b/src/access/viraccessdriverpolkit.c index 89bc890..fae3f26 100644 --- a/src/access/viraccessdriverpolkit.c +++ b/src/access/viraccessdriverpolkit.c @@ -385,6 +385,50 @@ virAccessDriverPolkitCheckStorageVol(virAccessManagerPtr manager, virAccessPermStorageVolTypeToString(perm), attrs); } +static int +virAccessDriverPolkitCheckFsPool(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virAccessPermFsPool perm) +{ + char uuidstr[VIR_UUID_STRING_BUFLEN]; + const char *attrs[] = { + "connect_driver", driverName, + "fspool_name", fspool->name, + "fspool_uuid", uuidstr, + NULL, + }; + virUUIDFormat(fspool->uuid, uuidstr); + + return virAccessDriverPolkitCheck(manager, + "fs-pool", + virAccessPermFsPoolTypeToString(perm), + attrs); +} + +static int +virAccessDriverPolkitCheckFsItem(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virFsItemDefPtr item, + virAccessPermFsItem perm) +{ + char uuidstr[VIR_UUID_STRING_BUFLEN]; + const char *attrs[] = { + "connect_driver", driverName, + "fspool_name", fspool->name, + "fspool_uuid", uuidstr, + "item_name", item->name, + "item_key", item->key, + NULL, + }; + virUUIDFormat(fspool->uuid, uuidstr); + + return virAccessDriverPolkitCheck(manager, + "fs-item", + virAccessPermStorageVolTypeToString(perm), + attrs); +} virAccessDriver accessDriverPolkit = { .privateDataLen = sizeof(virAccessDriverPolkitPrivate), @@ -399,4 +443,7 @@ virAccessDriver accessDriverPolkit = { .checkSecret = virAccessDriverPolkitCheckSecret, .checkStoragePool = virAccessDriverPolkitCheckStoragePool, .checkStorageVol = virAccessDriverPolkitCheckStorageVol, + .checkFsPool = virAccessDriverPolkitCheckFsPool, + .checkFsItem = virAccessDriverPolkitCheckFsItem, + }; diff --git a/src/access/viraccessdriverstack.c b/src/access/viraccessdriverstack.c index b43a743..c78c321 100644 --- a/src/access/viraccessdriverstack.c +++ b/src/access/viraccessdriverstack.c @@ -267,6 +267,53 @@ virAccessDriverStackCheckStorageVol(virAccessManagerPtr manager, return ret; } +static int +virAccessDriverStackCheckFsPool(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virAccessPermFsPool perm) +{ + virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager); + int ret = 1; + size_t i; + + for (i = 0; i < priv->managersLen; i++) { + int rv; + /* We do not short-circuit on first denial - always check all drivers */ + rv = virAccessManagerCheckFsPool(priv->managers[i], driverName, fspool, perm); + if (rv == 0 && ret != -1) + ret = 0; + else if (rv < 0) + ret = -1; + } + + return ret; +} + +static int +virAccessDriverStackCheckFsItem(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virFsItemDefPtr item, + virAccessPermFsItem perm) +{ + virAccessDriverStackPrivatePtr priv = virAccessManagerGetPrivateData(manager); + int ret = 1; + size_t i; + + for (i = 0; i < priv->managersLen; i++) { + int rv; + /* We do not short-circuit on first denial - always check all drivers */ + rv = virAccessManagerCheckFsItem(priv->managers[i], driverName, fspool, item, perm); + if (rv == 0 && ret != -1) + ret = 0; + else if (rv < 0) + ret = -1; + } + + return ret; +} + virAccessDriver accessDriverStack = { .privateDataLen = sizeof(virAccessDriverStackPrivate), .name = "stack", @@ -280,4 +327,6 @@ virAccessDriver accessDriverStack = { .checkSecret = virAccessDriverStackCheckSecret, .checkStoragePool = virAccessDriverStackCheckStoragePool, .checkStorageVol = virAccessDriverStackCheckStorageVol, + .checkFsPool = virAccessDriverStackCheckFsPool, + .checkFsItem = virAccessDriverStackCheckFsItem, }; diff --git a/src/access/viraccessmanager.c b/src/access/viraccessmanager.c index bcf552b..6882c03 100644 --- a/src/access/viraccessmanager.c +++ b/src/access/viraccessmanager.c @@ -344,3 +344,34 @@ int virAccessManagerCheckStorageVol(virAccessManagerPtr manager, return virAccessManagerSanitizeError(ret); } + +int virAccessManagerCheckFsPool(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virAccessPermFsPool perm) +{ + int ret = 0; + VIR_DEBUG("manager=%p(name=%s) driver=%s pool=%p perm=%d", + manager, manager->drv->name, driverName, fspool, perm); + + if (manager->drv->checkFsPool) + ret = manager->drv->checkFsPool(manager, driverName, fspool, perm); + + return virAccessManagerSanitizeError(ret); +} + +int virAccessManagerCheckFsItem(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virFsItemDefPtr item, + virAccessPermFsItem perm) +{ + int ret = 0; + VIR_DEBUG("manager=%p(name=%s) driver=%s pool=%p vol=%p perm=%d", + manager, manager->drv->name, driverName, fspool, item, perm); + + if (manager->drv->checkFsItem) + ret = manager->drv->checkFsItem(manager, driverName, fspool, item, perm); + + return virAccessManagerSanitizeError(ret); +} diff --git a/src/access/viraccessmanager.h b/src/access/viraccessmanager.h index e7eb15d..69cddb5 100644 --- a/src/access/viraccessmanager.h +++ b/src/access/viraccessmanager.h @@ -27,6 +27,7 @@ # include "conf/nwfilter_conf.h" # include "conf/node_device_conf.h" # include "conf/storage_conf.h" +# include "conf/fs_conf.h" # include "conf/secret_conf.h" # include "conf/interface_conf.h" # include "access/viraccessperm.h" @@ -86,6 +87,16 @@ int virAccessManagerCheckStorageVol(virAccessManagerPtr manager, virStoragePoolDefPtr pool, virStorageVolDefPtr vol, virAccessPermStorageVol perm); +int virAccessManagerCheckFsPool(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virAccessPermFsPool perm); +int virAccessManagerCheckFsItem(virAccessManagerPtr manager, + const char *driverName, + virFsPoolDefPtr fspool, + virFsItemDefPtr item, + virAccessPermFsItem perm); + #endif /* __VIR_ACCESS_MANAGER_H__ */ diff --git a/src/access/viraccessperm.c b/src/access/viraccessperm.c index 0f58290..5ac7162 100644 --- a/src/access/viraccessperm.c +++ b/src/access/viraccessperm.c @@ -29,7 +29,7 @@ VIR_ENUM_IMPL(virAccessPermConnect, "search_domains", "search_networks", "search_storage_pools", "search_node_devices", "search_interfaces", "search_secrets", - "search_nwfilters", + "search_nwfilters", "search_fs_pools", "detect_storage_pools", "pm_control", "interface_transaction"); @@ -83,3 +83,16 @@ VIR_ENUM_IMPL(virAccessPermStorageVol, "getattr", "read", "create", "delete", "format", "resize", "data_read", "data_write"); + +VIR_ENUM_IMPL(virAccessPermFsPool, + VIR_ACCESS_PERM_FS_POOL_LAST, + "getattr", "read", "write", + "save", "delete", "start", "stop", + "refresh", "search_items", + "format"); + +VIR_ENUM_IMPL(virAccessPermFsItem, + VIR_ACCESS_PERM_FS_ITEM_LAST, + "getattr", "read", "create", "delete", + "format", "data_read", + "data_write"); diff --git a/src/access/viraccessperm.h b/src/access/viraccessperm.h index 1817da7..7a29de5 100644 --- a/src/access/viraccessperm.h +++ b/src/access/viraccessperm.h @@ -67,6 +67,12 @@ typedef enum { VIR_ACCESS_PERM_CONNECT_SEARCH_STORAGE_POOLS, /** + * @desc: List fs pools + * @message: Listing fs pools requires authorization + * @anonymous: 1 + */ + VIR_ACCESS_PERM_CONNECT_SEARCH_FS_POOLS, + /** * @desc: List node devices * @message: Listing node devices requires authorization * @anonymous: 1 @@ -651,6 +657,122 @@ typedef enum { VIR_ACCESS_PERM_STORAGE_VOL_LAST } virAccessPermStorageVol; +typedef enum { + + /** + * @desc: Access fs pool + * @message: Accessing fs pool requires authorization + * @anonymous: 1 + */ + VIR_ACCESS_PERM_FS_POOL_GETATTR, + + /** + * @desc: Read fs pool + * @message: Reading fs pool configuration requires authorization + * @anonymous: 1 + */ + VIR_ACCESS_PERM_FS_POOL_READ, + + /** + * @desc: Write fs pool + * @message: Writing fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FS_POOL_WRITE, + + /** + * @desc: Save fs pool + * @message: Saving fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FS_POOL_SAVE, + + /** + * @desc: Delete fs pool + * @message: Deleting fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FS_POOL_DELETE, + + /** + * @desc: Start fs pool + * @message: Starting fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FS_POOL_START, + + /** + * @desc: Stop fs pool + * @message: Stopping fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FS_POOL_STOP, + + /** + * @desc: Refresh fs pool + * @message: Refreshing fs pool items requires authorization + */ + VIR_ACCESS_PERM_FS_POOL_REFRESH, + + /** + * @desc: List fs pool items + * @message: Listing fs pool items requires authorization + */ + VIR_ACCESS_PERM_FS_POOL_SEARCH_ITEMS, + + /** + * @desc: Format fs pool + * @message: Formatting fs pool data requires authorization + */ + VIR_ACCESS_PERM_FS_POOL_FORMAT, + + VIR_ACCESS_PERM_FS_POOL_LAST +} virAccessPermFsPool; + +typedef enum { + + /** + * @desc: Access fs item + * @message: Acceessing fs item requires authorization + * @anonymous: 1 + */ + VIR_ACCESS_PERM_FS_ITEM_GETATTR, + + /** + * @desc: Read fs item + * @message: Reading fs item configuration requires authorization + * @anonymous: 1 + */ + VIR_ACCESS_PERM_FS_ITEM_READ, + + /** + * @desc: Create fs item + * @message: Creating fs item requires authorization + */ + VIR_ACCESS_PERM_FS_ITEM_CREATE, + + /** + * @desc: Delete fs item + * @message: Deleting fs item requires authorization + */ + VIR_ACCESS_PERM_FS_ITEM_DELETE, + + /** + * @desc: Format fs item + * @message: Formatting fs item data requires authorization + */ + VIR_ACCESS_PERM_FS_ITEM_FORMAT, + + /** + * @desc: Read fs item data + * @message: Reading fs item data requires authorization + */ + VIR_ACCESS_PERM_FS_ITEM_DATA_READ, + + /** + * @desc: Write fs item data + * @message: Writing fs item data requires authorization + */ + VIR_ACCESS_PERM_FS_ITEM_DATA_WRITE, + + VIR_ACCESS_PERM_FS_ITEM_LAST +} virAccessPermFsItem; + VIR_ENUM_DECL(virAccessPermConnect); VIR_ENUM_DECL(virAccessPermDomain); VIR_ENUM_DECL(virAccessPermInterface); @@ -660,5 +782,7 @@ VIR_ENUM_DECL(virAccessPermNWFilter); VIR_ENUM_DECL(virAccessPermSecret); VIR_ENUM_DECL(virAccessPermStoragePool); VIR_ENUM_DECL(virAccessPermStorageVol); +VIR_ENUM_DECL(virAccessPermFsPool); +VIR_ENUM_DECL(virAccessPermFsItem); #endif /* __VIR_ACCESS_PERM_H__ */ diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 026543c..68150d6 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -8,6 +8,8 @@ # access/viraccessmanager.h virAccessManagerCheckConnect; virAccessManagerCheckDomain; +virAccessManagerCheckFsItem; +virAccessManagerCheckFsPool; virAccessManagerCheckInterface; virAccessManagerCheckNetwork; virAccessManagerCheckNodeDevice; @@ -26,6 +28,10 @@ virAccessPermConnectTypeFromString; virAccessPermConnectTypeToString; virAccessPermDomainTypeFromString; virAccessPermDomainTypeToString; +virAccessPermFsItemTypeFromString; +virAccessPermFsItemTypeToString; +virAccessPermFsPoolTypeFromString; +virAccessPermFsPoolTypeToString; virAccessPermInterfaceTypeFromString; virAccessPermInterfaceTypeToString; virAccessPermNetworkTypeFromString; -- 1.8.3.1

Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy@virtuozzo.com> --- daemon/libvirtd.c | 10 + daemon/remote.c | 35 +++ src/driver.h | 1 + src/remote/remote_driver.c | 72 +++++- src/remote/remote_protocol.x | 522 ++++++++++++++++++++++++++++++++++++++++++- src/rpc/gendispatch.pl | 19 +- 6 files changed, 650 insertions(+), 9 deletions(-) diff --git a/daemon/libvirtd.c b/daemon/libvirtd.c index 95c1b1c..b6d4d80 100644 --- a/daemon/libvirtd.c +++ b/daemon/libvirtd.c @@ -92,6 +92,9 @@ # ifdef WITH_STORAGE # include "storage/storage_driver.h" # endif +# ifdef WITH_FS +# include "fs/fs_driver.h" +# endif # ifdef WITH_NODE_DEVICES # include "node_device/node_device_driver.h" # endif @@ -374,6 +377,9 @@ static void daemonInitialize(void) # ifdef WITH_NWFILTER virDriverLoadModule("nwfilter"); # endif +# ifdef WITH_FS + virDriverLoadModule("fs"); +# endif # ifdef WITH_XEN virDriverLoadModule("xen"); # endif @@ -398,6 +404,7 @@ static void daemonInitialize(void) # ifdef WITH_VZ virDriverLoadModule("vz"); # endif + #else # ifdef WITH_NETWORK networkRegister(); @@ -408,6 +415,9 @@ static void daemonInitialize(void) # ifdef WITH_STORAGE storageRegister(); # endif +# ifdef WITH_FS + fsRegister(); +# endif # ifdef WITH_NODE_DEVICES nodedevRegister(); # endif diff --git a/daemon/remote.c b/daemon/remote.c index 9e75472..bf60246 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -88,6 +88,8 @@ static virNetworkPtr get_nonnull_network(virConnectPtr conn, remote_nonnull_netw static virInterfacePtr get_nonnull_interface(virConnectPtr conn, remote_nonnull_interface iface); static virStoragePoolPtr get_nonnull_storage_pool(virConnectPtr conn, remote_nonnull_storage_pool pool); static virStorageVolPtr get_nonnull_storage_vol(virConnectPtr conn, remote_nonnull_storage_vol vol); +static virFsPoolPtr get_nonnull_fs_pool(virConnectPtr conn, remote_nonnull_fs_pool fspool); +static virFsItemPtr get_nonnull_fs_item(virConnectPtr conn, remote_nonnull_fs_item item); static virSecretPtr get_nonnull_secret(virConnectPtr conn, remote_nonnull_secret secret); static virNWFilterPtr get_nonnull_nwfilter(virConnectPtr conn, remote_nonnull_nwfilter nwfilter); static virDomainSnapshotPtr get_nonnull_domain_snapshot(virDomainPtr dom, remote_nonnull_domain_snapshot snapshot); @@ -97,6 +99,8 @@ static void make_nonnull_network(remote_nonnull_network *net_dst, virNetworkPtr static void make_nonnull_interface(remote_nonnull_interface *interface_dst, virInterfacePtr interface_src); static void make_nonnull_storage_pool(remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src); static void make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src); +static void make_nonnull_fs_pool(remote_nonnull_fs_pool *fspool_dst, virFsPoolPtr fspool_src); +static void make_nonnull_fs_item(remote_nonnull_fs_item *item_dst, virFsItemPtr item_src); static void make_nonnull_node_device(remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src); static void make_nonnull_secret(remote_nonnull_secret *secret_dst, virSecretPtr secret_src); static void make_nonnull_nwfilter(remote_nonnull_nwfilter *net_dst, virNWFilterPtr nwfilter_src); @@ -6631,6 +6635,22 @@ get_nonnull_domain_snapshot(virDomainPtr dom, remote_nonnull_domain_snapshot sna return virGetDomainSnapshot(dom, snapshot.name); } +static virFsPoolPtr +get_nonnull_fs_pool(virConnectPtr conn, remote_nonnull_fs_pool fspool) +{ + return virGetFsPool(conn, fspool.name, BAD_CAST fspool.uuid, + NULL, NULL); +} + +static virFsItemPtr +get_nonnull_fs_item(virConnectPtr conn, remote_nonnull_fs_item item) +{ + virFsItemPtr ret; + ret = virGetFsItem(conn, item.fspool, item.name, item.key, + NULL, NULL); + return ret; +} + static virNodeDevicePtr get_nonnull_node_device(virConnectPtr conn, remote_nonnull_node_device dev) { @@ -6677,6 +6697,21 @@ make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virStorageVolPtr v } static void +make_nonnull_fs_pool(remote_nonnull_fs_pool *fspool_dst, virFsPoolPtr fspool_src) +{ + ignore_value(VIR_STRDUP_QUIET(fspool_dst->name, fspool_src->name)); + memcpy(fspool_dst->uuid, fspool_src->uuid, VIR_UUID_BUFLEN); +} + +static void +make_nonnull_fs_item(remote_nonnull_fs_item *item_dst, virFsItemPtr item_src) +{ + ignore_value(VIR_STRDUP_QUIET(item_dst->fspool, item_src->fspool)); + ignore_value(VIR_STRDUP_QUIET(item_dst->name, item_src->name)); + ignore_value(VIR_STRDUP_QUIET(item_dst->key, item_src->key)); +} + +static void make_nonnull_node_device(remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src) { ignore_value(VIR_STRDUP_QUIET(dev_dst->name, dev_src->name)); diff --git a/src/driver.h b/src/driver.h index fb93083..57ad1f7 100644 --- a/src/driver.h +++ b/src/driver.h @@ -87,6 +87,7 @@ struct _virConnectDriver { virNWFilterDriverPtr nwfilterDriver; virSecretDriverPtr secretDriver; virStorageDriverPtr storageDriver; + virFsDriverPtr fsDriver; }; int virRegisterConnectDriver(virConnectDriverPtr driver, diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 6637a1d..2aa765c 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -144,6 +144,8 @@ static virNWFilterPtr get_nonnull_nwfilter(virConnectPtr conn, remote_nonnull_nw static virInterfacePtr get_nonnull_interface(virConnectPtr conn, remote_nonnull_interface iface); static virStoragePoolPtr get_nonnull_storage_pool(virConnectPtr conn, remote_nonnull_storage_pool pool); static virStorageVolPtr get_nonnull_storage_vol(virConnectPtr conn, remote_nonnull_storage_vol vol); +static virFsPoolPtr get_nonnull_fs_pool(virConnectPtr conn, remote_nonnull_fs_pool fspool); +static virFsItemPtr get_nonnull_fs_item(virConnectPtr conn, remote_nonnull_fs_item item); static virNodeDevicePtr get_nonnull_node_device(virConnectPtr conn, remote_nonnull_node_device dev); static virSecretPtr get_nonnull_secret(virConnectPtr conn, remote_nonnull_secret secret); static virDomainSnapshotPtr get_nonnull_domain_snapshot(virDomainPtr domain, remote_nonnull_domain_snapshot snapshot); @@ -152,6 +154,8 @@ static void make_nonnull_network(remote_nonnull_network *net_dst, virNetworkPtr static void make_nonnull_interface(remote_nonnull_interface *interface_dst, virInterfacePtr interface_src); static void make_nonnull_storage_pool(remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr vol_src); static void make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src); +static void make_nonnull_fs_pool(remote_nonnull_fs_pool *fspool_dst, virFsPoolPtr fspool_src); +static void make_nonnull_fs_item(remote_nonnull_fs_item *item_dst, virFsItemPtr item_src); static void make_nonnull_node_device(remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src); static void make_nonnull_secret(remote_nonnull_secret *secret_dst, virSecretPtr secret_src); @@ -7501,7 +7505,7 @@ remoteDomainGetFSInfo(virDomainPtr dom, if (ret.info.info_len > REMOTE_DOMAIN_FSINFO_MAX) { virReportError(VIR_ERR_INTERNAL_ERROR, - _("Too many mountpoints in fsinfo: %d for limit %d"), + _("Too many mountpoints in = remoteFsinfo: %d for limit %d"), ret.info.info_len, REMOTE_DOMAIN_FSINFO_MAX); goto cleanup; } @@ -7811,6 +7815,19 @@ get_nonnull_storage_vol(virConnectPtr conn, remote_nonnull_storage_vol vol) NULL, NULL); } +static virFsPoolPtr +get_nonnull_fs_pool(virConnectPtr conn, remote_nonnull_fs_pool fspool) +{ + return virGetFsPool(conn, fspool.name, BAD_CAST fspool.uuid, + NULL, NULL); +} + +static virFsItemPtr +get_nonnull_fs_item(virConnectPtr conn, remote_nonnull_fs_item item) +{ + return virGetFsItem(conn, item.fspool, item.name, item.key, + NULL, NULL); +} static virNodeDevicePtr get_nonnull_node_device(virConnectPtr conn, remote_nonnull_node_device dev) { @@ -7876,6 +7893,21 @@ make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virStorageVolPtr v } static void +make_nonnull_fs_pool(remote_nonnull_fs_pool *fspool_dst, virFsPoolPtr fspool_src) +{ + fspool_dst->name = fspool_src->name; + memcpy(fspool_dst->uuid, fspool_src->uuid, VIR_UUID_BUFLEN); +} + +static void +make_nonnull_fs_item(remote_nonnull_fs_item *item_dst, virFsItemPtr item_src) +{ + item_dst->fspool = item_src->fspool; + item_dst->name = item_src->name; + item_dst->key = item_src->key; +} + +static void make_nonnull_secret(remote_nonnull_secret *secret_dst, virSecretPtr secret_src) { memcpy(secret_dst->uuid, secret_src->uuid, VIR_UUID_BUFLEN); @@ -8266,6 +8298,43 @@ static virNWFilterDriver nwfilter_driver = { .connectListAllNWFilters = remoteConnectListAllNWFilters, /* 0.10.2 */ }; +static virFsDriver fs_driver = { + .connectNumOfFsPools = remoteConnectNumOfFsPools, + .connectListFsPools = remoteConnectListFsPools, + .connectNumOfDefinedFsPools = remoteConnectNumOfDefinedFsPools, + .connectListDefinedFsPools = remoteConnectListDefinedFsPools, + .connectListAllFsPools = remoteConnectListAllFsPools, + .fsPoolLookupByName = remoteFsPoolLookupByName, + .fsPoolLookupByUUID = remoteFsPoolLookupByUUID, + .fsPoolLookupByItem = remoteFsPoolLookupByItem, + .fsPoolCreateXML = remoteFsPoolCreateXML, + .fsPoolDefineXML = remoteFsPoolDefineXML, + .fsPoolBuild = remoteFsPoolBuild, + .fsPoolUndefine = remoteFsPoolUndefine, + .fsPoolCreate = remoteFsPoolCreate, + .fsPoolDestroy = remoteFsPoolDestroy, + .fsPoolDelete = remoteFsPoolDelete, + .fsPoolRefresh = remoteFsPoolRefresh, + .fsPoolGetInfo = remoteFsPoolGetInfo, + .fsPoolGetXMLDesc = remoteFsPoolGetXMLDesc, + .fsPoolGetAutostart = remoteFsPoolGetAutostart, + .fsPoolSetAutostart = remoteFsPoolSetAutostart, + .fsPoolNumOfItems = remoteFsPoolNumOfItems, + .fsPoolListItems = remoteFsPoolListItems, + .fsPoolListAllItems = remoteFsPoolListAllItems, + .fsItemLookupByName = remoteFsItemLookupByName, + .fsItemLookupByKey = remoteFsItemLookupByKey, + .fsItemLookupByPath = remoteFsItemLookupByPath, + .fsItemCreateXML = remoteFsItemCreateXML, + .fsItemCreateXMLFrom = remoteFsItemCreateXMLFrom, + .fsItemDelete = remoteFsItemDelete, + .fsItemGetInfo = remoteFsItemGetInfo, + .fsItemGetXMLDesc = remoteFsItemGetXMLDesc, + .fsItemGetPath = remoteFsItemGetPath, + .fsPoolIsActive = remoteFsPoolIsActive, + .fsPoolIsPersistent = remoteFsPoolIsPersistent, +}; + static virConnectDriver connect_driver = { .hypervisorDriver = &hypervisor_driver, .interfaceDriver = &interface_driver, @@ -8274,6 +8343,7 @@ static virConnectDriver connect_driver = { .nwfilterDriver = &nwfilter_driver, .secretDriver = &secret_driver, .storageDriver = &storage_driver, + .fsDriver = &fs_driver, }; static virStateDriver state_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index b4fd057..ec4a94e 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -85,6 +85,12 @@ const REMOTE_STORAGE_POOL_LIST_MAX = 4096; /* Upper limit on lists of storage vols. */ const REMOTE_STORAGE_VOL_LIST_MAX = 16384; +/* Upper limit on lists of fspools. */ +const REMOTE_FS_POOL_LIST_MAX = 4096; + +/* Upper limit on lists of fsitems. */ +const REMOTE_FS_ITEM_LIST_MAX = 16384; + /* Upper limit on lists of node devices. */ const REMOTE_NODE_DEVICE_LIST_MAX = 16384; @@ -294,6 +300,19 @@ struct remote_nonnull_storage_vol { remote_nonnull_string key; }; +/* A fspool which may not be NULL. */ +struct remote_nonnull_fs_pool { + remote_nonnull_string name; + remote_uuid uuid; +}; + +/* A fsitem which may not be NULL. */ +struct remote_nonnull_fs_item { + remote_nonnull_string fspool; + remote_nonnull_string name; + remote_nonnull_string key; +}; + /* A node device which may not be NULL. */ struct remote_nonnull_node_device { remote_nonnull_string name; @@ -318,6 +337,8 @@ typedef remote_nonnull_network *remote_network; typedef remote_nonnull_nwfilter *remote_nwfilter; typedef remote_nonnull_storage_pool *remote_storage_pool; typedef remote_nonnull_storage_vol *remote_storage_vol; +typedef remote_nonnull_fs_pool *remote_fs_pool; +typedef remote_nonnull_fs_item *remote_fs_item; typedef remote_nonnull_node_device *remote_node_device; /* Error message. See <virterror.h> for explanation of fields. */ @@ -1955,6 +1976,230 @@ struct remote_storage_vol_resize_args { unsigned int flags; }; +/* Fs pool calls: */ + +struct remote_connect_num_of_fs_pools_ret { + int num; +}; + +struct remote_connect_list_fs_pools_args { + int maxnames; +}; + +struct remote_connect_list_fs_pools_ret { + remote_nonnull_string names<REMOTE_FS_POOL_LIST_MAX>; /* insert@1 */ +}; + +struct remote_connect_num_of_defined_fs_pools_ret { + int num; +}; + +struct remote_connect_list_defined_fs_pools_args { + int maxnames; +}; + +struct remote_connect_list_defined_fs_pools_ret { + remote_nonnull_string names<REMOTE_FS_POOL_LIST_MAX>; /* insert@1 */ +}; + +struct remote_fs_pool_lookup_by_uuid_args { + remote_uuid uuid; +}; + +struct remote_fs_pool_lookup_by_uuid_ret { + remote_nonnull_fs_pool pool; +}; + +struct remote_fs_pool_lookup_by_name_args { + remote_nonnull_string name; +}; + +struct remote_fs_pool_lookup_by_name_ret { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_lookup_by_item_args { + remote_nonnull_fs_item item; +}; + +struct remote_fs_pool_lookup_by_item_ret { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_create_xml_args { + remote_nonnull_string xml; + unsigned int flags; +}; + +struct remote_fs_pool_create_xml_ret { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_define_xml_args { + remote_nonnull_string xml; + unsigned int flags; +}; + +struct remote_fs_pool_define_xml_ret { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_build_args { + remote_nonnull_fs_pool fspool; + unsigned int flags; +}; + +struct remote_fs_pool_undefine_args { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_create_args { + remote_nonnull_fs_pool fspool; + unsigned int flags; +}; + +struct remote_fs_pool_destroy_args { + remote_nonnull_fs_pool fspool; +}; +struct remote_fs_pool_delete_args { + remote_nonnull_fs_pool fspool; + unsigned int flags; +}; + +struct remote_fs_pool_get_xml_desc_args { + remote_nonnull_fs_pool fspool; + unsigned int flags; +}; + +struct remote_fs_pool_get_xml_desc_ret { + remote_nonnull_string xml; +}; + +struct remote_fs_pool_get_info_args { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_get_info_ret { /* insert@1 */ + unsigned char state; + unsigned hyper capacity; + unsigned hyper allocation; + unsigned hyper available; +}; + +struct remote_fs_pool_get_autostart_args { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_get_autostart_ret { + int autostart; +}; + +struct remote_fs_pool_set_autostart_args { + remote_nonnull_fs_pool fspool; + int autostart; +}; + +struct remote_fs_pool_num_of_items_args { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_num_of_items_ret { + int num; +}; + +struct remote_fs_pool_list_items_args { + remote_nonnull_fs_pool fspool; + int maxnames; +}; + +struct remote_fs_pool_list_items_ret { + remote_nonnull_string names<REMOTE_FS_ITEM_LIST_MAX>; /* insert@1 */ +}; +struct remote_fs_pool_refresh_args { + remote_nonnull_fs_pool fspool; + unsigned int flags; +}; + +/* Fs item calls: */ + +struct remote_fs_item_lookup_by_name_args { + remote_nonnull_fs_pool fspool; + remote_nonnull_string name; +}; + +struct remote_fs_item_lookup_by_name_ret { + remote_nonnull_fs_item item; +}; + +struct remote_fs_item_lookup_by_key_args { + remote_nonnull_string key; +}; + +struct remote_fs_item_lookup_by_key_ret { + remote_nonnull_fs_item item; +}; + +struct remote_fs_item_lookup_by_path_args { + remote_nonnull_string path; +}; + +struct remote_fs_item_lookup_by_path_ret { + remote_nonnull_fs_item item; +}; + +struct remote_fs_item_create_xml_args { + remote_nonnull_fs_pool fspool; + remote_nonnull_string xml; + unsigned int flags; +}; + +struct remote_fs_item_create_xml_ret { + remote_nonnull_fs_item item; +}; + +struct remote_fs_item_create_xml_from_args { + remote_nonnull_fs_pool fspool; + remote_nonnull_string xml; + remote_nonnull_fs_item cloneitem; + unsigned int flags; +}; + +struct remote_fs_item_create_xml_from_ret { + remote_nonnull_fs_item item; +}; + +struct remote_fs_item_delete_args { + remote_nonnull_fs_item item; + unsigned int flags; +}; + +struct remote_fs_item_get_xml_desc_args { + remote_nonnull_fs_item item; + unsigned int flags; +}; + +struct remote_fs_item_get_xml_desc_ret { + remote_nonnull_string xml; +}; + +struct remote_fs_item_get_info_args { + remote_nonnull_fs_item item; +}; + +struct remote_fs_item_get_info_ret { /* insert@1 */ + char type; + unsigned hyper capacity; + unsigned hyper allocation; +}; + +struct remote_fs_item_get_path_args { + remote_nonnull_fs_item item; +}; + +struct remote_fs_item_get_path_ret { + remote_nonnull_string name; +}; + /* Node driver calls: */ struct remote_node_num_of_devices_args { @@ -2244,7 +2489,21 @@ struct remote_storage_pool_is_persistent_ret { int persistent; }; +struct remote_fs_pool_is_active_args { + remote_nonnull_fs_pool fspool; +}; + +struct remote_fs_pool_is_active_ret { + int active; +}; + +struct remote_fs_pool_is_persistent_args { + remote_nonnull_fs_pool fspool; +}; +struct remote_fs_pool_is_persistent_ret { + int persistent; +}; struct remote_interface_is_active_args { remote_nonnull_interface iface; }; @@ -2874,6 +3133,27 @@ struct remote_storage_pool_list_all_volumes_ret { /* insert@1 */ unsigned int ret; }; +struct remote_connect_list_all_fs_pools_args { + int need_results; + unsigned int flags; +}; + +struct remote_connect_list_all_fs_pools_ret { /* insert@1 */ + remote_nonnull_fs_pool fspools<REMOTE_FS_POOL_LIST_MAX>; + unsigned int ret; +}; + +struct remote_fs_pool_list_all_items_args { + remote_nonnull_fs_pool fspool; + int need_results; + unsigned int flags; +}; + +struct remote_fs_pool_list_all_items_ret { /* insert@1 */ + remote_nonnull_fs_item items<REMOTE_FS_ITEM_LIST_MAX>; + unsigned int ret; +}; + struct remote_connect_list_all_networks_args { int need_results; unsigned int flags; @@ -5923,5 +6203,245 @@ enum remote_procedure { * @generate: both * @acl: none */ - REMOTE_PROC_NODE_DEVICE_EVENT_LIFECYCLE = 376 + REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH = 376, + + /** + * @generate: both + * @priority: high + * @acl: connect:search_fs_pools + * @aclfilter: fs_pool:getattr + */ + REMOTE_PROC_CONNECT_NUM_OF_FS_POOLS = 377, + + /** + * @generate: both + * @priority: high + * @acl: connect:search_fs_pools + * @aclfilter: fs_pool:getattr + */ + REMOTE_PROC_CONNECT_LIST_FS_POOLS = 378, + + /** + * @generate: both + * @priority: high + * @acl: connect:search_fs_pools + * @aclfilter: fs_pool:getattr + */ + REMOTE_PROC_CONNECT_NUM_OF_DEFINED_FS_POOLS = 379, + + /** + * @generate: both + * @priority: high + * @acl: connect:search_fs_pools + * @aclfilter: fs_pool:getattr + */ + REMOTE_PROC_CONNECT_LIST_DEFINED_FS_POOLS = 380, + + /** + * @generate: both + * @acl: fs_pool:start + * @acl: fs_pool:write + */ + REMOTE_PROC_FS_POOL_CREATE_XML = 381, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:write + * @acl: fs_pool:save + */ + REMOTE_PROC_FS_POOL_DEFINE_XML = 382, + + /** + * @generate: both + * @acl: fs_pool:format + */ + REMOTE_PROC_FS_POOL_BUILD = 383, + + /** + * @generate: both + * @acl: fs_pool:format + */ + REMOTE_PROC_FS_POOL_DELETE = 384, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:delete + */ + REMOTE_PROC_FS_POOL_UNDEFINE = 385, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:getattr + */ + REMOTE_PROC_FS_POOL_LOOKUP_BY_NAME = 386, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:getattr + */ + REMOTE_PROC_FS_POOL_LOOKUP_BY_UUID = 387, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:getattr + */ + REMOTE_PROC_FS_POOL_LOOKUP_BY_ITEM = 388, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:read + */ + REMOTE_PROC_FS_POOL_GET_INFO = 389, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:read + */ + REMOTE_PROC_FS_POOL_GET_XML_DESC = 390, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:search_items + * @aclfilter: fs_item:getattr + */ + REMOTE_PROC_FS_POOL_NUM_OF_ITEMS = 391, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:search_items + * @aclfilter: fs_item:getattr + */ + REMOTE_PROC_FS_POOL_LIST_ITEMS = 392, + + /** + * @generate: both + * @acl: fs_item:create + */ + REMOTE_PROC_FS_ITEM_CREATE_XML = 393, + + /** + * @generate: both + * @acl: fs_item:delete + */ + REMOTE_PROC_FS_ITEM_DELETE = 394, + + /** + * @generate: both + * @priority: high + * @acl: fs_item:getattr + */ + REMOTE_PROC_FS_ITEM_LOOKUP_BY_NAME = 395, + + /** + * @generate: both + * @priority: high + * @acl: fs_item:getattr + */ + REMOTE_PROC_FS_ITEM_LOOKUP_BY_KEY = 396, + + /** + * @generate: both + * @priority: high + * @acl: fs_item:getattr + */ + REMOTE_PROC_FS_ITEM_LOOKUP_BY_PATH = 397, + + /** + * @generate: both + * @priority: high + * @acl: fs_item:read + */ + REMOTE_PROC_FS_ITEM_GET_INFO = 398, + + /** + * @generate: both + * @priority: high + * @acl: fs_item:read + */ + REMOTE_PROC_FS_ITEM_GET_XML_DESC = 399, + + /** + * @generate: both + * @priority: high + * @acl: fs_item:read + */ + REMOTE_PROC_FS_ITEM_GET_PATH = 400, + + /** + * @generate: both + * @acl: fs_item:create + */ + REMOTE_PROC_FS_ITEM_CREATE_XML_FROM = 401, + + /** + * @generate: both + * @priority: high + * @acl: connect:search_fs_pools + * @aclfilter: fs_pool:getattr + */ + REMOTE_PROC_CONNECT_LIST_ALL_FS_POOLS = 402, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:search_items + * @aclfilter: fs_item:getattr + */ + REMOTE_PROC_FS_POOL_LIST_ALL_ITEMS = 403, + + /** + * @generate: both + * @acl: fs_pool:refresh + */ + REMOTE_PROC_FS_POOL_REFRESH = 404, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:read + */ + REMOTE_PROC_FS_POOL_IS_ACTIVE = 405, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:read + */ + REMOTE_PROC_FS_POOL_IS_PERSISTENT = 406, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:read + */ + REMOTE_PROC_FS_POOL_GET_AUTOSTART = 407, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:write + */ + REMOTE_PROC_FS_POOL_SET_AUTOSTART = 408, + + /** + * @generate: both + * @acl: fs_pool:start + */ + REMOTE_PROC_FS_POOL_CREATE = 409, + + /** + * @generate: both + * @priority: high + * @acl: fs_pool:stop + */ + REMOTE_PROC_FS_POOL_DESTROY = 410 }; diff --git a/src/rpc/gendispatch.pl b/src/rpc/gendispatch.pl index 173189c..171684b 100755 --- a/src/rpc/gendispatch.pl +++ b/src/rpc/gendispatch.pl @@ -500,7 +500,7 @@ elsif ($mode eq "server") { if ($args_member =~ m/^remote_nonnull_string name;/ and $has_node_device) { # ignore the name arg for node devices next - } elsif ($args_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|interface|secret|nwfilter) (\S+);/) { + } elsif ($args_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|interface|secret|nwfilter|fs_pool|fs_item) (\S+);/) { my $type_name = name_to_TypeName($1); push(@vars_list, "vir${type_name}Ptr $2 = NULL"); @@ -665,7 +665,7 @@ elsif ($mode eq "server") { if (!$modern_ret_as_list) { push(@ret_list, "ret->$3 = tmp.$3;"); } - } elsif ($ret_member =~ m/(?:admin|remote)_nonnull_(secret|nwfilter|node_device|interface|network|storage_vol|storage_pool|domain_snapshot|domain|server|client) (\S+)<(\S+)>;/) { + } elsif ($ret_member =~ m/(?:admin|remote)_nonnull_(secret|nwfilter|node_device|interface|network|storage_vol|storage_pool|domain_snapshot|domain|server|client|fs_pool|fs_item) (\S+)<(\S+)>;/) { $modern_ret_struct_name = $1; $single_ret_list_error_msg_type = $1; $single_ret_list_name = $2; @@ -723,7 +723,7 @@ elsif ($mode eq "server") { $single_ret_var = $1; $single_ret_by_ref = 0; $single_ret_check = " == NULL"; - } elsif ($ret_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|interface|node_device|secret|nwfilter|domain_snapshot) (\S+);/) { + } elsif ($ret_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|interface|node_device|secret|nwfilter|domain_snapshot|fs_pool|fs_item) (\S+);/) { my $type_name = name_to_TypeName($1); if ($call->{ProcName} eq "DomainCreateWithFlags") { @@ -1268,7 +1268,7 @@ elsif ($mode eq "client") { $priv_src = "dev->conn"; push(@args_list, "virNodeDevicePtr dev"); push(@setters_list, "args.name = dev->name;"); - } elsif ($args_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|interface|secret|nwfilter|domain_snapshot) (\S+);/) { + } elsif ($args_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|interface|secret|nwfilter|domain_snapshot|fs_pool|fs_item) (\S+);/) { my $name = $1; my $arg_name = $2; my $type_name = name_to_TypeName($name); @@ -1461,7 +1461,7 @@ elsif ($mode eq "client") { } push(@ret_list, "memcpy(result->$3, ret.$3, sizeof(result->$3));"); - } elsif ($ret_member =~ m/(?:admin|remote)_nonnull_(secret|nwfilter|node_device|interface|network|storage_vol|storage_pool|domain_snapshot|domain|server|client) (\S+)<(\S+)>;/) { + } elsif ($ret_member =~ m/(?:admin|remote)_nonnull_(secret|nwfilter|node_device|interface|network|storage_vol|storage_pool|domain_snapshot|domain|server|client|fs_pool|fs_item) (\S+)<(\S+)>;/) { my $proc_name = name_to_TypeName($1); if ($structprefix eq "admin") { @@ -1513,7 +1513,7 @@ elsif ($mode eq "client") { push(@ret_list, "VIR_FREE(ret.$1);"); $single_ret_var = "char *rv = NULL"; $single_ret_type = "char *"; - } elsif ($ret_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|node_device|interface|secret|nwfilter|domain_snapshot) (\S+);/) { + } elsif ($ret_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|node_device|interface|secret|nwfilter|domain_snapshot|fs_pool|fs_item) (\S+);/) { my $name = $1; my $arg_name = $2; my $type_name = name_to_TypeName($name); @@ -1968,7 +1968,8 @@ elsif ($mode eq "client") { "storage_conf.h", "nwfilter_conf.h", "node_device_conf.h", - "interface_conf.h" + "interface_conf.h", + "fs_conf.h" ); foreach my $hdr (@headers) { print "#include \"$hdr\"\n"; @@ -2065,6 +2066,8 @@ elsif ($mode eq "client") { if ($object ne "Connect") { if ($object eq "StorageVol") { push @argdecls, "virStoragePoolDefPtr pool"; + } elsif ($object eq "FsItem") { + push @argdecls, "virFsPoolDefPtr fspool"; } push @argdecls, "$objecttype $arg"; } @@ -2094,6 +2097,8 @@ elsif ($mode eq "client") { if ($object ne "Connect") { if ($object eq "StorageVol") { push @argvars, "pool"; + } elsif ($object eq "FsItem") { + push @argvars, "fspool"; } push @argvars, $arg; } -- 1.8.3.1

Implementation is backend base as in case of storage pools. This patch adds directory backend which is nothing more than managing directories inside another one as starting point. Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy@virtuozzo.com> --- configure.ac | 33 + daemon/Makefile.am | 4 + po/POTFILES.in | 2 + src/Makefile.am | 38 + src/driver.h | 1 + src/fs/fs_backend.h | 85 ++ src/fs/fs_backend_dir.c | 334 +++++++ src/fs/fs_backend_dir.h | 8 + src/fs/fs_driver.c | 2164 ++++++++++++++++++++++++++++++++++++++++++++++ src/fs/fs_driver.h | 10 + src/libvirt.c | 28 + src/libvirt_private.syms | 1 + 12 files changed, 2708 insertions(+) create mode 100644 src/fs/fs_backend.h create mode 100644 src/fs/fs_backend_dir.c create mode 100644 src/fs/fs_backend_dir.h create mode 100644 src/fs/fs_driver.c create mode 100644 src/fs/fs_driver.h diff --git a/configure.ac b/configure.ac index 8d7d63e..435b1ec 100644 --- a/configure.ac +++ b/configure.ac @@ -1647,6 +1647,35 @@ fi AM_CONDITIONAL([WITH_SECRETS], [test "$with_secrets" = "yes"]) +AC_ARG_WITH([fs-dir], + [AS_HELP_STRING([--with-fs-dir], + [with fs backend for fs driver @<:@default=yes@:>])], + [],[with_fs_dir=yes]) + +if test "$with_libvirtd" = "no"; then + with_fs_dir=no +fi + +if test "$with_fs_dir" = "yes" ; then + AC_DEFINE_UNQUOTED([WITH_FS_DIR], 1, [whether directory backend for fs driver is enabled]) +fi +AM_CONDITIONAL([WITH_FS_DIR], [test "$with_fs_dir" = "yes"]) + +with_fs=no +for backend in dir; do + if eval test \$with_fs_$backend = yes; then + with_fs=yes + break + fi +done +if test $with_fs = yes; then + AC_DEFINE([WITH_FS], [1], + [Define to 1 if at least one fs backend is in use]) +fi +AM_CONDITIONAL([WITH_FS], [test "$with_fs" = "yes"]) + + + AC_ARG_WITH([storage-dir], [AS_HELP_STRING([--with-storage-dir], [with directory backend for the storage driver @<:@default=yes@:>@])], @@ -2760,6 +2789,10 @@ AC_MSG_NOTICE([Sheepdog: $with_storage_sheepdog]) AC_MSG_NOTICE([ Gluster: $with_storage_gluster]) AC_MSG_NOTICE([ ZFS: $with_storage_zfs]) AC_MSG_NOTICE([]) +AC_MSG_NOTICE([Fs Drivers]) +AC_MSG_NOTICE([]) +AC_MSG_NOTICE([ Dir: $with_fs_dir]) +AC_MSG_NOTICE([]) AC_MSG_NOTICE([Security Drivers]) AC_MSG_NOTICE([]) AC_MSG_NOTICE([ SELinux: $with_secdriver_selinux ($SELINUX_MOUNT)]) diff --git a/daemon/Makefile.am b/daemon/Makefile.am index 927d16f..63444cf 100644 --- a/daemon/Makefile.am +++ b/daemon/Makefile.am @@ -241,6 +241,10 @@ if WITH_STORAGE libvirtd_LDADD += ../src/libvirt_driver_storage.la endif WITH_STORAGE +if WITH_FS + libvirtd_LDADD += ../src/libvirt_driver_fs.la +endif WITH_FS + if WITH_NETWORK libvirtd_LDADD += ../src/libvirt_driver_network.la endif WITH_NETWORK diff --git a/po/POTFILES.in b/po/POTFILES.in index f4d2f25..0fc3b79 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -59,6 +59,8 @@ src/esx/esx_vi.c src/esx/esx_vi_methods.c src/esx/esx_vi_types.c src/fdstream.c +src/fs/fs_backend_dir.c +src/fs/fs_driver.c src/hyperv/hyperv_driver.c src/hyperv/hyperv_util.c src/hyperv/hyperv_wmi.c diff --git a/src/Makefile.am b/src/Makefile.am index db69fbb..6275f9e 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -642,6 +642,7 @@ DRIVER_SOURCE_FILES = \ $(REMOTE_DRIVER_SOURCES) \ $(SECRET_DRIVER_SOURCES) \ $(STORAGE_DRIVER_SOURCES) \ + $(FS_DRIVER_SOURCES) \ $(TEST_DRIVER_SOURCES) \ $(UML_DRIVER_SOURCES) \ $(VBOX_DRIVER_SOURCES) \ @@ -662,6 +663,7 @@ STATEFUL_DRIVER_SOURCE_FILES = \ $(QEMU_DRIVER_SOURCES) \ $(SECRET_DRIVER_SOURCES) \ $(STORAGE_DRIVER_SOURCES) \ + $(FS_DRIVER_SOURCES) \ $(UML_DRIVER_SOURCES) \ $(XEN_DRIVER_SOURCES) \ $(NULL) @@ -968,6 +970,14 @@ SECRET_UTIL_SOURCES = \ SECRET_DRIVER_SOURCES = \ secret/secret_driver.h secret/secret_driver.c +# FS pool backend specific impls +FS_DRIVER_SOURCES = \ + fs/fs_driver.h fs/fs_driver.c \ + fs/fs_backend.h + +FS_DRIVER_DIR_SOURCES = \ + fs/fs_backend_dir.h fs/fs_backend_dir.c + # Storage backend specific impls STORAGE_DRIVER_SOURCES = \ storage/storage_driver.h storage/storage_driver.c \ @@ -1631,6 +1641,32 @@ endif WITH_DRIVER_MODULES libvirt_driver_secret_la_SOURCES = $(SECRET_DRIVER_SOURCES) endif WITH_SECRETS +libvirt_driver_fs_impl_la_SOURCES = +libvirt_driver_fs_impl_la_CFLAGS = \ + -I$(srcdir)/access \ + -I$(srcdir)/conf \ + $(AM_CFLAGS) +libvirt_driver_fs_impl_la_LDFLAGS = $(AM_LDFLAGS) +libvirt_driver_fs_impl_la_LIBADD = +libvirt_driver_fs_impl_la_LIBADD += $(SECDRIVER_LIBS) $(LIBXML_LIBS) +if WITH_FS +noinst_LTLIBRARIES += libvirt_driver_fs_impl.la +libvirt_driver_fs_la_SOURCES = +libvirt_driver_fs_la_LIBADD = libvirt_driver_fs_impl.la +if WITH_DRIVER_MODULES +mod_LTLIBRARIES += libvirt_driver_fs.la +libvirt_driver_fs_la_LIBADD += ../gnulib/lib/libgnu.la +libvirt_driver_fs_la_LDFLAGS = -module -avoid-version $(AM_LDFLAGS) +else ! WITH_DRIVER_MODULES +noinst_LTLIBRARIES += libvirt_driver_fs.la +# Stateful, so linked to daemon instead +#libvirt_la_BUILT_LIBADD += libvirt_driver_fs.la +endif ! WITH_DRIVER_MODULES +libvirt_driver_fs_impl_la_SOURCES += $(FS_DRIVER_SOURCES) +libvirt_driver_fs_impl_la_SOURCES += $(FS_DRIVER_DIR_SOURCES) +endif WITH_FS + + # Needed to keep automake quiet about conditionals libvirt_driver_storage_impl_la_SOURCES = libvirt_driver_storage_impl_la_CFLAGS = \ @@ -1902,6 +1938,8 @@ EXTRA_DIST += \ $(BHYVE_DRIVER_SOURCES) \ $(NETWORK_DRIVER_SOURCES) \ $(INTERFACE_DRIVER_SOURCES) \ + $(FS_DRIVER_SOURCES) \ + $(FS_DRIVER_DIR_SOURCES) \ $(STORAGE_DRIVER_SOURCES) \ $(STORAGE_DRIVER_FS_SOURCES) \ $(STORAGE_DRIVER_LVM_SOURCES) \ diff --git a/src/driver.h b/src/driver.h index 57ad1f7..6d475f9 100644 --- a/src/driver.h +++ b/src/driver.h @@ -100,6 +100,7 @@ int virSetSharedNodeDeviceDriver(virNodeDeviceDriverPtr driver) ATTRIBUTE_RETURN int virSetSharedNWFilterDriver(virNWFilterDriverPtr driver) ATTRIBUTE_RETURN_CHECK; int virSetSharedSecretDriver(virSecretDriverPtr driver) ATTRIBUTE_RETURN_CHECK; int virSetSharedStorageDriver(virStorageDriverPtr driver) ATTRIBUTE_RETURN_CHECK; +int virSetSharedFsDriver(virFsDriverPtr driver) ATTRIBUTE_RETURN_CHECK; void *virDriverLoadModule(const char *name); diff --git a/src/fs/fs_backend.h b/src/fs/fs_backend.h new file mode 100644 index 0000000..f714b29 --- /dev/null +++ b/src/fs/fs_backend.h @@ -0,0 +1,85 @@ +#ifndef __VIR_FS_BACKEND_H__ +# define __VIR_FS_BACKEND_H__ + +# include <sys/stat.h> + +# include "internal.h" +# include "fs_conf.h" +# include "fs_driver.h" + +typedef char * (*virFsBackendFindFspoolSources)(virConnectPtr conn, + const char *srcSpec, + unsigned int flags); +typedef int (*virFsBackendCheckFspool)(virFsPoolObjPtr fspool, + bool *active); +typedef int (*virFsBackendStartFspool)(virConnectPtr conn, + virFsPoolObjPtr fspool); +typedef int (*virFsBackendBuildFspool)(virConnectPtr conn, + virFsPoolObjPtr fspool, + unsigned int flags); +typedef int (*virFsBackendRefreshFspool)(virConnectPtr conn, + virFsPoolObjPtr fspool); +typedef int (*virFsBackendStopFspool)(virConnectPtr conn, + virFsPoolObjPtr fspool); +typedef int (*virFsBackendDeleteFspool)(virConnectPtr conn, + virFsPoolObjPtr fspool, + unsigned int flags); + +/* FIXME */ + +/* A 'buildItem' backend must remove any volume created on error since + * the storage driver does not distinguish whether the failure is due + * to failure to create the volume, to reserve any space necessary for + * the volume, to get data about the volume, to change it's accessibility, + * etc. This avoids issues arising from a creation failure due to some + * external action which created a volume of the same name that libvirt + * was not aware of between checking the fspool and the create attempt. It + * also avoids extra round trips to just delete a file. + */ +typedef int (*virFsBackendBuildItem)(virConnectPtr conn, + virFsPoolObjPtr fspool, + virFsItemDefPtr item, + unsigned int flags); +typedef int (*virFsBackendCreateItem)(virConnectPtr conn, + virFsPoolObjPtr fspool, + virFsItemDefPtr item); +typedef int (*virFsBackendRefreshItem)(virConnectPtr conn, + virFsPoolObjPtr fspool, + virFsItemDefPtr item); +typedef int (*virFsBackendDeleteItem)(virConnectPtr conn, + virFsPoolObjPtr fspool, + virFsItemDefPtr item, + unsigned int flags); +typedef int (*virFsBackendBuildItemFrom)(virConnectPtr conn, + virFsPoolObjPtr fspool, + virFsItemDefPtr origitem, + virFsItemDefPtr newitem, + unsigned int flags); + +typedef struct _virFsBackend virFsBackend; +typedef virFsBackend *virFsBackendPtr; + +/* Callbacks are optional unless documented otherwise; but adding more + * callbacks provides better fspool support. */ +struct _virFsBackend { + int type; + + virFsBackendFindFspoolSources findFspoolSources; + virFsBackendCheckFspool checkFspool; + virFsBackendStartFspool startFspool; + virFsBackendBuildFspool buildFspool; + virFsBackendRefreshFspool refreshFspool; /* Must be non-NULL */ + virFsBackendStopFspool stopFspool; + virFsBackendDeleteFspool deleteFspool; + + virFsBackendBuildItem buildItem; + virFsBackendBuildItemFrom buildItemFrom; + virFsBackendCreateItem createItem; + virFsBackendRefreshItem refreshItem; + virFsBackendDeleteItem deleteItem; +}; + +# define VIR_FS_DEFAULT_POOL_PERM_MODE 0755 +# define VIR_FS_DEFAULT_ITEM_PERM_MODE 0600 + +#endif /* __VIR_FS_BACKEND_H__ */ diff --git a/src/fs/fs_backend_dir.c b/src/fs/fs_backend_dir.c new file mode 100644 index 0000000..fc08b85 --- /dev/null +++ b/src/fs/fs_backend_dir.c @@ -0,0 +1,334 @@ +#include <config.h> + +#include <sys/statvfs.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <stdio.h> +#include <dirent.h> +#include <errno.h> +#include <fcntl.h> +#include <unistd.h> +#include <string.h> + +#include <libxml/parser.h> +#include <libxml/tree.h> +#include <libxml/xpath.h> + +#include "virerror.h" +#include "fs_backend_dir.h" +#include "fs_conf.h" +#include "vircommand.h" +#include "viralloc.h" +#include "virxml.h" +#include "virfile.h" +#include "virlog.h" +#include "virstring.h" +#include "fdstream.h" +#include "stat-time.h" + +#define VIR_FROM_THIS VIR_FROM_FSPOOL + +VIR_LOG_INIT("fs.fs_backend_dir"); + +static int +virFsDirBuild(virConnectPtr conn ATTRIBUTE_UNUSED, + virFsPoolObjPtr fspool, + unsigned int flags) +{ + int ret = -1; + char *parent = NULL; + char *p = NULL; + mode_t mode; + unsigned int dir_create_flags; + + virCheckFlags(0, -1); + + if (VIR_STRDUP(parent, fspool->def->target.path) < 0) + goto error; + if (!(p = strrchr(parent, '/'))) { + virReportError(VIR_ERR_INVALID_ARG, + _("path '%s' is not absolute"), + fspool->def->target.path); + goto error; + } + + if (p != parent) { + /* assure all directories in the path prior to the final dir + * exist, with default uid/gid/mode. */ + *p = '\0'; + if (virFileMakePath(parent) < 0) { + virReportSystemError(errno, _("cannot create path '%s'"), + parent); + goto error; + } + } + + dir_create_flags = VIR_DIR_CREATE_ALLOW_EXIST; + mode = fspool->def->target.perms.mode; + + if (mode == (mode_t) -1 && + (!virFileExists(fspool->def->target.path))) + mode = VIR_FS_DEFAULT_POOL_PERM_MODE; + + /* Now create the final dir in the path with the uid/gid/mode + * requested in the config. If the dir already exists, just set + * the perms. */ + if (virDirCreate(fspool->def->target.path, + mode, + fspool->def->target.perms.uid, + fspool->def->target.perms.gid, + dir_create_flags) < 0) + goto error; + + ret = 0; + + error: + VIR_FREE(parent); + return ret; +} + +static int +virFsDirRefresh(virConnectPtr conn ATTRIBUTE_UNUSED, + virFsPoolObjPtr fspool) +{ + DIR *dir; + struct dirent *entry; + virFsItemDefPtr item = NULL; + struct statvfs sb; + struct stat statbuf; + int fd = 0; + int ret = -1; + + if (virDirOpen(&dir, fspool->def->target.path) < 0) + goto cleanup; + + while (virDirRead(dir, &entry, fspool->def->target.path) > 0) { + if (virStringHasControlChars(entry->d_name)) { + VIR_WARN("Ignoring control characters under '%s'", + fspool->def->target.path); + continue; + } + + if (VIR_ALLOC(item) < 0) + goto cleanup; + + if (VIR_STRDUP(item->name, entry->d_name) < 0) + goto cleanup; + item->type = VIR_FS_ITEM_DIR; + if (virAsprintf(&item->target.path, "%s/%s", + fspool->def->target.path, + item->name) == -1) + goto cleanup; + + if (VIR_STRDUP(item->key, item->target.path) < 0) + goto cleanup; + + + if (VIR_APPEND_ELEMENT(fspool->items.objs, fspool->items.count, item) < 0) + goto cleanup; + } + + + if ((fd = open(fspool->def->target.path, O_RDONLY)) < 0) { + virReportSystemError(errno, + _("cannot open path '%s'"), + fspool->def->target.path); + goto cleanup; + } + + if (fstat(fd, &statbuf) < 0) { + virReportSystemError(errno, + _("cannot stat path '%s'"), + fspool->def->target.path); + goto cleanup; + } + + fspool->def->target.perms.mode = statbuf.st_mode & S_IRWXUGO; + fspool->def->target.perms.uid = statbuf.st_uid; + fspool->def->target.perms.gid = statbuf.st_gid; + + if (statvfs(fspool->def->target.path, &sb) < 0) { + virReportSystemError(errno, + _("cannot statvfs path '%s'"), + fspool->def->target.path); + goto cleanup; + } + + fspool->def->capacity = ((unsigned long long)sb.f_blocks * + (unsigned long long)sb.f_frsize); + fspool->def->available = ((unsigned long long)sb.f_bfree * + (unsigned long long)sb.f_frsize); + fspool->def->allocation = fspool->def->capacity - fspool->def->available; + + ret = 0; + + cleanup: + VIR_DIR_CLOSE(dir); + VIR_FORCE_CLOSE(fd); + virFsItemDefFree(item); + if (ret < 0) + virFsPoolObjClearItems(fspool); + return ret; +} + +static int +virFsDirDelete(virConnectPtr conn ATTRIBUTE_UNUSED, + virFsPoolObjPtr fspool, + unsigned int flags) +{ + virCheckFlags(0, -1); + + if (rmdir(fspool->def->target.path) < 0) { + virReportSystemError(errno, _("failed to remove fspool '%s'"), + fspool->def->target.path); + return -1; + } + + return 0; + +} +static int +virFsDirItemBuild(virConnectPtr conn ATTRIBUTE_UNUSED, + virFsPoolObjPtr fspool ATTRIBUTE_UNUSED, + virFsItemDefPtr item, + unsigned int flags) +{ + virCheckFlags(0, -1); + + if (item->type == VIR_FS_ITEM_DIR) { + if ((virDirCreate(item->target.path, + (item->target.perms->mode == (mode_t) -1 ? + VIR_FS_DEFAULT_ITEM_PERM_MODE: + item->target.perms->mode), + item->target.perms->uid, + item->target.perms->gid, + 0)) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("error creating item")); + return -1; + } + } + + return 0; +} + +static int +virFsDirItemBuildFrom(virConnectPtr conn ATTRIBUTE_UNUSED, + virFsPoolObjPtr fspool ATTRIBUTE_UNUSED, + virFsItemDefPtr item, + virFsItemDefPtr inputitem, + unsigned int flags) +{ + virCommandPtr cmd = NULL; + int ret = -1; + + virCheckFlags(0, -1); + + item->target.capacity = inputitem->target.capacity; + cmd = virCommandNewArgList("cp", "-r", inputitem->target.path, + item->target.path, NULL); + ret = virCommandRun(cmd, NULL); + + virCommandFree(cmd); + return ret; +} + +static int +virFsDirItemCreate(virConnectPtr conn ATTRIBUTE_UNUSED, + virFsPoolObjPtr fspool, + virFsItemDefPtr item) +{ + if (strchr(item->name, '/')) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("volume name '%s' cannot contain '/'"), item->name); + return -1; + } + + VIR_FREE(item->target.path); + if (virAsprintf(&item->target.path, "%s/%s", + fspool->def->target.path, + item->name) == -1) + return -1; + + if (virFileExists(item->target.path)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("item target path '%s' already exists"), + item->target.path); + return -1; + } + + VIR_FREE(item->key); + return VIR_STRDUP(item->key, item->target.path); +} + + +static int +virFsDirItemRefresh(virConnectPtr conn ATTRIBUTE_UNUSED, + virFsPoolObjPtr fspool ATTRIBUTE_UNUSED, + virFsItemDefPtr item) +{ + int fd; + int ret = -1; + struct stat statbuf; + virCommandPtr cmd = NULL; + char *output = NULL, *end; + + if ((fd = open(item->target.path, O_RDONLY)) < 0) { + virReportSystemError(errno, _("cannot open directory '%s'"), + item->target.path); + return -1; + } + if (fstat(fd, &statbuf) < 0) { + virReportSystemError(errno, _("cannot stat path '%s'"), + item->target.path); + goto cleanup; + } + + cmd = virCommandNewArgList("du", "-sB1", item->target.path, NULL); + virCommandSetOutputBuffer(cmd, &output); + if ((ret = virCommandRun(cmd, NULL)) < 0) + goto cleanup; + + if (virStrToLong_ull(output, &end, 10, &item->target.allocation) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Malformed du output: %s"), output); + goto cleanup; + } + + if (&(item->target.perms) && VIR_ALLOC(*(&item->target.perms)) < 0) + goto cleanup; + item->target.perms->mode = statbuf.st_mode & S_IRWXUGO; + item->target.perms->uid = statbuf.st_uid; + item->target.perms->gid = statbuf.st_gid; + + ret = 0; + cleanup: + VIR_FORCE_CLOSE(fd); + VIR_FREE(output); + virCommandFree(cmd); + return ret; +} + +static int +virFsDirItemDelete(virConnectPtr conn ATTRIBUTE_UNUSED, + virFsPoolObjPtr fspool ATTRIBUTE_UNUSED, + virFsItemDefPtr item, + unsigned int flags) +{ + virCheckFlags(0, -1); + + return virFileDeleteTree(item->target.path); +} + +virFsBackend virFsBackendDir = { + .type = VIR_FS_POOL_DIR, + + .buildFspool = virFsDirBuild, + .refreshFspool = virFsDirRefresh, + .deleteFspool = virFsDirDelete, + .buildItem = virFsDirItemBuild, + .buildItemFrom = virFsDirItemBuildFrom, + .createItem = virFsDirItemCreate, + .deleteItem = virFsDirItemDelete, + .refreshItem = virFsDirItemRefresh, +}; diff --git a/src/fs/fs_backend_dir.h b/src/fs/fs_backend_dir.h new file mode 100644 index 0000000..d8ff68f --- /dev/null +++ b/src/fs/fs_backend_dir.h @@ -0,0 +1,8 @@ +#ifndef __VIR_FS_BACKEND_DIR_H__ +# define __VIR_FS_BACKEND_DIR_H__ + +# include "fs_backend.h" + +extern virFsBackend virFsBackendDir; + +#endif /* __VIR_FS_BACKEND_DIR_H__ */ diff --git a/src/fs/fs_driver.c b/src/fs/fs_driver.c new file mode 100644 index 0000000..76aba7a --- /dev/null +++ b/src/fs/fs_driver.c @@ -0,0 +1,2164 @@ +#include <config.h> + +#include <stdio.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/param.h> +#include <fcntl.h> + +#include <errno.h> +#include <string.h> + +#include "virerror.h" +#include "datatypes.h" +#include "driver.h" +#include "fs_driver.h" +#include "fs_conf.h" +#include "fs_backend.h" +#include "viralloc.h" +#include "virlog.h" +#include "virfile.h" +#include "fdstream.h" +#include "configmake.h" +#include "virstring.h" +#include "viraccessapicheck.h" +#include "dirname.h" + +#if WITH_FS_DIR +# include "fs_backend_dir.h" +#endif + +#define VIR_FROM_THIS VIR_FROM_FSPOOL + +VIR_LOG_INIT("fs.fs_driver"); + +static virFsDriverStatePtr driver; + +typedef struct _virFsItemStreamInfo virFsItemStreamInfo; +typedef virFsItemStreamInfo *virFsItemStreamInfoPtr; +struct _virFsItemStreamInfo { + char *fspool_name; + char *item_path; +}; + +static int fsStateCleanup(void); + +static void fsDriverLock(void) +{ + virMutexLock(&driver->lock); +} + +static void fsDriverUnlock(void) +{ + virMutexUnlock(&driver->lock); +} + +static virFsBackendPtr backends[] = { +#if WITH_FS_DIR + &virFsBackendDir, +#endif +}; + +static virFsBackendPtr +virFsBackendForType(int type) +{ + size_t i; + for (i = 0; backends[i]; i++) + if (backends[i]->type == type) + return backends[i]; + + virReportError(VIR_ERR_INTERNAL_ERROR, + _("missing backend for fspool type %d (%s)"), + type, NULLSTR(virFsPoolTypeToString(type))); + return NULL; +} + +static void +fsItemRemoveFromFsPool(virFsPoolObjPtr fspool, + virFsItemDefPtr item) +{ + size_t i; + + for (i = 0; i < fspool->items.count; i++) { + if (fspool->items.objs[i] == item) { + VIR_INFO("Deleting item '%s' from fspool '%s'", + item->name, fspool->def->name); + virFsItemDefFree(item); + + VIR_DELETE_ELEMENT(fspool->items.objs, i, fspool->items.count); + break; + } + } +} + +static int +fsItemDeleteInternal(virFsItemPtr obj, + virFsBackendPtr backend, + virFsPoolObjPtr fspool, + virFsItemDefPtr item, + unsigned int flags) +{ + int ret = -1; + + virCheckFlags(0, -1); + + if (!backend->deleteItem) { + virReportError(VIR_ERR_NO_SUPPORT, + "%s", _("fspool does not support item deletion")); + goto cleanup; + } + if (backend->deleteItem(obj->conn, fspool, item, flags) < 0) + goto cleanup; + + fsItemRemoveFromFsPool(fspool, item); + + ret = 0; + + cleanup: + return ret; +} + +static virFsItemDefPtr +virFsItemDefFromItem(virFsItemPtr obj, + virFsPoolObjPtr *fspool, + virFsBackendPtr *backend) +{ + virFsItemDefPtr item = NULL; + + *fspool = NULL; + + fsDriverLock(); + *fspool = virFsPoolObjFindByName(&driver->fspools, obj->fspool); + fsDriverUnlock(); + + if (!*fspool) { + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching name '%s'"), + obj->fspool); + return NULL; + } + + if (!virFsPoolObjIsActive(*fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is not active"), + (*fspool)->def->name); + goto error; + } + + if (!(item = virFsItemDefFindByName(*fspool, obj->name))) { + virReportError(VIR_ERR_NO_FS_ITEM, + _("no fs item with matching name '%s'"), + obj->name); + goto error; + } + + if (backend) { + if (!(*backend = virFsBackendForType((*fspool)->def->type))) + goto error; + } + + return item; + + error: + virFsPoolObjUnlock(*fspool); + *fspool = NULL; + + return NULL; +} + +static void +fsPoolUpdateState(virFsPoolObjPtr fspool) +{ + bool active; + virFsBackendPtr backend; + int ret = -1; + char *stateFile; + + if (!(stateFile = virFileBuildPath(driver->stateDir, + fspool->def->name, ".xml"))) + goto error; + + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) { + VIR_ERROR(_("Missing backend %d"), fspool->def->type); + goto error; + } + + /* Backends which do not support 'checkFspool' are considered + * inactive by default. + */ + active = false; + if (backend->checkFspool && + backend->checkFspool(fspool, &active) < 0) { + virErrorPtr err = virGetLastError(); + VIR_ERROR(_("Failed to initialize fspool '%s': %s"), + fspool->def->name, err ? err->message : + _("no error message found")); + goto error; + } + + /* We can pass NULL as connection, most backends do not use + * it anyway, but if they do and fail, we want to log error and + * continue with other fspools. + */ + if (active) { + virFsPoolObjClearItems(fspool); + if (backend->refreshFspool(NULL, fspool) < 0) { + virErrorPtr err = virGetLastError(); + if (backend->stopFspool) + backend->stopFspool(NULL, fspool); + VIR_ERROR(_("Failed to restart fspool '%s': %s"), + fspool->def->name, err ? err->message : + _("no error message found")); + goto error; + } + } + + fspool->active = active; + ret = 0; + error: + if (ret < 0) { + if (stateFile) + unlink(stateFile); + } + VIR_FREE(stateFile); + + return; +} + +static void +fsPoolUpdateAllState(void) +{ + size_t i; + + for (i = 0; i < driver->fspools.count; i++) { + virFsPoolObjPtr fspool = driver->fspools.objs[i]; + + virFsPoolObjLock(fspool); + fsPoolUpdateState(fspool); + virFsPoolObjUnlock(fspool); + } +} + +static void +fsDriverAutostart(void) +{ + size_t i; + virConnectPtr conn = NULL; + + /* XXX Remove hardcoding of QEMU URI */ + if (driver->privileged) + conn = virConnectOpen("qemu:///system"); + else + conn = virConnectOpen("qemu:///session"); + /* Ignoring NULL conn - let backends decide */ + + for (i = 0; i < driver->fspools.count; i++) { + virFsPoolObjPtr fspool = driver->fspools.objs[i]; + virFsBackendPtr backend; + bool started = false; + + virFsPoolObjLock(fspool); + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) { + virFsPoolObjUnlock(fspool); + continue; + } + + if (fspool->autostart && + !virFsPoolObjIsActive(fspool)) { + if (backend->startFspool && + backend->startFspool(conn, fspool) < 0) { + virErrorPtr err = virGetLastError(); + VIR_ERROR(_("Failed to autostart fspool '%s': %s"), + fspool->def->name, err ? err->message : + _("no error message found")); + virFsPoolObjUnlock(fspool); + continue; + } + started = true; + } + + if (started) { + char *stateFile; + + virFsPoolObjClearItems(fspool); + stateFile = virFileBuildPath(driver->stateDir, + fspool->def->name, ".xml"); + if (!stateFile || + virFsPoolSaveState(stateFile, fspool->def) < 0 || + backend->refreshFspool(conn, fspool) < 0) { + virErrorPtr err = virGetLastError(); + if (stateFile) + unlink(stateFile); + if (backend->stopFspool) + backend->stopFspool(conn, fspool); + VIR_ERROR(_("Failed to autostart fspool '%s': %s"), + fspool->def->name, err ? err->message : + _("no error message found")); + } else { + fspool->active = true; + } + VIR_FREE(stateFile); + } + virFsPoolObjUnlock(fspool); + } + + virObjectUnref(conn); +} + +/** + * virFsStartup: + * + * Initialization function for the Fs Driver + */ +static int +fsStateInitialize(bool privileged, + virStateInhibitCallback callback ATTRIBUTE_UNUSED, + void *opaque ATTRIBUTE_UNUSED) +{ + int ret = -1; + char *configdir = NULL; + char *rundir = NULL; + + if (VIR_ALLOC(driver) < 0) + return ret; + + if (virMutexInit(&driver->lock) < 0) { + VIR_FREE(driver); + return ret; + } + fsDriverLock(); + + if (privileged) { + if (VIR_STRDUP(driver->configDir, + SYSCONFDIR "/libvirt/fs") < 0 || + VIR_STRDUP(driver->autostartDir, + SYSCONFDIR "/libvirt/fs/autostart") < 0 || + VIR_STRDUP(driver->stateDir, + LOCALSTATEDIR "/run/libvirt/fs") < 0) + goto error; + } else { + configdir = virGetUserConfigDirectory(); + rundir = virGetUserRuntimeDirectory(); + if (!(configdir && rundir)) + goto error; + + if ((virAsprintf(&driver->configDir, + "%s/fs", configdir) < 0) || + (virAsprintf(&driver->autostartDir, + "%s/fs/autostart", configdir) < 0) || + (virAsprintf(&driver->stateDir, + "%s/fs/run", rundir) < 0)) + goto error; + } + driver->privileged = privileged; + + if (virFileMakePath(driver->stateDir) < 0) { + virReportError(errno, + _("cannot create directory %s"), + driver->stateDir); + goto error; + } + + if (virFsPoolLoadAllState(&driver->fspools, + driver->stateDir) < 0) + goto error; + + if (virFsPoolLoadAllConfigs(&driver->fspools, + driver->configDir, + driver->autostartDir) < 0) + goto error; + + fsPoolUpdateAllState(); + + fsDriverUnlock(); + + ret = 0; + cleanup: + VIR_FREE(configdir); + VIR_FREE(rundir); + return ret; + + error: + fsDriverUnlock(); + fsStateCleanup(); + goto cleanup; +} + +/** + * fsStateAutoStart: + * + * Function to auto start the fs_driver + */ +static void +fsStateAutoStart(void) +{ + if (!driver) + return; + + fsDriverLock(); + fsDriverAutostart(); + fsDriverUnlock(); +} + +/** + * fsStateReload: + * + * Function to restart the fs_driver, it will recheck the configuration + * files and update its state + */ +static int +fsStateReload(void) +{ + if (!driver) + return -1; + + fsDriverLock(); + virFsPoolLoadAllState(&driver->fspools, + driver->stateDir); + virFsPoolLoadAllConfigs(&driver->fspools, + driver->configDir, + driver->autostartDir); + fsDriverAutostart(); + fsDriverUnlock(); + + return 0; +} + + +/** + * fsStateCleanup + * + * Shutdown the fs driver, it will stop all active fspools + */ +static int +fsStateCleanup(void) +{ + if (!driver) + return -1; + + fsDriverLock(); + + /* free inactive fspools */ + virFsPoolObjListFree(&driver->fspools); + + VIR_FREE(driver->configDir); + VIR_FREE(driver->autostartDir); + VIR_FREE(driver->stateDir); + fsDriverUnlock(); + virMutexDestroy(&driver->lock); + VIR_FREE(driver); + + return 0; +} + + +static virFsPoolObjPtr +virFsPoolObjFromFsPool(virFsPoolPtr fspool) +{ + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virFsPoolObjPtr ret; + + fsDriverLock(); + if (!(ret = virFsPoolObjFindByUUID(&driver->fspools, fspool->uuid))) { + virUUIDFormat(fspool->uuid, uuidstr); + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching uuid '%s' (%s)"), + uuidstr, fspool->name); + } + fsDriverUnlock(); + + return ret; +} + +static int +fsConnectNumOfFsPools(virConnectPtr conn) +{ + size_t i; + int nactive = 0; + + if (virConnectNumOfFsPoolsEnsureACL(conn) < 0) + return -1; + + fsDriverLock(); + for (i = 0; i < driver->fspools.count; i++) { + virFsPoolObjPtr obj = driver->fspools.objs[i]; + virFsPoolObjLock(obj); + if (virConnectNumOfFsPoolsCheckACL(conn, obj->def) && + virFsPoolObjIsActive(obj)) + nactive++; + virFsPoolObjUnlock(obj); + } + fsDriverUnlock(); + + return nactive; +} + +static int +fsConnectListAllFsPools(virConnectPtr conn, + virFsPoolPtr **fspools, + unsigned int flags) +{ + int ret = -1; + + virCheckFlags(VIR_CONNECT_LIST_FS_POOLS_FILTERS_ALL, -1); + + if (virConnectListAllFsPoolsEnsureACL(conn) < 0) + goto cleanup; + + fsDriverLock(); + ret = virFsPoolObjListExport(conn, driver->fspools, fspools, + virConnectListAllFsPoolsCheckACL, + flags); + fsDriverUnlock(); + + cleanup: + return ret; +} + +static int +fsConnectListFsPools(virConnectPtr conn, + char **const names, + int nnames) +{ + int got = 0; + size_t i; + + if (virConnectListFsPoolsEnsureACL(conn) < 0) + return -1; + + fsDriverLock(); + for (i = 0; i < driver->fspools.count && got < nnames; i++) { + virFsPoolObjPtr obj = driver->fspools.objs[i]; + virFsPoolObjLock(obj); + if (virConnectListFsPoolsCheckACL(conn, obj->def) && + virFsPoolObjIsActive(obj)) { + if (VIR_STRDUP(names[got], obj->def->name) < 0) { + virFsPoolObjUnlock(obj); + goto cleanup; + } + got++; + } + virFsPoolObjUnlock(obj); + } + fsDriverUnlock(); + return got; + + cleanup: + fsDriverUnlock(); + for (i = 0; i < got; i++) + VIR_FREE(names[i]); + memset(names, 0, nnames * sizeof(*names)); + return -1; +} + +static int +fsConnectNumOfDefinedFsPools(virConnectPtr conn) +{ + size_t i; + int nactive = 0; + + if (virConnectNumOfDefinedFsPoolsEnsureACL(conn) < 0) + return -1; + + fsDriverLock(); + for (i = 0; i < driver->fspools.count; i++) { + virFsPoolObjPtr obj = driver->fspools.objs[i]; + virFsPoolObjLock(obj); + if (virConnectNumOfDefinedFsPoolsCheckACL(conn, obj->def) && + !virFsPoolObjIsActive(obj)) + nactive++; + virFsPoolObjUnlock(obj); + } + fsDriverUnlock(); + + return nactive; +} + +static int +fsConnectListDefinedFsPools(virConnectPtr conn, + char **const names, + int nnames) +{ + int got = 0; + size_t i; + + if (virConnectListDefinedFsPoolsEnsureACL(conn) < 0) + return -1; + + fsDriverLock(); + for (i = 0; i < driver->fspools.count && got < nnames; i++) { + virFsPoolObjPtr obj = driver->fspools.objs[i]; + virFsPoolObjLock(obj); + if (virConnectListDefinedFsPoolsCheckACL(conn, obj->def) && + !virFsPoolObjIsActive(obj)) { + if (VIR_STRDUP(names[got], obj->def->name) < 0) { + virFsPoolObjUnlock(obj); + goto cleanup; + } + got++; + } + virFsPoolObjUnlock(obj); + } + fsDriverUnlock(); + return got; + + cleanup: + fsDriverUnlock(); + for (i = 0; i < got; i++) + VIR_FREE(names[i]); + memset(names, 0, nnames * sizeof(*names)); + return -1; +} + +static virFsPoolPtr +fsPoolLookupByUUID(virConnectPtr conn, + const unsigned char *uuid) +{ + virFsPoolObjPtr fspool; + virFsPoolPtr ret = NULL; + + fsDriverLock(); + fspool = virFsPoolObjFindByUUID(&driver->fspools, uuid); + fsDriverUnlock(); + + if (!fspool) { + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virUUIDFormat(uuid, uuidstr); + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching uuid '%s'"), uuidstr); + return NULL; + } + + if (virFsPoolLookupByUUIDEnsureACL(conn, fspool->def) < 0) + goto cleanup; + + ret = virGetFsPool(conn, fspool->def->name, fspool->def->uuid, + NULL, NULL); + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static virFsPoolPtr +fsPoolLookupByName(virConnectPtr conn, + const char *name) +{ + virFsPoolObjPtr fspool; + virFsPoolPtr ret = NULL; + + fsDriverLock(); + fspool = virFsPoolObjFindByName(&driver->fspools, name); + fsDriverUnlock(); + + if (!fspool) { + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching name '%s'"), name); + return NULL; + } + + if (virFsPoolLookupByNameEnsureACL(conn, fspool->def) < 0) + goto cleanup; + + ret = virGetFsPool(conn, fspool->def->name, fspool->def->uuid, + NULL, NULL); + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static virFsPoolPtr +fsPoolLookupByItem(virFsItemPtr item) +{ + virFsPoolObjPtr fspool; + virFsPoolPtr ret = NULL; + + fsDriverLock(); + fspool = virFsPoolObjFindByName(&driver->fspools, item->fspool); + fsDriverUnlock(); + + if (!fspool) { + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching name '%s'"), + item->fspool); + return NULL; + } + + if (virFsPoolLookupByItemEnsureACL(item->conn, fspool->def) < 0) + goto cleanup; + + ret = virGetFsPool(item->conn, fspool->def->name, fspool->def->uuid, + NULL, NULL); + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + + +static virFsPoolPtr +fsPoolCreateXML(virConnectPtr conn, + const char *xml, + unsigned int flags) +{ + virFsPoolDefPtr def; + virFsPoolObjPtr fspool = NULL; + virFsPoolPtr ret = NULL; + virFsBackendPtr backend; + char *stateFile = NULL; + unsigned int build_flags = 0; + + virCheckFlags(VIR_FS_POOL_CREATE_WITH_BUILD | + VIR_FS_POOL_CREATE_WITH_BUILD_OVERWRITE | + VIR_FS_POOL_CREATE_WITH_BUILD_NO_OVERWRITE, NULL); + + VIR_EXCLUSIVE_FLAGS_RET(VIR_FS_POOL_BUILD_OVERWRITE, + VIR_FS_POOL_BUILD_NO_OVERWRITE, NULL); + + fsDriverLock(); + if (!(def = virFsPoolDefParseString(xml))) + goto cleanup; + + if (virFsPoolCreateXMLEnsureACL(conn, def) < 0) + goto cleanup; + + if (virFsPoolObjIsDuplicate(&driver->fspools, def, 1) < 0) + goto cleanup; + + if (virFsPoolSourceFindDuplicate(conn, &driver->fspools, def) < 0) + goto cleanup; + + if ((backend = virFsBackendForType(def->type)) == NULL) + goto cleanup; + + if (!(fspool = virFsPoolObjAssignDef(&driver->fspools, def))) + goto cleanup; + def = NULL; + + if (backend->buildFspool) { + if (flags & VIR_FS_POOL_CREATE_WITH_BUILD_OVERWRITE) + build_flags |= VIR_FS_POOL_BUILD_OVERWRITE; + else if (flags & VIR_FS_POOL_CREATE_WITH_BUILD_NO_OVERWRITE) + build_flags |= VIR_FS_POOL_BUILD_NO_OVERWRITE; + + if (build_flags || + (flags & VIR_FS_POOL_CREATE_WITH_BUILD)) { + if (backend->buildFspool(conn, fspool, build_flags) < 0) { + virFsPoolObjRemove(&driver->fspools, fspool); + fspool = NULL; + goto cleanup; + } + } + } + + if (backend->startFspool && + backend->startFspool(conn, fspool) < 0) { + virFsPoolObjRemove(&driver->fspools, fspool); + fspool = NULL; + goto cleanup; + } + + stateFile = virFileBuildPath(driver->stateDir, + fspool->def->name, ".xml"); + + if (!stateFile || virFsPoolSaveState(stateFile, fspool->def) < 0 || + backend->refreshFspool(conn, fspool) < 0) { + if (stateFile) + unlink(stateFile); + if (backend->stopFspool) + backend->stopFspool(conn, fspool); + virFsPoolObjRemove(&driver->fspools, fspool); + fspool = NULL; + goto cleanup; + } + VIR_INFO("Creating fspool '%s'", fspool->def->name); + fspool->active = true; + + ret = virGetFsPool(conn, fspool->def->name, fspool->def->uuid, + NULL, NULL); + + cleanup: + VIR_FREE(stateFile); + virFsPoolDefFree(def); + if (fspool) + virFsPoolObjUnlock(fspool); + fsDriverUnlock(); + return ret; +} + +static virFsPoolPtr +fsPoolDefineXML(virConnectPtr conn, + const char *xml, + unsigned int flags) +{ + virFsPoolDefPtr def; + virFsPoolObjPtr fspool = NULL; + virFsPoolPtr ret = NULL; + + virCheckFlags(0, NULL); + + fsDriverLock(); + if (!(def = virFsPoolDefParseString(xml))) + goto cleanup; + + if (virFsPoolDefineXMLEnsureACL(conn, def) < 0) + goto cleanup; + + if (virFsPoolObjIsDuplicate(&driver->fspools, def, 0) < 0) + goto cleanup; + + if (virFsPoolSourceFindDuplicate(conn, &driver->fspools, def) < 0) + goto cleanup; + + if (virFsBackendForType(def->type) == NULL) + goto cleanup; + + if (!(fspool = virFsPoolObjAssignDef(&driver->fspools, def))) + goto cleanup; + + if (virFsPoolObjSaveDef(driver, fspool, def) < 0) { + virFsPoolObjRemove(&driver->fspools, fspool); + def = NULL; + fspool = NULL; + goto cleanup; + } + def = NULL; + + VIR_INFO("Defining fspool '%s'", fspool->def->name); + ret = virGetFsPool(conn, fspool->def->name, fspool->def->uuid, + NULL, NULL); + + cleanup: + virFsPoolDefFree(def); + if (fspool) + virFsPoolObjUnlock(fspool); + fsDriverUnlock(); + return ret; +} + +static int +fsPoolCreate(virFsPoolPtr obj, + unsigned int flags) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + int ret = -1; + char *stateFile = NULL; + unsigned int build_flags = 0; + + virCheckFlags(VIR_FS_POOL_CREATE_WITH_BUILD | + VIR_FS_POOL_CREATE_WITH_BUILD_OVERWRITE | + VIR_FS_POOL_CREATE_WITH_BUILD_NO_OVERWRITE, -1); + + VIR_EXCLUSIVE_FLAGS_RET(VIR_FS_POOL_BUILD_OVERWRITE, + VIR_FS_POOL_BUILD_NO_OVERWRITE, -1); + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return -1; + + if (virFsPoolCreateEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) + goto cleanup; + + if (virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is already active"), + fspool->def->name); + goto cleanup; + } + + if (backend->buildFspool) { + if (flags & VIR_FS_POOL_CREATE_WITH_BUILD_OVERWRITE) + build_flags |= VIR_FS_POOL_BUILD_OVERWRITE; + else if (flags & VIR_FS_POOL_CREATE_WITH_BUILD_NO_OVERWRITE) + build_flags |= VIR_FS_POOL_BUILD_NO_OVERWRITE; + + if (build_flags || + (flags & VIR_FS_POOL_CREATE_WITH_BUILD)) { + if (backend->buildFspool(obj->conn, fspool, build_flags) < 0) { + virFsPoolObjRemove(&driver->fspools, fspool); + fspool = NULL; + goto cleanup; + } + } + } + + VIR_INFO("Starting up fspool '%s'", fspool->def->name); + if (backend->startFspool && + backend->startFspool(obj->conn, fspool) < 0) + goto cleanup; + + stateFile = virFileBuildPath(driver->stateDir, + fspool->def->name, ".xml"); + + virFsPoolObjClearItems(fspool); + if (!stateFile || virFsPoolSaveState(stateFile, fspool->def) < 0 || + backend->refreshFspool(obj->conn, fspool) < 0) { + if (stateFile) + unlink(stateFile); + goto cleanup; + } + + fspool->active = true; + ret = 0; + + cleanup: + VIR_FREE(stateFile); + if (fspool) + virFsPoolObjUnlock(fspool); + return ret; +} + +static int +fsPoolBuild(virFsPoolPtr obj, + unsigned int flags) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + int ret = -1; + + virCheckFlags(0, -1); + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return -1; + + if (virFsPoolBuildEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) + goto cleanup; + + if (virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is already active"), + fspool->def->name); + goto cleanup; + } + + if (backend->buildFspool && + backend->buildFspool(obj->conn, fspool, flags) < 0) + goto cleanup; + + ret = 0; + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static int +fsPoolUndefine(virFsPoolPtr obj) +{ + virFsPoolObjPtr fspool; + int ret = -1; + + fsDriverLock(); + if (!(fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid))) { + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virUUIDFormat(obj->uuid, uuidstr); + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching uuid '%s' (%s)"), + uuidstr, obj->name); + goto cleanup; + } + + if (virFsPoolUndefineEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if (virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is still active"), + fspool->def->name); + goto cleanup; + } + + if (fspool->asyncjobs > 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("fspool '%s' has asynchronous jobs running."), + fspool->def->name); + goto cleanup; + } + + if (virFsPoolObjDeleteDef(fspool) < 0) + goto cleanup; + + if (unlink(fspool->autostartLink) < 0 && + errno != ENOENT && + errno != ENOTDIR) { + char ebuf[1024]; + VIR_ERROR(_("Failed to delete autostart link '%s': %s"), + fspool->autostartLink, virStrerror(errno, ebuf, sizeof(ebuf))); + } + + VIR_FREE(fspool->configFile); + VIR_FREE(fspool->autostartLink); + + VIR_INFO("Undefining fspool '%s'", fspool->def->name); + virFsPoolObjRemove(&driver->fspools, fspool); + fspool = NULL; + ret = 0; + + cleanup: + if (fspool) + virFsPoolObjUnlock(fspool); + fsDriverUnlock(); + return ret; +} + +static int +fsPoolDestroy(virFsPoolPtr obj) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + char *stateFile = NULL; + int ret = -1; + + fsDriverLock(); + if (!(fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid))) { + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virUUIDFormat(obj->uuid, uuidstr); + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching uuid '%s' (%s)"), + uuidstr, obj->name); + goto cleanup; + } + + if (virFsPoolDestroyEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) + goto cleanup; + + VIR_INFO("Destroying fspool '%s'", fspool->def->name); + + if (!virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is not active"), fspool->def->name); + goto cleanup; + } + + if (fspool->asyncjobs > 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("fspool '%s' has asynchronous jobs running."), + fspool->def->name); + goto cleanup; + } + + if (!(stateFile = virFileBuildPath(driver->stateDir, + fspool->def->name, + ".xml"))) + goto cleanup; + + unlink(stateFile); + VIR_FREE(stateFile); + + if (backend->stopFspool && + backend->stopFspool(obj->conn, fspool) < 0) + goto cleanup; + + virFsPoolObjClearItems(fspool); + + fspool->active = false; + + if (fspool->configFile == NULL) { + virFsPoolObjRemove(&driver->fspools, fspool); + fspool = NULL; + } else if (fspool->newDef) { + virFsPoolDefFree(fspool->def); + fspool->def = fspool->newDef; + fspool->newDef = NULL; + } + + ret = 0; + + cleanup: + if (fspool) + virFsPoolObjUnlock(fspool); + fsDriverUnlock(); + return ret; +} + +static int +fsPoolDelete(virFsPoolPtr obj, + unsigned int flags) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + char *stateFile = NULL; + int ret = -1; + + virCheckFlags(0, -1); + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return -1; + + if (virFsPoolDeleteEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) + goto cleanup; + + VIR_INFO("Deleting fspool '%s'", fspool->def->name); + + if (virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is still active"), + fspool->def->name); + goto cleanup; + } + + if (fspool->asyncjobs > 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("fspool '%s' has asynchronous jobs running."), + fspool->def->name); + goto cleanup; + } + + if (!(stateFile = virFileBuildPath(driver->stateDir, + fspool->def->name, + ".xml"))) + goto cleanup; + + unlink(stateFile); + VIR_FREE(stateFile); + + if (!backend->deleteFspool) { + virReportError(VIR_ERR_NO_SUPPORT, + "%s", _("fspool does not support fspool deletion")); + goto cleanup; + } + if (backend->deleteFspool(obj->conn, fspool, flags) < 0) + goto cleanup; + + ret = 0; + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static int +fsPoolRefresh(virFsPoolPtr obj, + unsigned int flags) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + int ret = -1; + + virCheckFlags(0, -1); + + fsDriverLock(); + if (!(fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid))) { + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virUUIDFormat(obj->uuid, uuidstr); + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching uuid '%s' (%s)"), + uuidstr, obj->name); + goto cleanup; + } + + if (virFsPoolRefreshEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) + goto cleanup; + + if (!virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is not active"), fspool->def->name); + goto cleanup; + } + + if (fspool->asyncjobs > 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("fspool '%s' has asynchronous jobs running."), + fspool->def->name); + goto cleanup; + } + + virFsPoolObjClearItems(fspool); + if (backend->refreshFspool(obj->conn, fspool) < 0) { + if (backend->stopFspool) + backend->stopFspool(obj->conn, fspool); + + fspool->active = false; + + if (fspool->configFile == NULL) { + virFsPoolObjRemove(&driver->fspools, fspool); + fspool = NULL; + } + goto cleanup; + } + ret = 0; + + cleanup: + if (fspool) + virFsPoolObjUnlock(fspool); + fsDriverUnlock(); + return ret; + + return 0; +} + + +static int +fsPoolGetInfo(virFsPoolPtr obj, + virFsPoolInfoPtr info) +{ + virFsPoolObjPtr fspool; + int ret = -1; + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return -1; + + if (virFsPoolGetInfoEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if (virFsBackendForType(fspool->def->type) == NULL) + goto cleanup; + + memset(info, 0, sizeof(virFsPoolInfo)); + if (fspool->active) + info->state = VIR_FS_POOL_RUNNING; + else + info->state = VIR_FS_POOL_INACTIVE; + info->capacity = fspool->def->capacity; + info->allocation = fspool->def->allocation; + info->available = fspool->def->available; + ret = 0; + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static char * +fsPoolGetXMLDesc(virFsPoolPtr obj, + unsigned int flags) +{ + virFsPoolObjPtr fspool; + virFsPoolDefPtr def; + char *ret = NULL; + + virCheckFlags(VIR_FS_XML_INACTIVE, NULL); + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return NULL; + + if (virFsPoolGetXMLDescEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if ((flags & VIR_FS_XML_INACTIVE) && fspool->newDef) + def = fspool->newDef; + else + def = fspool->def; + + ret = virFsPoolDefFormat(def); + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static int +fsPoolGetAutostart(virFsPoolPtr obj, int *autostart) +{ + virFsPoolObjPtr fspool; + int ret = -1; + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return -1; + + if (virFsPoolGetAutostartEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if (!fspool->configFile) { + *autostart = 0; + } else { + *autostart = fspool->autostart; + } + ret = 0; + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static int +fsPoolSetAutostart(virFsPoolPtr obj, int autostart) +{ + virFsPoolObjPtr fspool; + int ret = -1; + + fsDriverLock(); + fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid); + + if (!fspool) { + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virUUIDFormat(obj->uuid, uuidstr); + virReportError(VIR_ERR_NO_FS_POOL, + _("no fspool with matching uuid '%s' (%s)"), + uuidstr, obj->name); + goto cleanup; + } + + if (virFsPoolSetAutostartEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if (!fspool->configFile) { + virReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("fspool has no config file")); + goto cleanup; + } + + autostart = (autostart != 0); + + if (fspool->autostart != autostart) { + if (autostart) { + if (virFileMakePath(driver->autostartDir) < 0) { + virReportSystemError(errno, + _("cannot create autostart directory %s"), + driver->autostartDir); + goto cleanup; + } + + if (symlink(fspool->configFile, fspool->autostartLink) < 0) { + virReportSystemError(errno, + _("Failed to create symlink '%s' to '%s'"), + fspool->autostartLink, fspool->configFile); + goto cleanup; + } + } else { + if (unlink(fspool->autostartLink) < 0 && + errno != ENOENT && errno != ENOTDIR) { + virReportSystemError(errno, + _("Failed to delete symlink '%s'"), + fspool->autostartLink); + goto cleanup; + } + } + fspool->autostart = autostart; + } + ret = 0; + + cleanup: + if (fspool) + virFsPoolObjUnlock(fspool); + fsDriverUnlock(); + return ret; +} + +static int +fsPoolNumOfItems(virFsPoolPtr obj) +{ + virFsPoolObjPtr fspool; + int ret = -1; + size_t i; + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return -1; + + if (virFsPoolNumOfItemsEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if (!virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is not active"), fspool->def->name); + goto cleanup; + } + ret = 0; + for (i = 0; i < fspool->items.count; i++) { + if (virFsPoolNumOfItemsCheckACL(obj->conn, fspool->def, + fspool->items.objs[i])) + ret++; + } + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static int +fsPoolListItems(virFsPoolPtr obj, + char **const names, + int maxnames) +{ + virFsPoolObjPtr fspool; + size_t i; + int n = 0; + + memset(names, 0, maxnames * sizeof(*names)); + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return -1; + + if (virFsPoolListItemsEnsureACL(obj->conn, fspool->def) < 0) + goto cleanup; + + if (!virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is not active"), fspool->def->name); + goto cleanup; + } + + for (i = 0; i < fspool->items.count && n < maxnames; i++) { + if (!virFsPoolListItemsCheckACL(obj->conn, fspool->def, + fspool->items.objs[i])) + continue; + if (VIR_STRDUP(names[n++], fspool->items.objs[i]->name) < 0) + goto cleanup; + } + + virFsPoolObjUnlock(fspool); + return n; + + cleanup: + virFsPoolObjUnlock(fspool); + for (n = 0; n < maxnames; n++) + VIR_FREE(names[n]); + + memset(names, 0, maxnames * sizeof(*names)); + return -1; +} + +static int +fsPoolListAllItems(virFsPoolPtr fspool, + virFsItemPtr **items, + unsigned int flags) +{ + virFsPoolObjPtr obj; + size_t i; + virFsItemPtr *tmp_items = NULL; + virFsItemPtr item = NULL; + int nitems = 0; + int ret = -1; + + virCheckFlags(0, -1); + + if (!(obj = virFsPoolObjFromFsPool(fspool))) + return -1; + + if (virFsPoolListAllItemsEnsureACL(fspool->conn, obj->def) < 0) + goto cleanup; + + if (!virFsPoolObjIsActive(obj)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is not active"), obj->def->name); + goto cleanup; + } + + /* Just returns the items count */ + if (!items) { + ret = obj->items.count; + goto cleanup; + } + + if (VIR_ALLOC_N(tmp_items, obj->items.count + 1) < 0) + goto cleanup; + + for (i = 0; i < obj->items.count; i++) { + if (!virFsPoolListAllItemsCheckACL(fspool->conn, obj->def, + obj->items.objs[i])) + continue; + if (!(item = virGetFsItem(fspool->conn, obj->def->name, + obj->items.objs[i]->name, + obj->items.objs[i]->key, + NULL, NULL))) + goto cleanup; + tmp_items[nitems++] = item; + } + + *items = tmp_items; + tmp_items = NULL; + ret = nitems; + + cleanup: + if (tmp_items) { + for (i = 0; i < nitems; i++) + virObjectUnref(tmp_items[i]); + VIR_FREE(tmp_items); + } + + virFsPoolObjUnlock(obj); + + return ret; +} + +static virFsItemPtr +fsItemLookupByName(virFsPoolPtr obj, const char *name) +{ + virFsPoolObjPtr fspool; + virFsItemDefPtr item; + virFsItemPtr ret = NULL; + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return NULL; + + if (!virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is not active"), fspool->def->name); + goto cleanup; + } + + item = virFsItemDefFindByName(fspool, name); + + if (!item) { + virReportError(VIR_ERR_NO_FS_ITEM, + _("no fspool item with matching name '%s'"), + name); + goto cleanup; + } + + if (virFsItemLookupByNameEnsureACL(obj->conn, fspool->def, item) < 0) + goto cleanup; + + ret = virGetFsItem(obj->conn, fspool->def->name, item->name, item->key, + NULL, NULL); + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + + +static virFsItemPtr +fsItemLookupByKey(virConnectPtr conn, const char *key) +{ + size_t i; + virFsItemPtr ret = NULL; + + fsDriverLock(); + for (i = 0; i < driver->fspools.count && !ret; i++) { + virFsPoolObjLock(driver->fspools.objs[i]); + if (virFsPoolObjIsActive(driver->fspools.objs[i])) { + virFsItemDefPtr item = + virFsItemDefFindByKey(driver->fspools.objs[i], key); + + if (item) { + virFsPoolDefPtr def = driver->fspools.objs[i]->def; + if (virFsItemLookupByKeyEnsureACL(conn, def, item) < 0) { + virFsPoolObjUnlock(driver->fspools.objs[i]); + goto cleanup; + } + + ret = virGetFsItem(conn, + def->name, + item->name, + item->key, + NULL, NULL); + } + } + virFsPoolObjUnlock(driver->fspools.objs[i]); + } + + if (!ret) + virReportError(VIR_ERR_NO_FS_ITEM, + _("no fspool item with matching key %s"), key); + + cleanup: + fsDriverUnlock(); + return ret; +} + +static virFsItemPtr +fsItemLookupByPath(virConnectPtr conn, + const char *path) +{ + size_t i; + virFsItemPtr ret = NULL; + char *cleanpath; + + cleanpath = virFileSanitizePath(path); + if (!cleanpath) + return NULL; + + fsDriverLock(); + for (i = 0; i < driver->fspools.count && !ret; i++) { + virFsPoolObjPtr fspool = driver->fspools.objs[i]; + virFsItemDefPtr item; + + virFsPoolObjLock(fspool); + + if (!virFsPoolObjIsActive(fspool)) { + virFsPoolObjUnlock(fspool); + continue; + } + + item = virFsItemDefFindByPath(fspool, cleanpath); + + if (item) { + if (virFsItemLookupByPathEnsureACL(conn, fspool->def, item) < 0) { + virFsPoolObjUnlock(fspool); + goto cleanup; + } + + ret = virGetFsItem(conn, fspool->def->name, + item->name, item->key, + NULL, NULL); + } + + virFsPoolObjUnlock(fspool); + } + + if (!ret) { + if (STREQ(path, cleanpath)) { + virReportError(VIR_ERR_NO_FS_ITEM, + _("no fspool item with matching path '%s'"), path); + } else { + virReportError(VIR_ERR_NO_FS_ITEM, + _("no fspool item with matching path '%s' (%s)"), + path, cleanpath); + } + } + + cleanup: + VIR_FREE(cleanpath); + fsDriverUnlock(); + return ret; +} + +static virFsItemPtr +fsItemCreateXML(virFsPoolPtr obj, + const char *xmldesc, + unsigned int flags) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + virFsItemDefPtr itemdef = NULL; + virFsItemPtr ret = NULL, itemobj = NULL; + + virCheckFlags(0, NULL); + + if (!(fspool = virFsPoolObjFromFsPool(obj))) + return NULL; + + if (!virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fspool '%s' is not active"), fspool->def->name); + goto cleanup; + } + + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) + goto cleanup; + + itemdef = virFsItemDefParseString(fspool->def, xmldesc, + VIR_ITEM_XML_PARSE_OPT_CAPACITY); + if (itemdef == NULL) + goto cleanup; + + if (!itemdef->target.capacity && !backend->buildItem) { + virReportError(VIR_ERR_NO_SUPPORT, + "%s", _("item capacity required for this " + "fspool")); + goto cleanup; + } + + if (virFsItemCreateXMLEnsureACL(obj->conn, fspool->def, itemdef) < 0) + goto cleanup; + + if (virFsItemDefFindByName(fspool, itemdef->name)) { + virReportError(VIR_ERR_FS_ITEM_EXIST, + _("'%s'"), itemdef->name); + goto cleanup; + } + + if (!backend->createItem) { + virReportError(VIR_ERR_NO_SUPPORT, + "%s", _("fspool does not support item " + "creation")); + goto cleanup; + } + + if (VIR_REALLOC_N(fspool->items.objs, + fspool->items.count+1) < 0) + goto cleanup; + + /* Wipe any key the user may have suggested, as item creation + * will generate the canonical key. */ + VIR_FREE(itemdef->key); + if (backend->createItem(obj->conn, fspool, itemdef) < 0) + goto cleanup; + + fspool->items.objs[fspool->items.count++] = itemdef; + itemobj = virGetFsItem(obj->conn, fspool->def->name, itemdef->name, + itemdef->key, NULL, NULL); + if (!itemobj) { + fspool->items.count--; + goto cleanup; + } + + + if (backend->buildItem) { + int buildret; + virFsItemDefPtr builditemdef = NULL; + + if (VIR_ALLOC(builditemdef) < 0) { + itemdef = NULL; + goto cleanup; + } + + /* Make a shallow copy of the 'defined' item definition, since the + * original allocation value will change as the user polls 'info', + * but we only need the initial requested values + */ + memcpy(builditemdef, itemdef, sizeof(*itemdef)); + + /* Drop the fspool lock during item allocation */ + fspool->asyncjobs++; + itemdef->building = true; + virFsPoolObjUnlock(fspool); + + buildret = backend->buildItem(obj->conn, fspool, builditemdef, flags); + + VIR_FREE(builditemdef); + + fsDriverLock(); + virFsPoolObjLock(fspool); + fsDriverUnlock(); + + itemdef->building = false; + fspool->asyncjobs--; + + if (buildret < 0) { + /* buildItem handles deleting item on failure */ + fsItemRemoveFromFsPool(fspool, itemdef); + itemdef = NULL; + goto cleanup; + } + + } + + if (backend->refreshItem && + backend->refreshItem(obj->conn, fspool, itemdef) < 0) { + fsItemDeleteInternal(itemobj, backend, fspool, itemdef, 0); + itemdef = NULL; + goto cleanup; + } + + /* Update fspool metadata ignoring the disk backend since + * it updates the fspool values. + */ + + VIR_INFO("Creating item '%s' in fs fspool '%s'", + itemobj->name, fspool->def->name); + ret = itemobj; + itemobj = NULL; + itemdef = NULL; + + cleanup: + virObjectUnref(itemobj); + virFsItemDefFree(itemdef); + if (fspool) + virFsPoolObjUnlock(fspool); + return ret; +} + +static virFsItemPtr +fsItemCreateXMLFrom(virFsPoolPtr obj, + const char *xmldesc, + virFsItemPtr vobj, + unsigned int flags) +{ + virFsPoolObjPtr fspool, origpool = NULL; + virFsBackendPtr backend; + virFsItemDefPtr origitem = NULL, newitem = NULL, shadowitem = NULL; + virFsItemPtr ret = NULL, itemobj = NULL; + int buildret; + + virCheckFlags(0, NULL); + + fsDriverLock(); + fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid); + if (fspool && STRNEQ(obj->name, vobj->fspool)) { + virFsPoolObjUnlock(fspool); + origpool = virFsPoolObjFindByName(&driver->fspools, vobj->fspool); + virFsPoolObjLock(fspool); + } + fsDriverUnlock(); + if (!fspool) { + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virUUIDFormat(obj->uuid, uuidstr); + virReportError(VIR_ERR_NO_FS_POOL, + _("no fs fspool with matching uuid '%s' (%s)"), + uuidstr, obj->name); + goto cleanup; + } + + if (STRNEQ(obj->name, vobj->fspool) && !origpool) { + virReportError(VIR_ERR_NO_FS_POOL, + _("no fs fspool with matching name '%s'"), + vobj->fspool); + goto cleanup; + } + + if (!virFsPoolObjIsActive(fspool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fs fspool '%s' is not active"), fspool->def->name); + goto cleanup; + } + + if (origpool && !virFsPoolObjIsActive(origpool)) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("fs fspool '%s' is not active"), + origpool->def->name); + goto cleanup; + } + + if ((backend = virFsBackendForType(fspool->def->type)) == NULL) + goto cleanup; + + origitem = virFsItemDefFindByName(origpool ? + origpool : fspool, vobj->name); + if (!origitem) { + virReportError(VIR_ERR_NO_FS_ITEM, + _("no fs item with matching name '%s'"), + vobj->name); + goto cleanup; + } + + newitem = virFsItemDefParseString(fspool->def, xmldesc, + VIR_VOL_XML_PARSE_NO_CAPACITY); + if (newitem == NULL) + goto cleanup; + + if (virFsItemCreateXMLFromEnsureACL(obj->conn, fspool->def, newitem) < 0) + goto cleanup; + + if (virFsItemDefFindByName(fspool, newitem->name)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("fs item name '%s' already in use."), + newitem->name); + goto cleanup; + } + + /* Use the original item's capacity in case the new capacity + * is less than that, or it was omitted */ + if (newitem->target.capacity < origitem->target.capacity) + newitem->target.capacity = origitem->target.capacity; + + if (!backend->buildItemFrom) { + virReportError(VIR_ERR_NO_SUPPORT, + "%s", _("fs fspool does not support" + " item creation from an existing item")); + goto cleanup; + } + + if (origitem->building) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("item '%s' is still being allocated."), + origitem->name); + goto cleanup; + } + + if (backend->refreshItem && + backend->refreshItem(obj->conn, fspool, origitem) < 0) + goto cleanup; + + if (VIR_REALLOC_N(fspool->items.objs, + fspool->items.count+1) < 0) + goto cleanup; + + /* 'Define' the new item so we get async progress reporting. + * Wipe any key the user may have suggested, as item creation + * will generate the canonical key. */ + VIR_FREE(newitem->key); + if (backend->createItem(obj->conn, fspool, newitem) < 0) + goto cleanup; + + /* Make a shallow copy of the 'defined' item definition, since the + * original allocation value will change as the user polls 'info', + * but we only need the initial requested values + */ + if (VIR_ALLOC(shadowitem) < 0) + goto cleanup; + + memcpy(shadowitem, newitem, sizeof(*newitem)); + + fspool->items.objs[fspool->items.count++] = newitem; + itemobj = virGetFsItem(obj->conn, fspool->def->name, newitem->name, + newitem->key, NULL, NULL); + if (!itemobj) { + fspool->items.count--; + goto cleanup; + } + + /* Drop the fspool lock during item allocation */ + fspool->asyncjobs++; + newitem->building = true; + origitem->in_use++; + virFsPoolObjUnlock(fspool); + + if (origpool) { + origpool->asyncjobs++; + virFsPoolObjUnlock(origpool); + } + + buildret = backend->buildItemFrom(obj->conn, fspool, shadowitem, origitem, flags); + + fsDriverLock(); + virFsPoolObjLock(fspool); + if (origpool) + virFsPoolObjLock(origpool); + fsDriverUnlock(); + + origitem->in_use--; + newitem->building = false; + fspool->asyncjobs--; + + if (origpool) { + origpool->asyncjobs--; + virFsPoolObjUnlock(origpool); + origpool = NULL; + } + + if (buildret < 0 || + (backend->refreshItem && + backend->refreshItem(obj->conn, fspool, newitem) < 0)) { + fsItemDeleteInternal(itemobj, backend, fspool, newitem, 0); + newitem = NULL; + goto cleanup; + } + + fspool->def->allocation += newitem->target.allocation; + fspool->def->available -= newitem->target.allocation; + + VIR_INFO("Creating item '%s' in fs fspool '%s'", + itemobj->name, fspool->def->name); + ret = itemobj; + itemobj = NULL; + newitem = NULL; + + cleanup: + virObjectUnref(itemobj); + virFsItemDefFree(newitem); + VIR_FREE(shadowitem); + if (fspool) + virFsPoolObjUnlock(fspool); + if (origpool) + virFsPoolObjUnlock(origpool); + return ret; +} + + +static int +fsItemGetInfo(virFsItemPtr obj, + virFsItemInfoPtr info) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + virFsItemDefPtr item; + int ret = -1; + + if (!(item = virFsItemDefFromItem(obj, &fspool, &backend))) + return -1; + + if (virFsItemGetInfoEnsureACL(obj->conn, fspool->def, item) < 0) + goto cleanup; + + if (backend->refreshItem && + backend->refreshItem(obj->conn, fspool, item) < 0) + goto cleanup; + + memset(info, 0, sizeof(*info)); + info->type = item->type; + info->capacity = item->target.capacity; + info->allocation = item->target.allocation; + ret = 0; + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static char * +fsItemGetXMLDesc(virFsItemPtr obj, unsigned int flags) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + virFsItemDefPtr item; + char *ret = NULL; + + virCheckFlags(0, NULL); + + if (!(item = virFsItemDefFromItem(obj, &fspool, &backend))) + return NULL; + + if (virFsItemGetXMLDescEnsureACL(obj->conn, fspool->def, item) < 0) + goto cleanup; + + if (backend->refreshItem && + backend->refreshItem(obj->conn, fspool, item) < 0) + goto cleanup; + + ret = virFsItemDefFormat(fspool->def, item); + + cleanup: + virFsPoolObjUnlock(fspool); + + return ret; +} + +static char * +fsItemGetPath(virFsItemPtr obj) +{ + virFsPoolObjPtr fspool; + virFsItemDefPtr item; + char *ret = NULL; + + if (!(item = virFsItemDefFromItem(obj, &fspool, NULL))) + return NULL; + + if (virFsItemGetPathEnsureACL(obj->conn, fspool->def, item) < 0) + goto cleanup; + + ignore_value(VIR_STRDUP(ret, item->target.path)); + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + + +static int fsPoolIsActive(virFsPoolPtr fspool) +{ + virFsPoolObjPtr obj; + int ret = -1; + + if (!(obj = virFsPoolObjFromFsPool(fspool))) + return -1; + + if (virFsPoolIsActiveEnsureACL(fspool->conn, obj->def) < 0) + goto cleanup; + + ret = virFsPoolObjIsActive(obj); + + cleanup: + virFsPoolObjUnlock(obj); + return ret; +} + +static int fsPoolIsPersistent(virFsPoolPtr fspool) +{ + virFsPoolObjPtr obj; + int ret = -1; + + if (!(obj = virFsPoolObjFromFsPool(fspool))) + return -1; + + if (virFsPoolIsPersistentEnsureACL(fspool->conn, obj->def) < 0) + goto cleanup; + + ret = obj->configFile ? 1 : 0; + + cleanup: + virFsPoolObjUnlock(obj); + return ret; +} + + +static int +fsItemDelete(virFsItemPtr obj, + unsigned int flags) +{ + virFsPoolObjPtr fspool; + virFsBackendPtr backend; + virFsItemDefPtr item = NULL; + int ret = -1; + + virCheckFlags(0, -1); + + if (!(item = virFsItemDefFromItem(obj, &fspool, &backend))) + return -1; + + if (virFsItemDeleteEnsureACL(obj->conn, fspool->def, item) < 0) + goto cleanup; + + if (item->in_use) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("item '%s' is still in use."), + item->name); + goto cleanup; + } + + if (item->building) { + virReportError(VIR_ERR_OPERATION_INVALID, + _("item '%s' is still being allocated."), + item->name); + goto cleanup; + } + + if (fsItemDeleteInternal(obj, backend, fspool, item, flags) < 0) + goto cleanup; + + ret = 0; + + cleanup: + virFsPoolObjUnlock(fspool); + return ret; +} + +static virFsDriver fsDriver = { + .name = "fs", + .connectNumOfFsPools = fsConnectNumOfFsPools, /* 2.1.0 */ + .connectListFsPools = fsConnectListFsPools, /* 2.1.0 */ + .connectNumOfDefinedFsPools = fsConnectNumOfDefinedFsPools, /* 2.1.0 */ + .connectListDefinedFsPools = fsConnectListDefinedFsPools, /* 2.1.0 */ + .connectListAllFsPools = fsConnectListAllFsPools, /* 2.1.0 */ + .fsPoolLookupByName = fsPoolLookupByName, /* 2.1.0 */ + .fsPoolLookupByUUID = fsPoolLookupByUUID, /* 2.1.0 */ + .fsPoolLookupByItem = fsPoolLookupByItem, /* 2.1.0 */ + .fsPoolCreateXML = fsPoolCreateXML, /* 2.1.0 */ + .fsPoolDefineXML = fsPoolDefineXML, /* 2.1.0 */ + .fsPoolBuild = fsPoolBuild, /* 2.1.0 */ + .fsPoolCreate = fsPoolCreate, /* 2.1.0 */ + .fsPoolUndefine = fsPoolUndefine, /* 2.1.0 */ + .fsPoolDestroy = fsPoolDestroy, /* 2.1.0 */ + .fsPoolDelete = fsPoolDelete, /* 2.1.0 */ + .fsPoolRefresh = fsPoolRefresh, /* 2.1.0 */ + .fsPoolGetInfo = fsPoolGetInfo, /* 2.1.0 */ + .fsPoolGetXMLDesc = fsPoolGetXMLDesc, /* 2.1.0 */ + .fsPoolGetAutostart = fsPoolGetAutostart, /* 2.1.0 */ + .fsPoolSetAutostart = fsPoolSetAutostart, /* 2.1.0 */ + .fsPoolNumOfItems = fsPoolNumOfItems, /* 2.1.0 */ + .fsPoolListItems = fsPoolListItems, /* 2.1.0 */ + .fsPoolListAllItems = fsPoolListAllItems, /* 2.1.0 */ + .fsItemLookupByName = fsItemLookupByName, /* 2.1.0 */ + .fsItemLookupByKey = fsItemLookupByKey, /* 2.1.0 */ + .fsItemLookupByPath = fsItemLookupByPath, /* 2.1.0 */ + .fsItemCreateXML = fsItemCreateXML, /* 2.1.0 */ + .fsItemCreateXMLFrom = fsItemCreateXMLFrom, /* 2.1.0 */ + .fsItemDelete = fsItemDelete, /* 2.1.0 */ + .fsItemGetInfo = fsItemGetInfo, /* 2.1.0 */ + .fsItemGetXMLDesc = fsItemGetXMLDesc, /* 2.1.0 */ + .fsItemGetPath = fsItemGetPath, /* 2.1.0 */ + .fsPoolIsActive = fsPoolIsActive, /* 2.1.0 */ + .fsPoolIsPersistent = fsPoolIsPersistent, /* 2.1.0 */ +}; + + +static virStateDriver stateDriver = { + .name = "fs", + .stateInitialize = fsStateInitialize, + .stateAutoStart = fsStateAutoStart, + .stateCleanup = fsStateCleanup, + .stateReload = fsStateReload, +}; + +int fsRegister(void) +{ + VIR_DEBUG("fsDriver = %p", &fsDriver); + + if (virSetSharedFsDriver(&fsDriver) < 0) + return -1; + + if (virRegisterStateDriver(&stateDriver) < 0) + return -1; + + VIR_DEBUG("fsDriver = %p", &fsDriver); + + return 0; +} diff --git a/src/fs/fs_driver.h b/src/fs/fs_driver.h new file mode 100644 index 0000000..aaf0258 --- /dev/null +++ b/src/fs/fs_driver.h @@ -0,0 +1,10 @@ +#ifndef __VIR_FS_DRIVER_H__ +# define __VIR_FS_DRIVER_H__ + +# include <sys/stat.h> + +# include "domain_conf.h" +# include "fs_conf.h" + +int fsRegister(void); +#endif /* __VIR_FS_DRIVER_H__ */ diff --git a/src/libvirt.c b/src/libvirt.c index 52462e3..cccebdd 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -116,6 +116,7 @@ static int virStateDriverTabCount; static virNetworkDriverPtr virSharedNetworkDriver; static virInterfaceDriverPtr virSharedInterfaceDriver; static virStorageDriverPtr virSharedStorageDriver; +static virFsDriverPtr virSharedFsDriver; static virNodeDeviceDriverPtr virSharedNodeDeviceDriver; static virSecretDriverPtr virSharedSecretDriver; static virNWFilterDriverPtr virSharedNWFilterDriver; @@ -587,7 +588,30 @@ virSetSharedStorageDriver(virStorageDriverPtr driver) return 0; } +/** + * virSetSharedFsDriver: + * @driver: pointer to a fs driver block + * + * Register a fs virtualization driver + * + * Returns the driver priority or -1 in case of error. + */ +int +virSetSharedFsDriver(virFsDriverPtr driver) +{ + virCheckNonNullArgReturn(driver, -1); + if (virSharedFsDriver) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("A fs driver is already registered")); + return -1; + } + + VIR_DEBUG("registering %s as fs driver", driver->name); + + virSharedFsDriver = driver; + return 0; +} /** * virSetSharedNodeDeviceDriver: * @driver: pointer to a device monitor block @@ -707,6 +731,8 @@ virRegisterConnectDriver(virConnectDriverPtr driver, driver->secretDriver = virSharedSecretDriver; if (driver->storageDriver == NULL) driver->storageDriver = virSharedStorageDriver; + if (driver->fsDriver == NULL) + driver->fsDriver = virSharedFsDriver; } virConnectDriverTab[virConnectDriverTabCount] = driver; @@ -1089,6 +1115,7 @@ virConnectOpenInternal(const char *name, ret->nwfilterDriver = virConnectDriverTab[i]->nwfilterDriver; ret->secretDriver = virConnectDriverTab[i]->secretDriver; ret->storageDriver = virConnectDriverTab[i]->storageDriver; + ret->fsDriver = virConnectDriverTab[i]->fsDriver; res = virConnectDriverTab[i]->hypervisorDriver->connectOpen(ret, auth, conf, flags); VIR_DEBUG("driver %zu %s returned %s", @@ -1107,6 +1134,7 @@ virConnectOpenInternal(const char *name, ret->nwfilterDriver = NULL; ret->secretDriver = NULL; ret->storageDriver = NULL; + ret->fsDriver = NULL; if (res == VIR_DRV_OPEN_ERROR) goto failed; diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 68150d6..f504143 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -1085,6 +1085,7 @@ virDomainMigratePrepareTunnel3; virDomainMigratePrepareTunnel3Params; virRegisterConnectDriver; virRegisterStateDriver; +virSetSharedFsDriver; virSetSharedInterfaceDriver; virSetSharedNetworkDriver; virSetSharedNodeDeviceDriver; -- 1.8.3.1