On 12/02/2016 10:38 AM, Olga Krishtal wrote: More simply stated - for what's going to be I think a bit more complex than originally thought... The changes would be extracting out common pool mgmt code into their own API's so that they can be used by future patches (eg. the File System Storage Driver). Patch fails "make syntax-check" preprocessor_indentation cppi: src/util/virpoolcommon.h: line 166: not properly indented maint.mk: incorrect preprocessor indentation cfg.mk:684: recipe for target 'sc_preprocessor_indentation' failed make: *** [sc_preprocessor_indentation] Error 1 Which is the last "# endif" in the file. ... First and most important, thanks for taking this on - it's going to be bumpy, but I think if we take it piece by piece that will be better in the long run. Also on the horizon is a need for a common pool structure for vGPU's - I think Laine will find having a common pool structure quite helpful for that work. While I understand why you're providing all the patches, I'm going to only focus on the first three for now. I'd prefer to agree on the infrastructure first, then add the fspool code. Hopefully that makes the mean time between patch series shorter, too. I see the first few patches as a means to create a common pool infrastructure. I think this is the right path, although I think you swung too far in that direction with what you've done. The new nomenclature doesn't need the "common" in the name/structures either. It's just "virpool.h" and "virpool.c" and it manages structures commonly used for pools. Currently it's just the block storage driver that needs it, but you're adding fspool which will be a file system storage driver. Just the first couple of patches have spawned off a few more ideas and a few "pre" patches... I really think it would be better to create the new structures and API's in one patch. Just keep track of wh This patch definitely can be further split... I think if you copy/paste code from one place to another and rename functions, fix comments, etc. and essentially set up the common pool code, then subsequent patches would just remove code. You can always note in the commit message where code was sourced from... Also remember, you're trying to hit a moving target. The storage pool/volume code is constantly changing - if you try to do everything at once there's bound to be conflicts. I already of some with what's here and in the subsequent patches. I also have other commitments so larger series will languish ;-) - reviews can take considerable time. You need to be very careful with changes here. The problem being existing code that may rely on _virStoragePool or _virStorageVol. We can always add, but it's the change that causes issues. That's why stuff got moved into datatypes.h because that's not the external API. In any case, there is an example - search on virBlkioParameter I think it would be just _virPool, but, what you have won't work. I believe you'd need something like: /* As of 3.x.x the _virPool was introduced to generalize a block * storage pool. This allows for backwards compatibility. */ # define _virStoragePool _virPool typedef struct _virPool virStoragePool That way anything that has _virStoragePool will/should do the right thing... Unnecessary whitespace adjustment. Similar issue here - that virItemCommon should be changed to something like "virPoolElement" ?? Loss of whitespace? I think this should be util/virpool.h The $(NULL) should line up properly caveat emptor: I'm not a Makefile expert - not even close, but I would also think there would need to be rules to ensure proper rebuilds when/if virpool.h changes as well. Whatever depends upon it, such as STORAGE_CONF_SOURCES. NB: Changes in here would be done after we settle on the common pool structures... Loss of whitespace Add of whitespace - it's just a consistency thing - it has nothing to do with the changes and IMO should not be done. This would be common I don't see this as common... It's SCSI pool specific Not sure totally removing works - some of this data is storage specific, while other parts would be more common. See my thoughts at the bottom. BTW: I think you should make a storage_conf.h specific geometry structure as a separate patch prior to *any* other changes and send that patch. eg. typedef struct _virStoragePoolGeometry virStoragePoolGeometry; typedef struct virStoragePoolGeometry *virStoragePoolGeometryPtr; struct _virStoragePoolGeometry { int cylinders; int heads; int sectors; }; ... Then instead of _geometry inline: virStoragePoolGeometry geometry; This is SCSI storage pool specific This is SCSI storage pool specific. scsi_host and fchost are _scsi backend specific constructs. So some of this is storage specific and some could be considered common I suppose. Common - a generic pool could have host elements Common - a generic pool could have some sort of device elements Common Specific Common Specific Common, but the name needs to change to something like "virPoolAuthDefPtr" (that could be a separate pre patch). Common Common This is actually specific to 4 pool types fs, netfs, disk, and logical For the fs/netfs it's the file system format type while for disk and logical it's the partition format type... I have more ideas at the end. And of course while reviewing this I saw something wrong in the formatstorage.html page... A storage pool doesn't have timestamps nor does it have encryption (<sigh> ... sent a patch to resolve). > - > -typedef struct _virStoragePoolTarget virStoragePoolTarget; > +typedef virPoolTarget virStoragePoolTarget; > typedef virStoragePoolTarget *virStoragePoolTargetPtr; > -struct _virStoragePoolTarget { > - char *path; /* Optional local filesystem mapping */ > - virStoragePerms perms; /* Default permissions for volumes */ Looks like it could be common, although virStoragePerms could change to something like virPoolPathPerms. Also instead of moving it to virstoragefile.c - add it to the virpool common code with the adjusted name. I could see a "need" for a pool element to have some sort of permissions/label'ing required. Anything with a path... I think some of this is common while other parts are specific Definitely common Is specific and common... Storage specific - could make some sort of structure to hold all 3 in order to share the data... 'source' uses the adjusted struct above, while target should be able to be just common > > typedef struct _virStoragePoolObj virStoragePoolObj; > typedef virStoragePoolObj *virStoragePoolObjPtr; > - > struct _virStoragePoolObj { > virMutex lock; > > @@ -272,9 +169,8 @@ struct _virStoragePoolObj { > int autostart; > unsigned int asyncjobs; > > - virStoragePoolDefPtr def; > - virStoragePoolDefPtr newDef; > - > + virPoolDefPtr def; > + virPoolDefPtr newDef; After a few hours of reviewing and writing some comments, I came back to this change.... I think this is the magic place where things will get interesting... If you "consider" _virStoragePoolObj to be common, you get "_virPoolObj" which would need to be defined in virpool.h. It would look a bit like: struct _virPoolObj { virObjectLockable parent; virMutex lock; virPoolDefPtr def; virPoolDefPtr newDef; void *privateData; void (*privateDataFreeFunc)(void *); }; where the "privateData" in this case would be the "rest" of this virStoragePoolObj: struct _virStoragePoolPrivateObj { char *configFile; char *autostartLink; bool active; int autostart; unsigned int asyncjobs; virStorageVolDefList volumes; }; at least for the block storage pool. It could be different for the FS storage... and even more different for anything else. The key being - the virpool.c is managing the memory and calls to free come in the form of callbacks. It gets really confusing; however, the good news is I've recently done object creation in this manner in "virsecretobj", so I think that might be a good example for you to use. Although the secretobjs don't have the need (yet) for private data like you would for pools. You can look at the virDomainObj to see how it manages the privateData. If this is just overload, let me know - I can help here. You'd just be gated on me creating the infrastructure. I think you can look at the rest of this, but with my new information - I'd have to rethink how much applies <sigh>. s/storage// IOW: This is an internal structure to describe a pool. s/Common// IOW: Just "_virPool {" s/storage volume/pool element/ Similar comments/issues, although I really don't like the "_virItem" as a name. How about "_virPoolElement"? Be careful to check comments of the structures - remove {S|s}torage and {V|v}vol[ume] Even better how about just a purely "common" pool format. Would initially be for storage pools, but eventually for the fspool. I also see a use for something else on the horizon - a graphics (vgpu) pool. I also think this should just be virpool.h - the common would be a given. Changing name to just virpool.h adjust the above macros too. But you wouldn't be including virstoragefile - that would be done elsewhere by code including this virpool.h that would also need virstoragefile.h Why was this needed? I think virpci.h won't be necessary either... NB: The above hunk is block storage specific for the disk backend and thus wouldn't have/need a common structure. So part of this *isn't* common, it's specific - you could create a common structure and then a block storage specific that includes the common parts The above two are Storage specific These would be common Very specific to a disk pool for *a* specific case as a result of multipath devices being able to use "user friendly names" or not. Specific to the disk pool. This would be SCSI storage pool specific and not for common file. The above is SCSI storage specific. Same here, SCSI storage See my comment earlier regarding which is common and specific - this becomes the common stuff, but it's easier for me to just point out below all the structs, so see the end... This seems generic, although the comments need some tweaking to be more generic. A 'path' to the pool target... The virStoragePerms could become virPoolPathPerms with the virStoragePerms struct being your guide. s/Storage// I'm conflicted over how to use type... and of course there would need to be a virPoolType list which would initially just be "BLOCK_STORAGE", but would eventually have "FILESYSTEM_STORAGE" (and down the road VGPU_DEVICES). These would be "storage" related, but less so common type data. They're all "sizing" elements and could also be their own storage specific structure. What follows is my thoughts for various structures. I would think you have it fresh in your mind where the exact overlap is. These would be "virpool.h" type structures (left out some details): typedef enum { VIR_POOL_BLOCK_STORAGE, VIR_POOL_LAST, } virPoolType; struct _virPoolDef { int type; /* virPoolType */ char *name; unsigned char uuid[VIR_UUID_BUFLEN]; virPoolSource source; virPoolTarget target; }; BTW: I'm conflicted over the virPoolType since I'm not sure how it would be used other than to save it. We cannot use the virStoragePoolType enum's because those would be specific to the block storage pool... I'd suspect that FS struct _virPoolSource { /* One or more host definitions */ size_t nhost; virPoolSourceHostPtr hosts; /* Authentication information */ virStorageAuthDefPtr auth; /* One or more devices */ size_t nsrcpath; virPoolSourcePathPtr srcpaths; /* Name of the source */ char *name; /* Vendor of the source */ char *vendor; /* Product name of the source */ char *product; }; typedef enum { VIR_POOL_SOURCE_DIR, VIR_POOL_SOURCE_DEVICE, VIR_POOL_SOURCE_NAME, VIR_POOL_LAST, } virPoolSourcePathType; struct _virPoolSourcePath { virPoolSourcePathType sourcetype; char *path; }; NB: Turns out 'logical' can have both 'device' and 'name', but "name" ends up being something we can add to a logical specific structure. Also 'gluster' can have both 'dir' and 'name', but it seems name is primary when both are used (see tests/*xmlin/*pool*gluster*.xml). Still the key is they are all paths of some sort: <dir path='$PATH'> <device path='$PATH'> where <device> it could be a path to a BLOCK device (/dev/) or it could be an iSCSI initiator string (and thus SOURCE_NAME being used...). Search on "<dir" or "<device" in tests/*xmlin/*pool*.xml struct _virPoolSourceHost { char *name; int port; }; struct _virPoolAuthDef { char *username; char *secrettype; /* <secret type='%s' for disk source */ int authType; /* virStorageAuthType */ virSecretLookupTypeDef seclookupdef; }; struct _virPoolTarget { char *path; /* Optional path to target */ virPoolPathPerms perms; /* Default permissions for path */ }; struct _virPoolPathPerms { mode_t mode; uid_t uid; gid_t gid; char *label; } Below here would be storage_conf.h type adjustments: struct _virStoragePoolDef { virPoolDef pool; virStoragePoolType storagetype; virStoragePoolSizes size; /* Based on storagetype, a subdata could be allocated to have/save * storagetype specific data */ void *subdata; /* vir*StoragePoolDefPtr */ /* In order to make life easy - format will be defined here * although it's only used by the some pools (fs, netfs, * disk, and logical via virStoragePoolFormat* enums */ int format; /* virStoragePoolFormat* */ }; struct _virStoragePoolSizes { unsigned long long allocation; /* bytes */ unsigned long long capacity; /* bytes */ unsigned long long available; /* bytes */ }; struct _virSCSIStoragePoolDef { virStoragePoolSourceAdapter adapter; virStoragePoolSourceInitiatorAttr initiator; }; struct _virDiskStoragePoolDef { int nfreeExtent; virDiskStoragePoolDeviceExtentPtr freeExtents; virStoragePoolGeometry geometry; int part_separator; /* enum virTristateSwitch */ }; struct _virDiskStoragePoolDeviceExtent { unsigned long long start; unsigned long long end; int type; /* virStorageFreeType */ }; NB: Gluster wouldn't need a pool specific data - it would just use the "name" and "dir" separately. Also, I think there's other patches that will want to have multiple gluster paths, so this (more or less) allows for that. I probably left out some structures, but I hope this makes sense... Yes, it's going to be painful to make the switchover. That's why I suggest taking it slowly and not trying to pile on all the FSPool changes along. John

On 12/15/2016 12:16 PM, Olga Krishtal wrote: Yeah - I got too wordy, but this type of change caused me to think about other possible consumers too. Like I thought I mentioned - this set of changes seem to have gone too far in the direction of common code. Of course the original set of changes was too much cut-n-paste for my taste. There has to be a happy medium - that's what we need to find. I usually do that by figuring out what I'll need, creating generic structs/code and slowly moving things. Even if the generic structs start in the specific code - they can be moved. I would think at this point you know what you eventually need in the fspool driver - so that's where to start. Sure to a degree. Some of this ends up being trial and error... or prototyping some changes to see what will and won't work. Trying to do this conceptually in email is difficult too, especially with other things going on. Again, create smaller patches that have the end goal. After sending I kept thinking about things "in the background". I took a pass at trying to extract/abstract just the pool concept and suffice to say it's a bit overwhelming. It's possible - it just has to be done carefully. Essentially though if you take the concept of a PoolObj to a different level of abstraction - it's a very common thing - there are domain, network, secret, storage, etc. that all use the objects code to build up a list or hash table of objects that point at 'def' data. In any case at this time I don't think that level of abstraction would be necessary for what you're trying to accomplish. And if I do come up with something - I would hope it'll be easy to merge in what you have. Not a fan of Unit... This could just be _virPoolDef while the consumer of this would be _virStorageBlockPoolDef and _virStorageFSPoolDef. Why *name in both PoolUnitDef and PoolDef? I think uuid should be here. There should be a 'voltype' field here... Changing the name will dig out code that's using it. As I found with the 'virStorageSource' "type" field there were a couple of source.target.type field users where source.target.type is not filled in. I have some patches to address that in a branch, but I'm waiting on other reviews to be completed before posting. Not sure I like UnitTypeDef - the common usage is privateData. Oh and you'd need a "void (*privateDataFreeFunc)(void *);". Might also need a few more things, but seems to be a good start. I don't think *List is the way to go, but since that's the model today - we can stick with it until I can work up something better. Lists work well when there's 1-10 elements on the List, but as more elements are added the search times exponentially increase. I think HashTable's are the better option (Domains, Secrets, Networks, and DomainSnapshot use them). See the virDomainObjList for a model. In any case, why are there voldefs in a list? Is this some sort of backing store listing for the same volume object? Or was this meant to be the volume object list? This structure manages how a domain views the storage. It is quite confusing and you have to pay close attention to the usage. Yes, this is essentially for remote/network storage For purposes of what you're trying to accomplish - it can be block storage specific unless you feel fspools would/could use NFS or would have their own need for a network structure. A vGPU would be something local and shouldn't need auth. A vGPU is something new dealing with graphics where there will be a need to have a pool of vGPU's to choose from much the same way there is storage. secrets are usually associated with remote storage; however, they're also something for local only as evidenced by the LUKS encryption secret. We could start as a private thing, but it could be moved as well. Again, depends on the implementation. Of course I've got the vzstorage pool concepts floating in and out of consciousness - tough to focus on one over the other! I have come to realize that mucking in virStorageSource I think is going to require a the structure to become private with a bunch of accessors to fields. Too much code today knows the structure and makes use of it. I started working through doing something like that as a result of other changes I've been posting related to storage source data. The biggest offender in peeking at the StorageSource is the path to the storage. http://libvirt.org/formatstorage.html Target elements, path. There are virStorageSource fields that aren't used for 'target' storage... But there's virStorageSourcePtr used for backingStore... You have to follow code paths to understand usage. ^^ Should use the virObjectLockable object... Yes requires some 'other' adjustments... you'd have to call this 'units' instead of 'elements', which is why I said "Elements" at first. Again, a hash table will be better... I think there's perhaps : _virPoolDef -> Common pool definition with private data pointers _virStorageBlockPoolDef -> Consumer of _virPoolDef as private data _virStorageFSPoolDef -> Consumer of _virPoolDef as private data _virPoolObj -> Common pool object with private data pointer _virStorageBlockPoolObj -> Consumer of _virPoolObj private data _virStorageFSPoolObj -> Consumer of _virPoolObj _virPoolObjList-> Common pool object list manipulation and search API I see no need (yet) for a StorageBlock or StoragePool object list. The ObjList is a table of objects with common reference/lookup functions. The tricky part there is the filtering API's currently used for various lookup APIs in order to pull out specific "types" of objects. The PoolObj some common stuff (def, newdef, some flags, locking) as well as a privateData for specific stuff. It would also have a 'def' that could describe the common lookup of uuid/name. The PoolDef is mostly private just to allow for easier lookups - that would copy the 'def' uuid/name fields FWIW: At the higher abstraction level the driver (StoragePool) is responsible to managing some sort of list or table of objects. Using cscope's egrep search capabilities - "^struct vir.*ObjList" returns 8 such instances. Of those 4 use a counted list (Interface, NodeDevice, NWFilter, StoragePool) and 4 use a hash table (Network, DomainSnapshot, Domain, Secret). Each ObjList would manage the _vir*Obj element corresponding to it (cscope egrep "^struct vir.*Obj {". Each of those Objects has commonality (parent/lock, def, newDef, state bits, privateData, privateDataFreeFunc). For example, search on consumers of "*ObjListNew()" type calls or anything that could be found by a cscope egrep of "^struct vir.*ObjList". There's quite a bit of cut-n-paste there. In any case, the previous 3 paragraphs are something on my radar, but I figured I'd share... Yeah - there's stuff I've found along the way like this too... Usually when something like this is discovered we try to make sure there's some sort of requirement added into the build system so that everyone would see the issue and not just those that have already tripped across it. I think that's where those Requires/BuildRequires come from - been a while since I thought about it though. The point I was making is changing from _virStoragePool to _virPoolCommon won't necessary fly without the ability to have some sort of definition. The usage of "_virPool" instead of "_virCommonPool" is my nomenclature. The example I referenced is how BlkioParameter did the changeover. I think it will work fine, but the details are something that are only known once someone jumps into the pool and starts swimming or sinking (a metaphor for the heap of trouble you get yourself into once you start actually coding things). John

On 12/02/2016 10:38 AM, Olga Krishtal wrote: I couldn't get this one to apply via "git am -3" - the src/Makefile.am failed... Even removing that specific change, the volpoolcommon.h changed - so there's something amiss with the patch.... I'll just make some comments along the way... I also suggest adding the virpool.c to the previous patch, then using subsequent patches to remove code from storage_conf. The end result is the same it's just "easier" to review... I think the file should be util/virpool.c The above stays here - I doubt it'll be used by fspool! It's very specific. The above stays Same The above has some common and some specific stuff - it'll need to be more closely looked at. The whole question of need for a virPoolObj I raised in 1/15 comes into play... I think this moves to virpool.c and is renamed to be more generic - that is anything that says "Storage" needs to change... I see this moving to virpool These are TBD. virpool.h Your new names should not be "virStoragePool" - rather just "virPool" obvious affect in code as well... virpool.c Similar virpool.c - common pool ... Based on earlier review - some of these API's don't move here. I wouldn't expect a "common" function to have "Storage" in the name... Above is specific to SCSI pool... Above is specific to DISK pool Above would just Clear "virPoolSource" things... leaving the virStoragePoolSource things for the storage pool code. I think this stays in storage pool I don't think we even allocate a virPoolDef - it's just a convenience structure within a virStoragePool type. Or inconvenience of typing a few extra characters for structure dereference. Beyond the "virStoragePool" -> "virPool" name change - I suspect the above changes a bit based on my comments from the first patch. The above should have been a part of the original creation of virpool.h I think this should have moved to virpool Obviously affecting this. John

On 12/02/2016 10:38 AM, Olga Krishtal wrote: I would just say moving this code to virpool.c in order to be shared by future patches which will be adding a new file system storage driver that will share the code. Should this have changed in the previous patch? Names would all need to start with virPool (see below for my suggestions). Keep the above alter the first parameter to be "&pool->def->target", then pass the default perms VIR_STORAGE_DEFAULT_POOL_PERM_MODE as a 2nd param Perhaps pass the "pool->def->target" since it contains both "path" and "permissions"... if (!(vol->target.path = virPoolTargetPathCreate(pool->def->target.path, vol->name))) [it'll make sense later] int virPoolBuildDir(const virPoolTarget *target, mode_t default_mode, bool needs_create_as_uuid) target then be referenced as "target->$FIELD" The default should be passed. virPoolDeleteDir taking pool as a parameter... Hmm... me wonders if this should be virFileRemove instead... In any case, it could take a 'const virPoolTarget *target' and do the magic from there. char * virPoolTargetPathCreate(char *poolpath, char *name) char *itempath; return NULL; if (!(itempath = virFileBuildPath(poolpath, name, NULL))) return NULL; s/*// s/*// VIR_FREE(itempath); (which will set itempath = NULL and...) return itempath; will either be valid or NULL This should be passed and not set here as it's block storage driver specific. John

This patch introduces new filesystem pool driver. Signed-off-by: Olga Krishtal <okrishtal(a)virtuozzo.com&gt; --- src/driver-fs.h | 193 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/driver.h | 1 + 2 files changed, 194 insertions(+) create mode 100644 src/driver-fs.h diff --git a/src/driver-fs.h b/src/driver-fs.h new file mode 100644 index 0000000..ba35ec2 --- /dev/null +++ b/src/driver-fs.h @@ -0,0 +1,193 @@ +/* +* driver-fs.h: entry points for fs drivers +* Author: Olga Krishtal <okrishtal(a)virtuozzo.com&gt; +* +* Copyright (C) 2016 Parallels IP Holdings GmbH +* +* 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 +(*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 fspool, + 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 */ + 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_FS_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___ -- 1.8.3.1

Signed-off-by: Olga Krishtal <okrishtal(a)virtuozzo.com&gt; --- src/access/viraccessdriver.h | 15 +++++ src/access/viraccessdrivernop.c | 21 +++++++ src/access/viraccessdriverpolkit.c | 47 ++++++++++++++ src/access/viraccessdriverstack.c | 50 +++++++++++++++ src/access/viraccessmanager.c | 32 ++++++++++ src/access/viraccessmanager.h | 11 +++- src/access/viraccessperm.c | 15 ++++- src/access/viraccessperm.h | 126 +++++++++++++++++++++++++++++++++++++ src/libvirt_private.syms | 5 +- 9 files changed, 318 insertions(+), 4 deletions(-) diff --git a/src/access/viraccessdriver.h b/src/access/viraccessdriver.h index e3050b6..194aa2f 100644 --- a/src/access/viraccessdriver.h +++ b/src/access/viraccessdriver.h @@ -61,6 +61,19 @@ 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); + typedef int (*virAccessDriverSetupDrv)(virAccessManagerPtr manager); typedef void (*virAccessDriverCleanupDrv)(virAccessManagerPtr manager); @@ -83,6 +96,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..a936711 100644 --- a/src/access/viraccessdrivernop.c +++ b/src/access/viraccessdrivernop.c @@ -104,6 +104,25 @@ virAccessDriverNopCheckStorageVol(virAccessManagerPtr manager ATTRIBUTE_UNUSED, } +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 +134,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 0d9e0a1..2beaf74 100644 --- a/src/access/viraccessdriverpolkit.c +++ b/src/access/viraccessdriverpolkit.c @@ -399,6 +399,51 @@ virAccessDriverPolkitCheckStorageVol(virAccessManagerPtr manager, 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", + virAccessPermFSItemTypeToString(perm), + attrs); +} + virAccessDriver accessDriverPolkit = { .privateDataLen = sizeof(virAccessDriverPolkitPrivate), .name = "polkit", @@ -412,4 +457,6 @@ 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..7fe1658 100644 --- a/src/access/viraccessdriverstack.c +++ b/src/access/viraccessdriverstack.c @@ -267,6 +267,54 @@ 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 +328,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..20a1260 100644 --- a/src/access/viraccessmanager.c +++ b/src/access/viraccessmanager.c @@ -344,3 +344,35 @@ 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..5c74572 100644 --- a/src/access/viraccessmanager.h +++ b/src/access/viraccessmanager.h @@ -29,6 +29,7 @@ # include "conf/storage_conf.h" # include "conf/secret_conf.h" # include "conf/interface_conf.h" +# include "conf/fs_conf.h" # include "access/viraccessperm.h" typedef struct _virAccessManager virAccessManager; @@ -86,6 +87,14 @@ 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..8fe5bbf 100644 --- a/src/access/viraccessperm.c +++ b/src/access/viraccessperm.c @@ -31,7 +31,7 @@ VIR_ENUM_IMPL(virAccessPermConnect, "search_interfaces", "search_secrets", "search_nwfilters", "detect_storage_pools", "pm_control", - "interface_transaction"); + "interface_transaction", "search_fspools"); VIR_ENUM_IMPL(virAccessPermDomain, VIR_ACCESS_PERM_DOMAIN_LAST, @@ -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_FSPOOL_LAST, + "getattr", "read", "write", + "save", "delete", "start", "stop", + "refresh", "search_items", + "format"); + +VIR_ENUM_IMPL(virAccessPermFSItem, + VIR_ACCESS_PERM_FSITEM_LAST, + "getattr", "read", "create", "delete", + "format", "data_read", + "data_write"); diff --git a/src/access/viraccessperm.h b/src/access/viraccessperm.h index 1817da7..b8e2531 100644 --- a/src/access/viraccessperm.h +++ b/src/access/viraccessperm.h @@ -113,6 +113,13 @@ typedef enum { */ VIR_ACCESS_PERM_CONNECT_INTERFACE_TRANSACTION, + /** + * * @desc: List fs pools + * * @message: Listing fs pools requires authorization + * * @anonymous: 1 + * */ + VIR_ACCESS_PERM_CONNECT_SEARCH_FSPOOLS, + VIR_ACCESS_PERM_CONNECT_LAST, } virAccessPermConnect; @@ -651,6 +658,123 @@ 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_FSPOOL_GETATTR, + + /** + * @desc: Read fs pool + * @message: Reading fs pool configuration requires authorization + * @anonymous: 1 + */ + VIR_ACCESS_PERM_FSPOOL_READ, + + /** + * @desc: Write fs pool + * @message: Writing fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FSPOOL_WRITE, + + /** + * @desc: Save fs pool + * @message: Saving fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FSPOOL_SAVE, + + /** + * @desc: Delete fs pool + * @message: Deleting fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FSPOOL_DELETE, + + /** + * @desc: Start fs pool + * @message: Starting fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FSPOOL_START, + + /** + * @desc: Stop fs pool + * @message: Stopping fs pool configuration requires authorization + */ + VIR_ACCESS_PERM_FSPOOL_STOP, + + /** + * @desc: Refresh fs pool + * @message: Refreshing fs pool items requires authorization + */ + VIR_ACCESS_PERM_FSPOOL_REFRESH, + + /** + * @desc: List fs pool items + * @message: Listing fs pool items requires authorization + */ + VIR_ACCESS_PERM_FSPOOL_SEARCH_ITEMS, + + /** + * @desc: Format fs pool + * @message: Formatting fs pool data requires authorization + */ + VIR_ACCESS_PERM_FSPOOL_FORMAT, + + VIR_ACCESS_PERM_FSPOOL_LAST +} virAccessPermFSPool; + +typedef enum { + + /** + * @desc: Access fs item + * @message: Acceessing fs item requires authorization + * @anonymous: 1 + */ + VIR_ACCESS_PERM_FSITEM_GETATTR, + + /** + * @desc: Read fs item + * @message: Reading fs item configuration requires authorization + * @anonymous: 1 + */ + VIR_ACCESS_PERM_FSITEM_READ, + + /** + * @desc: Create fs item + * @message: Creating fs item requires authorization + */ + VIR_ACCESS_PERM_FSITEM_CREATE, + + /** + * @desc: Delete fs item + * @message: Deleting fs item requires authorization + */ + VIR_ACCESS_PERM_FSITEM_DELETE, + + /** + * @desc: Format fs item + * @message: Formatting fs item data requires authorization + */ + VIR_ACCESS_PERM_FSITEM_FORMAT, + + /** + * @desc: Read fs item data + * @message: Reading fs item data requires authorization + */ + VIR_ACCESS_PERM_FSITEM_DATA_READ, + + /** + * @desc: Write fs item data + * @message: Writing fs item data requires authorization + */ + VIR_ACCESS_PERM_FSITEM_DATA_WRITE, + + VIR_ACCESS_PERM_FSITEM_LAST +} virAccessPermFSItem; + + VIR_ENUM_DECL(virAccessPermConnect); VIR_ENUM_DECL(virAccessPermDomain); VIR_ENUM_DECL(virAccessPermInterface); @@ -660,5 +784,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 8589394..a14dfc8 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -19,7 +19,8 @@ virAccessManagerGetDefault; virAccessManagerNew; virAccessManagerNewStack; virAccessManagerSetDefault; - +virAccessManagerCheckFSItem; +virAccessManagerCheckFSPool; # access/viraccessperm.h virAccessPermConnectTypeFromString; @@ -40,7 +41,7 @@ virAccessPermStoragePoolTypeFromString; virAccessPermStoragePoolTypeToString; virAccessPermStorageVolTypeFromString; virAccessPermStorageVolTypeToString; - +virAccessPermFSPoolTypeToString; # conf/capabilities.h virCapabilitiesAddGuest; -- 1.8.3.1

Signed-off-by: Olga Krishtal <okrishtal(a)virtuozzo.com&gt; --- daemon/remote.c | 35 ++++ src/Makefile.am | 6 +- src/check-driverimpls.pl | 2 + src/remote/remote_driver.c | 66 ++++++ src/remote/remote_protocol.x | 466 ++++++++++++++++++++++++++++++++++++++++++- src/remote_protocol-structs | 165 +++++++++++++++ src/rpc/gendispatch.pl | 23 ++- 7 files changed, 753 insertions(+), 10 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index e414f92..33e5e77 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_fspool(virConnectPtr conn, remote_nonnull_fspool fspool); +static virFSItemPtr get_nonnull_fsitem(virConnectPtr conn, remote_nonnull_fsitem 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_fspool(remote_nonnull_fspool *fspool_dst, virFSPoolPtr fspool_src); +static void make_nonnull_fsitem(remote_nonnull_fsitem *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); @@ -6660,6 +6664,22 @@ get_nonnull_domain_snapshot(virDomainPtr dom, remote_nonnull_domain_snapshot sna return virGetDomainSnapshot(dom, snapshot.name); } +static virFSPoolPtr +get_nonnull_fspool(virConnectPtr conn, remote_nonnull_fspool fspool) +{ + return virGetFSPool(conn, fspool.name, BAD_CAST fspool.uuid, + NULL, NULL); +} + +static virFSItemPtr +get_nonnull_fsitem(virConnectPtr conn, remote_nonnull_fsitem 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) { @@ -6706,6 +6726,21 @@ make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virStorageVolPtr v } static void +make_nonnull_fspool(remote_nonnull_fspool *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_fsitem(remote_nonnull_fsitem *item_dst, virFSItemPtr item_src) +{ + ignore_value(VIR_STRDUP_QUIET(item_dst->fspool, item_src->pool)); + 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/Makefile.am b/src/Makefile.am index 13a4976..2c9d675 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -233,7 +233,8 @@ DRIVER_SOURCES = \ locking/lock_driver_nop.h locking/lock_driver_nop.c \ locking/domain_lock.h locking/domain_lock.c \ logging/log_manager.c logging/log_manager.h \ - $(NULL) + libvirt-fs.c \ + $(NULL) LOCK_DRIVER_SANLOCK_SOURCES = \ locking/lock_driver_sanlock.c @@ -2400,7 +2401,8 @@ libvirt_setuid_rpc_client_la_SOURCES = \ libvirt-storage.c \ libvirt-stream.c \ libvirt-lxc.c \ - $(NULL) + libvirt-fs.c \ + $(NULL) libvirt_setuid_rpc_client_la_LDFLAGS = \ $(AM_LDFLAGS) \ diff --git a/src/check-driverimpls.pl b/src/check-driverimpls.pl index e320558..bd86886 100755 --- a/src/check-driverimpls.pl +++ b/src/check-driverimpls.pl @@ -54,6 +54,8 @@ while (<>) { if ($api !~ /^$mainprefix/) { $suffix =~ s/^[a-z]+(?:Unified)?//; $suffix =~ s/^([A-Z]+)/lc $1/e; + $suffix =~ s/fsitem/fsItem/; + $suffix =~ s/fspool/fsPool/; } if ($api ne $suffix) { diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index a3cd7cd..b08d598 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_fspool(virConnectPtr conn, remote_nonnull_fspool fspool); +static virFSItemPtr get_nonnull_fsitem(virConnectPtr conn, remote_nonnull_fsitem 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_fspool(remote_nonnull_fspool *fspool_dst, virFSPoolPtr fspool_src); +static void make_nonnull_fsitem(remote_nonnull_fsitem *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); @@ -7841,6 +7845,19 @@ get_nonnull_storage_vol(virConnectPtr conn, remote_nonnull_storage_vol vol) NULL, NULL); } +static virFSPoolPtr +get_nonnull_fspool(virConnectPtr conn, remote_nonnull_fspool fspool) +{ + return virGetFSPool(conn, fspool.name, BAD_CAST fspool.uuid, + NULL, NULL); +} + +static virFSItemPtr +get_nonnull_fsitem(virConnectPtr conn, remote_nonnull_fsitem 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) { @@ -7906,6 +7923,21 @@ make_nonnull_storage_vol(remote_nonnull_storage_vol *vol_dst, virStorageVolPtr v } static void +make_nonnull_fspool(remote_nonnull_fspool *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_fsitem(remote_nonnull_fsitem *item_dst, virFSItemPtr item_src) +{ + item_dst->fspool = item_src->pool; + 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); @@ -8296,6 +8328,39 @@ static virNWFilterDriver nwfilter_driver = { .connectListAllNWFilters = remoteConnectListAllNWFilters, /* 0.10.2 */ }; +static virFSDriver fspool_driver = { + .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, + .connectListAllFSPools = remoteConnectListAllFSPools, +}; + static virConnectDriver connect_driver = { .hypervisorDriver = &hypervisor_driver, .interfaceDriver = &interface_driver, @@ -8304,6 +8369,7 @@ static virConnectDriver connect_driver = { .nwfilterDriver = &nwfilter_driver, .secretDriver = &secret_driver, .storageDriver = &storage_driver, + .fsDriver = &fspool_driver, }; static virStateDriver state_driver = { diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index e8382dc..d1493fc 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_FSPOOL_LIST_MAX = 4096; + +/* Upper limit on lists of fsitems. */ +const REMOTE_FSITEM_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_fspool { + remote_nonnull_string name; + remote_uuid uuid; +}; + +/* A fsitem which may not be NULL. */ +struct remote_nonnull_fsitem { + 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_fspool *remote_fspool; +typedef remote_nonnull_fsitem *remote_fsitem; typedef remote_nonnull_node_device *remote_node_device; /* Error message. See <virterror.h> for explanation of fields. */ @@ -1955,6 +1976,206 @@ struct remote_storage_vol_resize_args { unsigned int flags; }; +/* FS pool calls: */ + +struct remote_fspool_lookup_by_uuid_args { + remote_uuid uuid; +}; + +struct remote_fspool_lookup_by_uuid_ret { + remote_nonnull_fspool pool; +}; + +struct remote_fspool_lookup_by_name_args { + remote_nonnull_string name; +}; + +struct remote_fspool_lookup_by_name_ret { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_lookup_by_item_args { + remote_nonnull_fsitem item; +}; + +struct remote_fspool_lookup_by_item_ret { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_create_xml_args { + remote_nonnull_string xml; + unsigned int flags; +}; + +struct remote_fspool_create_xml_ret { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_define_xml_args { + remote_nonnull_string xml; + unsigned int flags; +}; + +struct remote_fspool_define_xml_ret { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_build_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; + +struct remote_fspool_undefine_args { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_create_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; + +struct remote_fspool_destroy_args { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_delete_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; + +struct remote_fspool_get_xml_desc_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; + +struct remote_fs_pool_get_xml_desc_ret { + remote_nonnull_string xml; +}; + +struct remote_fspool_get_info_args { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_get_info_ret { /* insert@1 */ + unsigned char state; + unsigned hyper capacity; + unsigned hyper allocation; + unsigned hyper available; +}; + +struct remote_fspool_get_autostart_args { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_get_autostart_ret { + int autostart; +}; + +struct remote_fspool_set_autostart_args { + remote_nonnull_fspool fspool; + int autostart; +}; + +struct remote_fspool_num_of_items_args { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_num_of_items_ret { + int num; +}; + +struct remote_fspool_list_items_args { + remote_nonnull_fspool fspool; + int maxnames; +}; + +struct remote_fspool_list_items_ret { + remote_nonnull_string names<REMOTE_FSITEM_LIST_MAX>; /* insert@1 */ +}; +struct remote_fspool_refresh_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; + +/* FS item calls: */ + +struct remote_fsitem_lookup_by_name_args { + remote_nonnull_fspool fspool; + remote_nonnull_string name; +}; + +struct remote_fsitem_lookup_by_name_ret { + remote_nonnull_fsitem item; +}; + +struct remote_fsitem_lookup_by_key_args { + remote_nonnull_string key; +}; + +struct remote_fsitem_lookup_by_key_ret { + remote_nonnull_fsitem item; +}; + +struct remote_fsitem_lookup_by_path_args { + remote_nonnull_string path; +}; + +struct remote_fsitem_lookup_by_path_ret { + remote_nonnull_fsitem item; +}; + +struct remote_fsitem_create_xml_args { + remote_nonnull_fspool fspool; + remote_nonnull_string xml; + unsigned int flags; +}; + +struct remote_fsitem_create_xml_ret { + remote_nonnull_fsitem item; +}; + +struct remote_fsitem_create_xml_from_args { + remote_nonnull_fspool fspool; + remote_nonnull_string xml; + remote_nonnull_fsitem cloneitem; + unsigned int flags; +}; + +struct remote_fsitem_create_xml_from_ret { + remote_nonnull_fsitem item; +}; + +struct remote_fsitem_delete_args { + remote_nonnull_fsitem item; + unsigned int flags; +}; + +struct remote_fsitem_get_xml_desc_args { + remote_nonnull_fsitem item; + unsigned int flags; +}; + +struct remote_fsitem_get_xml_desc_ret { + remote_nonnull_string xml; +}; + +struct remote_fsitem_get_info_args { + remote_nonnull_fsitem item; +}; + +struct remote_fsitem_get_info_ret { /* insert@1 */ + char type; + unsigned hyper capacity; + unsigned hyper allocation; +}; + +struct remote_fsitem_get_path_args { + remote_nonnull_fsitem item; +}; + +struct remote_fsitem_get_path_ret { + remote_nonnull_string name; +}; + /* Node driver calls: */ struct remote_node_num_of_devices_args { @@ -2244,7 +2465,21 @@ struct remote_storage_pool_is_persistent_ret { int persistent; }; +struct remote_fspool_is_active_args { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_is_active_ret { + int active; +}; + +struct remote_fspool_is_persistent_args { + remote_nonnull_fspool fspool; +}; + +struct remote_fspool_is_persistent_ret { + int persistent; +}; struct remote_interface_is_active_args { remote_nonnull_interface iface; }; @@ -2874,6 +3109,27 @@ struct remote_storage_pool_list_all_volumes_ret { /* insert@1 */ unsigned int ret; }; +struct remote_connect_list_all_fspools_args { + int need_results; + unsigned int flags; +}; + +struct remote_connect_list_all_fspools_ret { /* insert@1 */ + remote_nonnull_fspool fspools<REMOTE_FSPOOL_LIST_MAX>; + unsigned int ret; +}; + +struct remote_fspool_list_all_items_args { + remote_nonnull_fspool fspool; + int need_results; + unsigned int flags; +}; + +struct remote_fspool_list_all_items_ret { /* insert@1 */ + remote_nonnull_fsitem items<REMOTE_FSITEM_LIST_MAX>; + unsigned int ret; +}; + struct remote_connect_list_all_networks_args { int need_results; unsigned int flags; @@ -5934,5 +6190,213 @@ enum remote_procedure { * @generate: both * @acl: none */ - REMOTE_PROC_NODE_DEVICE_EVENT_UPDATE = 377 + REMOTE_PROC_NODE_DEVICE_EVENT_UPDATE = 377, + + /** + * @generate: both + * @acl: fspool:start + * @acl: fspool:write + */ + REMOTE_PROC_FSPOOL_CREATE_XML = 382, + + /** + * @generate: both + * @priority: high + * @acl: fspool:write + * @acl: fspool:save + */ + REMOTE_PROC_FSPOOL_DEFINE_XML = 383, + + /** + * @generate: both + * @acl: fspool:format + */ + REMOTE_PROC_FSPOOL_BUILD = 384, + + /** + * @generate: both + * @acl: fspool:format + */ + REMOTE_PROC_FSPOOL_DELETE = 385, + + /** + * @generate: both + * @priority: high + * @acl: fspool:delete + */ + REMOTE_PROC_FSPOOL_UNDEFINE = 386, + + /** + * @generate: both + * @priority: high + * @acl: fspool:getattr + */ + REMOTE_PROC_FSPOOL_LOOKUP_BY_NAME = 387, + + /** + * @generate: both + * @priority: high + * @acl: fspool:getattr + */ + REMOTE_PROC_FSPOOL_LOOKUP_BY_UUID = 388, + + /** + * @generate: both + * @priority: high + * @acl: fspool:getattr + */ + REMOTE_PROC_FSPOOL_LOOKUP_BY_ITEM = 389, + + /** + * @generate: both + * @priority: high + * @acl: fspool:read + */ + REMOTE_PROC_FSPOOL_GET_INFO = 390, + + /** + * @generate: both + * @priority: high + * @acl: fspool:read + */ + REMOTE_PROC_FSPOOL_GET_XML_DESC = 391, + + /** + * @generate: both + * @priority: high + * @acl: fspool:search_items + * @aclfilter: fsitem:getattr + */ + REMOTE_PROC_FSPOOL_NUM_OF_ITEMS = 392, + + /** + * @generate: both + * @priority: high + * @acl: fspool:search_items + * @aclfilter: fsitem:getattr + */ + REMOTE_PROC_FSPOOL_LIST_ITEMS = 393, + + /** + * @generate: both + * @acl: fsitem:create + */ + REMOTE_PROC_FSITEM_CREATE_XML = 394, + + /** + * @generate: both + * @acl: fsitem:delete + */ + REMOTE_PROC_FSITEM_DELETE = 395, + + /** + * @generate: both + * @priority: high + * @acl: fsitem:getattr + */ + REMOTE_PROC_FSITEM_LOOKUP_BY_NAME = 396, + + /** + * @generate: both + * @priority: high + * @acl: fsitem:getattr + */ + REMOTE_PROC_FSITEM_LOOKUP_BY_KEY = 397, + + /** + * @generate: both + * @priority: high + * @acl: fsitem:getattr + */ + REMOTE_PROC_FSITEM_LOOKUP_BY_PATH = 398, + + /** + * @generate: both + * @priority: high + * @acl: fsitem:read + */ + REMOTE_PROC_FSITEM_GET_INFO = 399, + + /** + * @generate: both + * @priority: high + * @acl: fsitem:read + */ + REMOTE_PROC_FSITEM_GET_XML_DESC = 400, + + /** + * @generate: both + * @priority: high + * @acl: fsitem:read + */ + REMOTE_PROC_FSITEM_GET_PATH = 401, + + /** + * @generate: both + * @acl: fsitem:create + */ + REMOTE_PROC_FSITEM_CREATE_XML_FROM = 402, + + /** + * @generate: both + * @priority: high + * @acl: connect:search_fspools + * @aclfilter: fspool:getattr + */ + REMOTE_PROC_CONNECT_LIST_ALL_FSPOOLS = 403, + + /** + * @generate: both + * @priority: high + * @acl: fspool:search_items + * @aclfilter: fsitem:getattr + */ + REMOTE_PROC_FSPOOL_LIST_ALL_ITEMS = 404, + + /** + * @generate: both + * @acl: fspool:refresh + */ + REMOTE_PROC_FSPOOL_REFRESH = 405, + + /** + * @generate: both + * @priority: high + * @acl: fspool:read + */ + REMOTE_PROC_FSPOOL_IS_ACTIVE = 406, + + /** + * @generate: both + * @priority: high + * @acl: fspool:read + */ + REMOTE_PROC_FSPOOL_IS_PERSISTENT = 407, + + /** + * @generate: both + * @priority: high + * @acl: fspool:read + */ + REMOTE_PROC_FSPOOL_GET_AUTOSTART = 408, + + /** + * @generate: both + * @priority: high + * @acl: fspool:write + */ + REMOTE_PROC_FSPOOL_SET_AUTOSTART = 409, + + /** + * @generate: both + * @acl: fspool:start + */ + REMOTE_PROC_FSPOOL_CREATE = 410, + + /** + * @generate: both + * @priority: high + * @acl: fspool:stop + */ + REMOTE_PROC_FSPOOL_DESTROY = 411 }; diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index b71accc..bac0efb 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -34,6 +34,15 @@ struct remote_nonnull_storage_vol { remote_nonnull_string name; remote_nonnull_string key; }; +struct remote_nonnull_fspool { + remote_nonnull_string name; + remote_uuid uuid; +}; +struct remote_nonnull_fsitem { + remote_nonnull_string fspool; + remote_nonnull_string name; + remote_nonnull_string key; +}; struct remote_nonnull_node_device { remote_nonnull_string name; }; @@ -1483,6 +1492,162 @@ struct remote_storage_vol_resize_args { uint64_t capacity; u_int flags; }; +struct remote_fspool_lookup_by_uuid_args { + remote_uuid uuid; +}; +struct remote_fspool_lookup_by_uuid_ret { + remote_nonnull_fspool pool; +}; +struct remote_fspool_lookup_by_name_args { + remote_nonnull_string name; +}; +struct remote_fspool_lookup_by_name_ret { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_lookup_by_item_args { + remote_nonnull_fsitem item; +}; +struct remote_fspool_lookup_by_item_ret { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_create_xml_args { + remote_nonnull_string xml; + unsigned int flags; +}; +struct remote_fspool_create_xml_ret { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_define_xml_args { + remote_nonnull_string xml; + unsigned int flags; +}; +struct remote_fspool_define_xml_ret { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_build_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; +struct remote_fspool_undefine_args { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_create_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; + +struct remote_fspool_destroy_args { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_delete_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; +struct remote_fspool_get_xml_desc_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; +struct remote_fs_pool_get_xml_desc_ret { + remote_nonnull_string xml; +}; +struct remote_fspool_get_info_args { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_get_info_ret { + unsigned char state; + unsigned hyper capacity; + unsigned hyper allocation; + unsigned hyper available; +}; +struct remote_fspool_get_autostart_args { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_get_autostart_ret { + int autostart; +}; +struct remote_fspool_set_autostart_args { + remote_nonnull_fspool fspool; + int autostart; +}; +struct remote_fspool_num_of_items_args { + remote_nonnull_fspool fspool; +}; +struct remote_fspool_num_of_items_ret { + int num; +}; +struct remote_fspool_list_items_args { + remote_nonnull_fspool fspool; + int maxnames; +}; + +struct remote_fspool_list_items_ret { + remote_nonnull_string names<REMOTE_FSITEM_LIST_MAX>; +}; +struct remote_fspool_refresh_args { + remote_nonnull_fspool fspool; + unsigned int flags; +}; +struct remote_fsitem_lookup_by_name_args { + remote_nonnull_fspool fspool; + remote_nonnull_string name; +}; +struct remote_fsitem_lookup_by_name_ret { + remote_nonnull_fsitem item; +}; +struct remote_fsitem_lookup_by_key_args { + remote_nonnull_string key; +}; +struct remote_fsitem_lookup_by_key_ret { + remote_nonnull_fsitem item; +}; +struct remote_fsitem_lookup_by_path_args { + remote_nonnull_string path; +}; +struct remote_fsitem_lookup_by_path_ret { + remote_nonnull_fsitem item; +}; +struct remote_fsitem_create_xml_args { + remote_nonnull_fspool fspool; + remote_nonnull_string xml; + unsigned int flags; +}; +struct remote_fsitem_create_xml_ret { + remote_nonnull_fsitem item; +}; +struct remote_fsitem_create_xml_from_args { + remote_nonnull_fspool fspool; + remote_nonnull_string xml; + remote_nonnull_fsitem cloneitem; + unsigned int flags; +}; +struct remote_fsitem_create_xml_from_ret { + remote_nonnull_fsitem item; +}; +struct remote_fsitem_delete_args { + remote_nonnull_fsitem item; + unsigned int flags; +}; +struct remote_fsitem_get_xml_desc_args { + remote_nonnull_fsitem item; + unsigned int flags; +}; +struct remote_fsitem_get_xml_desc_ret { + remote_nonnull_string xml; +}; +struct remote_fsitem_get_info_args { + remote_nonnull_fsitem item; +}; +struct remote_fsitem_get_info_ret { + char type; + unsigned hyper capacity; + unsigned hyper allocation; +}; +struct remote_fsitem_get_path_args { + remote_nonnull_fsitem item; +}; +struct remote_fsitem_get_path_ret { + remote_nonnull_string name; +}; struct remote_node_num_of_devices_args { remote_string cap; u_int flags; diff --git a/src/rpc/gendispatch.pl b/src/rpc/gendispatch.pl index 173189c..7fd0bbd 100755 --- a/src/rpc/gendispatch.pl +++ b/src/rpc/gendispatch.pl @@ -56,6 +56,8 @@ sub fixup_name { my $name = shift; $name =~ s/Nwfilter/NWFilter/; + $name =~ s/Fspool/FSPool/; + $name =~ s/Fsitem/FSItem/; $name =~ s/Xml$/XML/; $name =~ s/Uri$/URI/; $name =~ s/Uuid$/UUID/; @@ -500,7 +502,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|fspool|fsitem) (\S+);/) { my $type_name = name_to_TypeName($1); push(@vars_list, "vir${type_name}Ptr $2 = NULL"); @@ -665,7 +667,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|fspool|fsitem) (\S+)<(\S+)>;/) { $modern_ret_struct_name = $1; $single_ret_list_error_msg_type = $1; $single_ret_list_name = $2; @@ -723,7 +725,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|fspool|fsitem) (\S+);/) { my $type_name = name_to_TypeName($1); if ($call->{ProcName} eq "DomainCreateWithFlags") { @@ -1268,7 +1270,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|fspool|fsitem) (\S+);/) { my $name = $1; my $arg_name = $2; my $type_name = name_to_TypeName($name); @@ -1461,7 +1463,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|fspool|fsitem) (\S+)<(\S+)>;/) { my $proc_name = name_to_TypeName($1); if ($structprefix eq "admin") { @@ -1513,7 +1515,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|fspool|fsitem) (\S+);/) { my $name = $1; my $arg_name = $2; my $type_name = name_to_TypeName($name); @@ -1968,7 +1970,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"; @@ -2053,6 +2056,8 @@ elsif ($mode eq "client") { $object =~ s/^(\w)/uc $1/e; $object =~ s/_(\w)/uc $1/e; $object =~ s/Nwfilter/NWFilter/; + $object =~ s/Fspool/FSPool/; + $object =~ s/Fsitem/FSItem/; my $objecttype = $prefix . $object . "DefPtr"; $apiname .= $action . "ACL"; @@ -2065,6 +2070,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 +2101,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

Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy(a)virtuozzo.com&gt; Signed-off-by: Maxim Nestratov <mnestratov(a)virtuozzo.com&gt; --- po/POTFILES.in | 2 + tools/Makefile.am | 2 + tools/virsh-fsitem.c | 1293 +++++++++++++++++++++++++++++++++++++++++ tools/virsh-fsitem.h | 39 ++ tools/virsh-fspool.c | 1574 ++++++++++++++++++++++++++++++++++++++++++++++++++ tools/virsh-fspool.h | 38 ++ tools/virsh.c | 4 + tools/virsh.h | 9 + tools/virsh.pod | 252 +++++++- 9 files changed, 3212 insertions(+), 1 deletion(-) create mode 100644 tools/virsh-fsitem.c create mode 100644 tools/virsh-fsitem.h create mode 100644 tools/virsh-fspool.c create mode 100644 tools/virsh-fspool.h diff --git a/po/POTFILES.in b/po/POTFILES.in index 7ad9174..2d4c191 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -289,8 +289,10 @@ tools/virsh-console.c tools/virsh-domain-monitor.c tools/virsh-domain.c tools/virsh-edit.c +tools/virsh-fspool.c tools/virsh-host.c tools/virsh-interface.c +tools/virsh-fsitem.c tools/virsh-network.c tools/virsh-nodedev.c tools/virsh-nwfilter.c diff --git a/tools/Makefile.am b/tools/Makefile.am index 319abb2..ff68bd2 100644 --- a/tools/Makefile.am +++ b/tools/Makefile.am @@ -198,9 +198,11 @@ virsh_SOURCES = \ virsh-nodedev.c virsh-nodedev.h \ virsh-nwfilter.c virsh-nwfilter.h \ virsh-pool.c virsh-pool.h \ + virsh-fspool.c virsh-fspool.h \ virsh-secret.c virsh-secret.h \ virsh-snapshot.c virsh-snapshot.h \ virsh-volume.c virsh-volume.h \ + virsh-fsitem.c virsh-fsitem.h \ $(NULL) virsh_LDFLAGS = \ diff --git a/tools/virsh-fsitem.c b/tools/virsh-fsitem.c new file mode 100644 index 0000000..87fb327 --- /dev/null +++ b/tools/virsh-fsitem.c @@ -0,0 +1,1293 @@ +/* + * virsh-fsitem.c: Commands to manage storage item + * + * Copyright (C) 2016 Parallels IP Holdings GmbH + * + * 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/>;. + * + * Olga Krishtal <okrishtal(a)virtuozzo.com&gt; + * + */ +#include <config.h> +#include "virsh-fsitem.h" + +#include <fcntl.h> + +#include <libxml/parser.h> +#include <libxml/tree.h> +#include <libxml/xpath.h> +#include <libxml/xmlsave.h> + +#include "internal.h" +#include "virbuffer.h" +#include "viralloc.h" +#include "virutil.h" +#include "virfile.h" +#include "virsh-fspool.h" +#include "virxml.h" +#include "virstring.h" + +#define VIRSH_COMMON_OPT_FSPOOL_FULL \ + VIRSH_COMMON_OPT_FSPOOL(N_("fspool name or uuid")) \ + +#define VIRSH_COMMON_OPT_FSPOOL_NAME \ + VIRSH_COMMON_OPT_FSPOOL(N_("fspool name")) \ + +#define VIRSH_COMMON_OPT_FSPOOL_OPTIONAL \ + {.name = "fspool", \ + .type = VSH_OT_STRING, \ + .help = N_("fspool name or uuid") \ + } \ + +#define VIRSH_COMMON_OPT_ITEM \ + {.name = "item", \ + .type = VSH_OT_DATA, \ + .flags = VSH_OFLAG_REQ, \ + .help = N_("item name, key or path") \ + } \ + +virFSItemPtr +virshCommandOptItemBy(vshControl *ctl, const vshCmd *cmd, + const char *optname, + const char *fspooloptname, + const char **name, unsigned int flags) +{ + virFSItemPtr item = NULL; + virFSPoolPtr fspool = NULL; + const char *n = NULL, *p = NULL; + virshControlPtr priv = ctl->privData; + + virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL); + + if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0) + return NULL; + + if (fspooloptname != NULL && + vshCommandOptStringReq(ctl, cmd, fspooloptname, &p) < 0) + return NULL; + + if (p) { + if (!(fspool = virshCommandOptFSPoolBy(ctl, cmd, fspooloptname, name, flags))) + return NULL; + + if (virFSPoolIsActive(fspool) != 1) { + vshError(ctl, _("fspool '%s' is not active"), p); + virFSPoolFree(fspool); + return NULL; + } + } + + vshDebug(ctl, VSH_ERR_DEBUG, "%s: found option <%s>: %s\n", + cmd->def->name, optname, n); + + if (name) + *name = n; + + /* try it by name */ + if (fspool && (flags & VIRSH_BYNAME)) { + vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as item name\n", + cmd->def->name, optname); + item = virFSItemLookupByName(fspool, n); + } + /* try it by key */ + if (!item && (flags & VIRSH_BYUUID)) { + vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as item key\n", + cmd->def->name, optname); + item = virFSItemLookupByKey(priv->conn, n); + } + /* try it by path */ + if (!item && (flags & VIRSH_BYUUID)) { + vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as item path\n", + cmd->def->name, optname); + item = virFSItemLookupByPath(priv->conn, n); + } + + if (!item) { + if (fspool || !fspooloptname) + vshError(ctl, _("failed to get item '%s'"), n); + else + vshError(ctl, _("failed to get item '%s', specifying --%s " + "might help"), n, fspooloptname); + } + + /* If the fspool was specified, then make sure that the returned + * item is from the given fspool */ + if (fspool && item) { + virFSPoolPtr itemfspool = NULL; + + if ((itemfspool = virFSPoolLookupByItem(item))) { + if (STRNEQ(virFSPoolGetName(itemfspool), + virFSPoolGetName(fspool))) { + vshResetLibvirtError(); + vshError(ctl, + _("Requested item '%s' is not in fspool '%s'"), + n, virFSPoolGetName(fspool)); + virFSItemFree(item); + item = NULL; + } + virFSPoolFree(itemfspool); + } + } + + if (fspool) + virFSPoolFree(fspool); + + return item; +} + +/* + * "item-create-as" command + */ +static const vshCmdInfo info_item_create_as[] = { + {.name = "help", + .data = N_("create a item from a set of args") + }, + {.name = "desc", + .data = N_("Create a item.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_create_as[] = { + VIRSH_COMMON_OPT_FSPOOL_NAME, + {.name = "name", + .type = VSH_OT_DATA, + .flags = VSH_OFLAG_REQ, + .help = N_("name of the item") + }, + {.name = "capacity", + .type = VSH_OT_DATA, + .flags = VSH_OFLAG_REQ, + .help = N_("size of the item, as scaled integer (default bytes)") + }, + {.name = "allocation", + .type = VSH_OT_STRING, + .help = N_("initial allocation size, as scaled integer (default bytes)") + }, + {.name = "format", + .type = VSH_OT_STRING, + .help = N_("file format type raw,bochs,qcow,qcow2,qed,vmdk") + }, + {.name = "print-xml", + .type = VSH_OT_BOOL, + .help = N_("print XML document, but don't define/create") + }, + {.name = NULL} +}; + +static int +virshItemSize(const char *data, unsigned long long *val) +{ + char *end; + if (virStrToLong_ull(data, &end, 10, val) < 0) + return -1; + return virScaleInteger(val, end, 1, ULLONG_MAX); +} + +static bool +cmdItemCreateAs(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + virFSItemPtr item = NULL; + char *xml = NULL; + bool printXML = vshCommandOptBool(cmd, "print-xml"); + const char *name, *capacityStr = NULL, *allocationStr = NULL, *format = NULL; + unsigned long long capacity, allocation = 0; + virBuffer buf = VIR_BUFFER_INITIALIZER; + unsigned long flags = 0; + bool ret = false; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", NULL))) + return false; + + if (vshCommandOptStringReq(ctl, cmd, "name", &name) < 0) + goto cleanup; + + if (vshCommandOptStringReq(ctl, cmd, "capacity", &capacityStr) < 0) + goto cleanup; + + if (virshItemSize(capacityStr, &capacity) < 0) { + vshError(ctl, _("Malformed size %s"), capacityStr); + goto cleanup; + } + + if (vshCommandOptStringQuiet(ctl, cmd, "allocation", &allocationStr) > 0 && + virshItemSize(allocationStr, &allocation) < 0) { + vshError(ctl, _("Malformed size %s"), allocationStr); + goto cleanup; + } + + if (vshCommandOptStringReq(ctl, cmd, "format", &format)) + goto cleanup; + + virBufferAddLit(&buf, "<item>\n"); + virBufferAdjustIndent(&buf, 2); + virBufferAsprintf(&buf, "<name>%s</name>\n", name); + virBufferAsprintf(&buf, "<capacity>%llu</capacity>\n", capacity); + if (allocationStr) + virBufferAsprintf(&buf, "<allocation>%llu</allocation>\n", allocation); + + if (format) { + virBufferAddLit(&buf, "<target>\n"); + virBufferAdjustIndent(&buf, 2); + virBufferAsprintf(&buf, "<format type='%s'/>\n", format); + virBufferAdjustIndent(&buf, -2); + virBufferAddLit(&buf, "</target>\n"); + } + + virBufferAdjustIndent(&buf, -2); + virBufferAddLit(&buf, "</item>\n"); + + if (virBufferError(&buf)) { + vshPrint(ctl, "%s", _("Failed to allocate XML buffer")); + goto cleanup; + } + xml = virBufferContentAndReset(&buf); + + if (printXML) { + vshPrint(ctl, "%s", xml); + } else { + if (!(item = virFSItemCreateXML(fspool, xml, flags))) { + vshError(ctl, _("Failed to create item %s"), name); + goto cleanup; + } + vshPrint(ctl, _("Item %s created\n"), name); + } + + ret = true; + + cleanup: + virBufferFreeAndReset(&buf); + if (item) + virFSItemFree(item); + virFSPoolFree(fspool); + VIR_FREE(xml); + return ret; +} + +/* + * "item-create" command + */ +static const vshCmdInfo info_item_create[] = { + {.name = "help", + .data = N_("create a item from an XML file") + }, + {.name = "desc", + .data = N_("Create a item.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_create[] = { + VIRSH_COMMON_OPT_FSPOOL_NAME, + VIRSH_COMMON_OPT_FILE(N_("file containing an XML item description")), + {.name = NULL} +}; + +static bool +cmdItemCreate(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + virFSItemPtr item; + const char *from = NULL; + bool ret = false; + unsigned int flags = 0; + char *buffer = NULL; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", NULL))) + return false; + + if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0) + goto cleanup; + + if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0) { + vshSaveLibvirtError(); + goto cleanup; + } + + if ((item = virFSItemCreateXML(fspool, buffer, flags))) { + vshPrint(ctl, _("Item %s created from %s\n"), + virFSItemGetName(item), from); + virFSItemFree(item); + ret = true; + } else { + vshError(ctl, _("Failed to create item from %s"), from); + } + + cleanup: + VIR_FREE(buffer); + virFSPoolFree(fspool); + return ret; +} + +/* + * "item-create-from" command + */ +static const vshCmdInfo info_item_create_from[] = { + {.name = "help", + .data = N_("create a item, using another item as input") + }, + {.name = "desc", + .data = N_("Create a item from an existing item.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_create_from[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + VIRSH_COMMON_OPT_FILE(N_("file containing an XML item description")), + VIRSH_COMMON_OPT_ITEM, + {.name = "inputfspool", + .type = VSH_OT_STRING, + .help = N_("fspool name or uuid of the input item's fspool") + }, + {.name = NULL} +}; + +static bool +cmdItemCreateFrom(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool = NULL; + virFSItemPtr newitem = NULL, inputitem = NULL; + const char *from = NULL; + bool ret = false; + char *buffer = NULL; + unsigned int flags = 0; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", NULL))) + goto cleanup; + + if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0) + goto cleanup; + + if (!(inputitem = virshCommandOptItem(ctl, cmd, "item", "inputfspool", NULL))) + goto cleanup; + + if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0) { + vshReportError(ctl); + goto cleanup; + } + + newitem = virFSItemCreateXMLFrom(fspool, buffer, inputitem, flags); + + if (newitem != NULL) { + vshPrint(ctl, _("Item %s created from input item %s\n"), + virFSItemGetName(newitem), virFSItemGetName(inputitem)); + } else { + vshError(ctl, _("Failed to create item from %s"), from); + goto cleanup; + } + + ret = true; + cleanup: + VIR_FREE(buffer); + if (fspool) + virFSPoolFree(fspool); + if (inputitem) + virFSItemFree(inputitem); + if (newitem) + virFSItemFree(newitem); + return ret; +} + +static xmlChar * +virshMakeCloneXML(const char *origxml, const char *newname) +{ + + xmlDocPtr doc = NULL; + xmlXPathContextPtr ctxt = NULL; + xmlXPathObjectPtr obj = NULL; + xmlChar *newxml = NULL; + int size; + + doc = virXMLParseStringCtxt(origxml, _("(item_definition)"), &ctxt); + if (!doc) + goto cleanup; + + obj = xmlXPathEval(BAD_CAST "/item/name", ctxt); + if (obj == NULL || obj->nodesetval == NULL || + obj->nodesetval->nodeTab == NULL) + goto cleanup; + + xmlNodeSetContent(obj->nodesetval->nodeTab[0], (const xmlChar *)newname); + xmlDocDumpMemory(doc, &newxml, &size); + + cleanup: + xmlXPathFreeObject(obj); + xmlXPathFreeContext(ctxt); + xmlFreeDoc(doc); + return newxml; +} + +/* + * "item-clone" command + */ +static const vshCmdInfo info_item_clone[] = { + {.name = "help", + .data = N_("clone a item.") + }, + {.name = "desc", + .data = N_("Clone an existing item within the parent fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_clone[] = { + VIRSH_COMMON_OPT_ITEM, + {.name = "newname", + .type = VSH_OT_DATA, + .flags = VSH_OFLAG_REQ, + .help = N_("clone name") + }, + VIRSH_COMMON_OPT_FSPOOL_OPTIONAL, + {.name = NULL} +}; + +static bool +cmdItemClone(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr origfspool = NULL; + virFSItemPtr origitem = NULL, newitem = NULL; + const char *name = NULL; + char *origxml = NULL; + xmlChar *newxml = NULL; + bool ret = false; + unsigned int flags = 0; + + if (!(origitem = virshCommandOptItem(ctl, cmd, "item", "fspool", NULL))) + goto cleanup; + + origfspool = virFSPoolLookupByItem(origitem); + if (!origfspool) { + vshError(ctl, "%s", _("failed to get parent fspool")); + goto cleanup; + } + + if (vshCommandOptStringReq(ctl, cmd, "newname", &name) < 0) + goto cleanup; + + origxml = virFSItemGetXMLDesc(origitem, 0); + if (!origxml) + goto cleanup; + + newxml = virshMakeCloneXML(origxml, name); + if (!newxml) { + vshPrint(ctl, "%s", _("Failed to allocate XML buffer")); + goto cleanup; + } + + newitem = virFSItemCreateXMLFrom(origfspool, (char *) newxml, origitem, flags); + + if (newitem != NULL) { + vshPrint(ctl, _("Item %s cloned from %s\n"), + virFSItemGetName(newitem), virFSItemGetName(origitem)); + } else { + vshError(ctl, _("Failed to clone item from %s"), + virFSItemGetName(origitem)); + goto cleanup; + } + + ret = true; + + cleanup: + VIR_FREE(origxml); + xmlFree(newxml); + if (origitem) + virFSItemFree(origitem); + if (newitem) + virFSItemFree(newitem); + if (origfspool) + virFSPoolFree(origfspool); + return ret; +} + +/* + * "item-delete" command + */ +static const vshCmdInfo info_item_delete[] = { + {.name = "help", + .data = N_("delete a item") + }, + {.name = "desc", + .data = N_("Delete a given item.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_delete[] = { + VIRSH_COMMON_OPT_ITEM, + VIRSH_COMMON_OPT_FSPOOL_OPTIONAL, + {.name = NULL} +}; + +static bool +cmdItemDelete(vshControl *ctl, const vshCmd *cmd) +{ + virFSItemPtr item; + bool ret = true; + const char *name; + unsigned int flags = 0; + + if (!(item = virshCommandOptItem(ctl, cmd, "item", "fspool", &name))) + return false; + + if (virFSItemDelete(item, flags) == 0) { + vshPrint(ctl, _("Item %s deleted\n"), name); + } else { + vshError(ctl, _("Failed to delete item %s"), name); + ret = false; + } + + virFSItemFree(item); + return ret; +} + +VIR_ENUM_DECL(virshFSItem) +VIR_ENUM_IMPL(virshFSItem, + VIR_FSITEM_LAST, + N_("dir")) + +static const char * +virshItemTypeToString(int type) +{ + const char *str = virshFSItemTypeToString(type); + return str ? _(str) : _("unknown"); +} + + +/* + * "item-info" command + */ +static const vshCmdInfo info_item_info[] = { + {.name = "help", + .data = N_("storage item information") + }, + {.name = "desc", + .data = N_("Returns basic information about the storage item.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_info[] = { + VIRSH_COMMON_OPT_ITEM, + VIRSH_COMMON_OPT_FSPOOL_OPTIONAL, + {.name = "bytes", + .type = VSH_OT_BOOL, + .help = N_("sizes are represented in bytes rather than pretty units") + }, + {.name = NULL} +}; + +static bool +cmdItemInfo(vshControl *ctl, const vshCmd *cmd) +{ + virFSItemInfo info; + virFSItemPtr item; + bool bytes = vshCommandOptBool(cmd, "bytes"); + bool ret = true; + + if (!(item = virshCommandOptItem(ctl, cmd, "item", "fspool", NULL))) + return false; + + vshPrint(ctl, "%-15s %s\n", _("Name:"), virFSItemGetName(item)); + + if (virFSItemGetInfo(item, &info) == 0) { + double val; + const char *unit; + + vshPrint(ctl, "%-15s %s\n", _("Type:"), + virshItemTypeToString(info.type)); + + if (bytes) { + vshPrint(ctl, "%-15s %llu %s\n", _("Capacity:"), + info.capacity, _("bytes")); + } else { + val = vshPrettyCapacity(info.capacity, &unit); + vshPrint(ctl, "%-15s %2.2lf %s\n", _("Capacity:"), val, unit); + } + + if (bytes) { + vshPrint(ctl, "%-15s %llu %s\n", _("Allocation:"), + info.allocation, _("bytes")); + } else { + val = vshPrettyCapacity(info.allocation, &unit); + vshPrint(ctl, "%-15s %2.2lf %s\n", _("Allocation:"), val, unit); + } + } else { + ret = false; + } + + virFSItemFree(item); + return ret; +} + +/* + * "item-dumpxml" command + */ +static const vshCmdInfo info_item_dumpxml[] = { + {.name = "help", + .data = N_("item information in XML") + }, + {.name = "desc", + .data = N_("Output the item information as an XML dump to stdout.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_dumpxml[] = { + VIRSH_COMMON_OPT_ITEM, + VIRSH_COMMON_OPT_FSPOOL_OPTIONAL, + {.name = NULL} +}; + +static bool +cmdItemDumpXML(vshControl *ctl, const vshCmd *cmd) +{ + virFSItemPtr item; + bool ret = true; + char *dump; + + if (!(item = virshCommandOptItem(ctl, cmd, "item", "fspool", NULL))) + return false; + + dump = virFSItemGetXMLDesc(item, 0); + if (dump != NULL) { + vshPrint(ctl, "%s", dump); + VIR_FREE(dump); + } else { + ret = false; + } + + virFSItemFree(item); + return ret; +} + +static int +virshFSItemSorter(const void *a, const void *b) +{ + virFSItemPtr *va = (virFSItemPtr *) a; + virFSItemPtr *vb = (virFSItemPtr *) b; + + if (*va && !*vb) + return -1; + + if (!*va) + return *vb != NULL; + + return vshStrcasecmp(virFSItemGetName(*va), + virFSItemGetName(*vb)); +} + +struct virshFSItemList { + virFSItemPtr *items; + size_t nitems; +}; +typedef struct virshFSItemList *virshFSItemListPtr; + +static void +virshFSItemListFree(virshFSItemListPtr list) +{ + size_t i; + + if (list && list->items) { + for (i = 0; i < list->nitems; i++) { + if (list->items[i]) + virFSItemFree(list->items[i]); + } + VIR_FREE(list->items); + } + VIR_FREE(list); +} + +static virshFSItemListPtr +virshFSItemListCollect(vshControl *ctl, + virFSPoolPtr fspool, + unsigned int flags) +{ + virshFSItemListPtr list = vshMalloc(ctl, sizeof(*list)); + size_t i; + char **names = NULL; + virFSItemPtr item = NULL; + bool success = false; + size_t deleted = 0; + int nitems = 0; + int ret = -1; + + /* try the list with flags support (0.10.2 and later) */ + if ((ret = virFSPoolListAllItems(fspool, + &list->items, + flags)) >= 0) { + list->nitems = ret; + goto finished; + } + + /* check if the command is actually supported */ + if (last_error && last_error->code == VIR_ERR_NO_SUPPORT) + goto fallback; + + /* there was an error during the call */ + vshError(ctl, "%s", _("Failed to list items")); + goto cleanup; + + fallback: + /* fall back to old method (0.10.1 and older) */ + vshResetLibvirtError(); + + /* Determine the number of items in the fspool */ + if ((nitems = virFSPoolNumOfItems(fspool)) < 0) { + vshError(ctl, "%s", _("Failed to list storage items")); + goto cleanup; + } + + if (nitems == 0) { + success = true; + return list; + } + + /* Retrieve the list of item names in the fspool */ + names = vshCalloc(ctl, nitems, sizeof(*names)); + if ((nitems = virFSPoolListItems(fspool, names, nitems)) < 0) { + vshError(ctl, "%s", _("Failed to list storage items")); + goto cleanup; + } + + list->items = vshMalloc(ctl, sizeof(virFSItemPtr) * (nitems)); + list->nitems = 0; + + /* get the items */ + for (i = 0; i < nitems; i++) { + if (!(item = virFSItemLookupByName(fspool, names[i]))) + continue; + list->items[list->nitems++] = item; + } + + /* truncate the list for not found items */ + deleted = nitems - list->nitems; + + finished: + /* sort the list */ + if (list->items && list->nitems) + qsort(list->items, list->nitems, sizeof(*list->items), virshFSItemSorter); + + if (deleted) + VIR_SHRINK_N(list->items, list->nitems, deleted); + + success = true; + + cleanup: + if (nitems > 0) + for (i = 0; i < nitems; i++) + VIR_FREE(names[i]); + VIR_FREE(names); + + if (!success) { + virshFSItemListFree(list); + list = NULL; + } + + return list; +} + +/* + * "item-list" command + */ +static const vshCmdInfo info_item_list[] = { + {.name = "help", + .data = N_("list items") + }, + {.name = "desc", + .data = N_("Returns list of items by fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_list[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + {.name = "details", + .type = VSH_OT_BOOL, + .help = N_("display extended details for items") + }, + {.name = NULL} +}; + +static bool +cmdItemList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED) +{ + virFSItemInfo itemInfo; + virFSPoolPtr fspool; + char *outputStr = NULL; + const char *unit; + double val; + bool details = vshCommandOptBool(cmd, "details"); + size_t i; + bool ret = false; + int stringLength = 0; + size_t allocStrLength = 0, capStrLength = 0; + size_t nameStrLength = 0, pathStrLength = 0; + size_t typeStrLength = 0; + struct itemInfoText { + char *allocation; + char *capacity; + char *path; + char *type; + }; + struct itemInfoText *itemInfoTexts = NULL; + virshFSItemListPtr list = NULL; + + /* Look up the fspool information given to us by the user */ + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", NULL))) + return false; + + if (!(list = virshFSItemListCollect(ctl, fspool, 0))) + goto cleanup; + + if (list->nitems > 0) + itemInfoTexts = vshCalloc(ctl, list->nitems, sizeof(*itemInfoTexts)); + + /* Collect the rest of the item information for display */ + for (i = 0; i < list->nitems; i++) { + /* Retrieve item info */ + virFSItemPtr item = list->items[i]; + + /* Retrieve the item path */ + if ((itemInfoTexts[i].path = virFSItemGetPath(item)) == NULL) { + /* Something went wrong retrieving a item path, cope with it */ + itemInfoTexts[i].path = vshStrdup(ctl, _("unknown")); + } + + /* If requested, retrieve item type and sizing information */ + if (details) { + if (virFSItemGetInfo(item, &itemInfo) != 0) { + /* Something went wrong retrieving item info, cope with it */ + itemInfoTexts[i].allocation = vshStrdup(ctl, _("unknown")); + itemInfoTexts[i].capacity = vshStrdup(ctl, _("unknown")); + itemInfoTexts[i].type = vshStrdup(ctl, _("unknown")); + } else { + /* Convert the returned item info into output strings */ + + /* Item type */ + itemInfoTexts[i].type = vshStrdup(ctl, + virshItemTypeToString(itemInfo.type)); + + val = vshPrettyCapacity(itemInfo.capacity, &unit); + if (virAsprintf(&itemInfoTexts[i].capacity, + "%.2lf %s", val, unit) < 0) + goto cleanup; + + val = vshPrettyCapacity(itemInfo.allocation, &unit); + if (virAsprintf(&itemInfoTexts[i].allocation, + "%.2lf %s", val, unit) < 0) + goto cleanup; + } + + /* Remember the largest length for each output string. + * This lets us displaying header and item information rows + * using a single, properly sized, printf style output string. + */ + + /* Keep the length of name string if longest so far */ + stringLength = strlen(virFSItemGetName(list->items[i])); + if (stringLength > nameStrLength) + nameStrLength = stringLength; + + /* Keep the length of path string if longest so far */ + stringLength = strlen(itemInfoTexts[i].path); + if (stringLength > pathStrLength) + pathStrLength = stringLength; + + /* Keep the length of type string if longest so far */ + stringLength = strlen(itemInfoTexts[i].type); + if (stringLength > typeStrLength) + typeStrLength = stringLength; + + /* Keep the length of capacity string if longest so far */ + stringLength = strlen(itemInfoTexts[i].capacity); + if (stringLength > capStrLength) + capStrLength = stringLength; + + /* Keep the length of allocation string if longest so far */ + stringLength = strlen(itemInfoTexts[i].allocation); + if (stringLength > allocStrLength) + allocStrLength = stringLength; + } + } + + /* If the --details option wasn't selected, we output the item + * info using the fixed string format from previous versions to + * maintain backward compatibility. + */ + + /* Output basic info then return if --details option not selected */ + if (!details) { + /* The old output format */ + vshPrintExtra(ctl, " %-20s %-40s\n", _("Name"), _("Path")); + vshPrintExtra(ctl, "---------------------------------------" + "---------------------------------------\n"); + for (i = 0; i < list->nitems; i++) { + vshPrint(ctl, " %-20s %-40s\n", virFSItemGetName(list->items[i]), + itemInfoTexts[i].path); + } + + /* Cleanup and return */ + ret = true; + goto cleanup; + } + + /* We only get here if the --details option was selected. */ + + /* Use the length of name header string if it's longest */ + stringLength = strlen(_("Name")); + if (stringLength > nameStrLength) + nameStrLength = stringLength; + + /* Use the length of path header string if it's longest */ + stringLength = strlen(_("Path")); + if (stringLength > pathStrLength) + pathStrLength = stringLength; + + /* Use the length of type header string if it's longest */ + stringLength = strlen(_("Type")); + if (stringLength > typeStrLength) + typeStrLength = stringLength; + + /* Use the length of capacity header string if it's longest */ + stringLength = strlen(_("Capacity")); + if (stringLength > capStrLength) + capStrLength = stringLength; + + /* Use the length of allocation header string if it's longest */ + stringLength = strlen(_("Allocation")); + if (stringLength > allocStrLength) + allocStrLength = stringLength; + + /* Display the string lengths for debugging */ + vshDebug(ctl, VSH_ERR_DEBUG, + "Longest name string = %zu chars\n", nameStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, + "Longest path string = %zu chars\n", pathStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, + "Longest type string = %zu chars\n", typeStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, + "Longest capacity string = %zu chars\n", capStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, + "Longest allocation string = %zu chars\n", allocStrLength); + + if (virAsprintf(&outputStr, + " %%-%lus %%-%lus %%-%lus %%%lus %%%lus\n", + (unsigned long) nameStrLength, + (unsigned long) pathStrLength, + (unsigned long) typeStrLength, + (unsigned long) capStrLength, + (unsigned long) allocStrLength) < 0) + goto cleanup; + + /* Display the header */ + vshPrint(ctl, outputStr, _("Name"), _("Path"), _("Type"), + ("Capacity"), _("Allocation")); + for (i = nameStrLength + pathStrLength + typeStrLength + + capStrLength + allocStrLength + + 10; i > 0; i--) + vshPrintExtra(ctl, "-"); + vshPrintExtra(ctl, "\n"); + + /* Display the item info rows */ + for (i = 0; i < list->nitems; i++) { + vshPrint(ctl, outputStr, + virFSItemGetName(list->items[i]), + itemInfoTexts[i].path, + itemInfoTexts[i].type, + itemInfoTexts[i].capacity, + itemInfoTexts[i].allocation); + } + + /* Cleanup and return */ + ret = true; + + cleanup: + + /* Safely free the memory allocated in this function */ + if (list && list->nitems) { + for (i = 0; i < list->nitems; i++) { + /* Cleanup the memory for one item info structure per loop */ + VIR_FREE(itemInfoTexts[i].path); + VIR_FREE(itemInfoTexts[i].type); + VIR_FREE(itemInfoTexts[i].capacity); + VIR_FREE(itemInfoTexts[i].allocation); + } + } + + /* Cleanup remaining memory */ + VIR_FREE(outputStr); + VIR_FREE(itemInfoTexts); + virFSPoolFree(fspool); + virshFSItemListFree(list); + + /* Return the desired value */ + return ret; +} + +/* + * "item-name" command + */ +static const vshCmdInfo info_item_name[] = { + {.name = "help", + .data = N_("returns the item name for a given item key or path") + }, + {.name = "desc", + .data = "" + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_name[] = { + {.name = "item", + .type = VSH_OT_DATA, + .flags = VSH_OFLAG_REQ, + .help = N_("item key or path") + }, + {.name = NULL} +}; + +static bool +cmdItemName(vshControl *ctl, const vshCmd *cmd) +{ + virFSItemPtr item; + + if (!(item = virshCommandOptItemBy(ctl, cmd, "item", NULL, NULL, + VIRSH_BYUUID))) + return false; + + vshPrint(ctl, "%s\n", virFSItemGetName(item)); + virFSItemFree(item); + return true; +} + +/* + * "item-fspool" command + */ +static const vshCmdInfo info_item_fspool[] = { + {.name = "help", + .data = N_("returns the storage fspool for a given item key or path") + }, + {.name = "desc", + .data = "" + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_fspool[] = { + {.name = "item", + .type = VSH_OT_DATA, + .flags = VSH_OFLAG_REQ, + .help = N_("item key or path") + }, + {.name = "uuid", + .type = VSH_OT_BOOL, + .help = N_("return the fspool uuid rather than fspool name") + }, + {.name = NULL} +}; + +static bool +cmdItemPool(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + virFSItemPtr item; + char uuid[VIR_UUID_STRING_BUFLEN]; + + /* Use the supplied string to locate the item */ + if (!(item = virshCommandOptItemBy(ctl, cmd, "item", NULL, NULL, + VIRSH_BYUUID))) { + return false; + } + + /* Look up the parent storage fspool for the item */ + fspool = virFSPoolLookupByItem(item); + if (fspool == NULL) { + vshError(ctl, "%s", _("failed to get parent fspool")); + virFSItemFree(item); + return false; + } + + /* Return the requested details of the parent storage fspool */ + if (vshCommandOptBool(cmd, "uuid")) { + /* Retrieve and return fspool UUID string */ + if (virFSPoolGetUUIDString(fspool, &uuid[0]) == 0) + vshPrint(ctl, "%s\n", uuid); + } else { + /* Return the storage fspool name */ + vshPrint(ctl, "%s\n", virFSPoolGetName(fspool)); + } + + /* Cleanup */ + virFSItemFree(item); + virFSPoolFree(fspool); + return true; +} + +/* + * "item-key" command + */ +static const vshCmdInfo info_item_key[] = { + {.name = "help", + .data = N_("returns the item key for a given item name or path") + }, + {.name = "desc", + .data = "" + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_key[] = { + {.name = "item", + .type = VSH_OT_DATA, + .flags = VSH_OFLAG_REQ, + .help = N_("item name or path") + }, + VIRSH_COMMON_OPT_FSPOOL_OPTIONAL, + {.name = NULL} +}; + +static bool +cmdItemKey(vshControl *ctl, const vshCmd *cmd) +{ + virFSItemPtr item; + + if (!(item = virshCommandOptItem(ctl, cmd, "item", "fspool", NULL))) + return false; + + vshPrint(ctl, "%s\n", virFSItemGetKey(item)); + virFSItemFree(item); + return true; +} + +/* + * "item-path" command + */ +static const vshCmdInfo info_item_path[] = { + {.name = "help", + .data = N_("returns the item path for a given item name or key") + }, + {.name = "desc", + .data = "" + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_item_path[] = { + {.name = "item", + .type = VSH_OT_DATA, + .flags = VSH_OFLAG_REQ, + .help = N_("item name or key") + }, + VIRSH_COMMON_OPT_FSPOOL_OPTIONAL, + {.name = NULL} +}; + +static bool +cmdItemPath(vshControl *ctl, const vshCmd *cmd) +{ + virFSItemPtr item; + char * FSItemPath; + + if (!(item = virshCommandOptItem(ctl, cmd, "item", "fspool", NULL))) + return false; + + if ((FSItemPath = virFSItemGetPath(item)) == NULL) { + virFSItemFree(item); + return false; + } + + vshPrint(ctl, "%s\n", FSItemPath); + VIR_FREE(FSItemPath); + virFSItemFree(item); + return true; +} + +const vshCmdDef fsItemCmds[] = { + {.name = "item-clone", + .handler = cmdItemClone, + .opts = opts_item_clone, + .info = info_item_clone, + .flags = 0 + }, + {.name = "item-create-as", + .handler = cmdItemCreateAs, + .opts = opts_item_create_as, + .info = info_item_create_as, + .flags = 0 + }, + {.name = "item-create", + .handler = cmdItemCreate, + .opts = opts_item_create, + .info = info_item_create, + .flags = 0 + }, + {.name = "item-create-from", + .handler = cmdItemCreateFrom, + .opts = opts_item_create_from, + .info = info_item_create_from, + .flags = 0 + }, + {.name = "item-delete", + .handler = cmdItemDelete, + .opts = opts_item_delete, + .info = info_item_delete, + .flags = 0 + }, + {.name = "item-dumpxml", + .handler = cmdItemDumpXML, + .opts = opts_item_dumpxml, + .info = info_item_dumpxml, + .flags = 0 + }, + {.name = "item-info", + .handler = cmdItemInfo, + .opts = opts_item_info, + .info = info_item_info, + .flags = 0 + }, + {.name = "item-key", + .handler = cmdItemKey, + .opts = opts_item_key, + .info = info_item_key, + .flags = 0 + }, + {.name = "item-list", + .handler = cmdItemList, + .opts = opts_item_list, + .info = info_item_list, + .flags = 0 + }, + {.name = "item-name", + .handler = cmdItemName, + .opts = opts_item_name, + .info = info_item_name, + .flags = 0 + }, + {.name = "item-path", + .handler = cmdItemPath, + .opts = opts_item_path, + .info = info_item_path, + .flags = 0 + }, + {.name = "item-fspool", + .handler = cmdItemPool, + .opts = opts_item_fspool, + .info = info_item_fspool, + .flags = 0 + }, + {.name = NULL} +}; diff --git a/tools/virsh-fsitem.h b/tools/virsh-fsitem.h new file mode 100644 index 0000000..0607ac5 --- /dev/null +++ b/tools/virsh-fsitem.h @@ -0,0 +1,39 @@ +/* + * virsh-fsitem.h: Commands to manage fsitems + * + * Copyright (C) 2016 Parallels IP Holdings GmbH + * + * 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 VIRSH_FSITEM_H +# define VIRSH_FSITEM_H + +# include "virsh.h" + +virFSItemPtr virshCommandOptItemBy(vshControl *ctl, const vshCmd *cmd, + const char *optname, + const char *fspooloptname, + const char **name, unsigned int flags); + +/* default is lookup by Name and UUID */ +# define virshCommandOptItem(_ctl, _cmd, _optname, _fspooloptname, _name) \ + virshCommandOptItemBy(_ctl, _cmd, _optname, _fspooloptname, _name, \ + VIRSH_BYUUID | VIRSH_BYNAME) + +extern const vshCmdDef fsItemCmds[]; + +#endif /* VIRSH_FSITEM_H */ diff --git a/tools/virsh-fspool.c b/tools/virsh-fspool.c new file mode 100644 index 0000000..5034fce --- /dev/null +++ b/tools/virsh-fspool.c @@ -0,0 +1,1574 @@ +/* + * virsh-fspool.c: Commands to manage fspool + * + * Copyright (C) 2016 Parallels IP Holdings GmbH + * + * + * 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/>;. + * + * Olga Krishtal <okrishtal(a)virtuozzo.com&gt; + * + */ + +#include <config.h> +#include "virsh-fspool.h" + +#include "internal.h" +#include "virbuffer.h" +#include "viralloc.h" +#include "virfile.h" +#include "conf/fs_conf.h" +#include "virstring.h" + +#define VIRSH_COMMON_OPT_FSPOOL_FULL \ + VIRSH_COMMON_OPT_FSPOOL(N_("fspool name or uuid")) \ + +#define VIRSH_COMMON_OPT_FSPOOL_BUILD \ + {.name = "build", \ + .type = VSH_OT_BOOL, \ + .flags = 0, \ + .help = N_("build the fspool as normal") \ + } \ + +#define VIRSH_COMMON_OPT_FSPOOL_NO_OVERWRITE \ + {.name = "no-overwrite", \ + .type = VSH_OT_BOOL, \ + .flags = 0, \ + .help = N_("do not overwrite an existing fspool of this type") \ + } \ + +#define VIRSH_COMMON_OPT_FSPOOL_OVERWRITE \ + {.name = "overwrite", \ + .type = VSH_OT_BOOL, \ + .flags = 0, \ + .help = N_("overwrite any existing data") \ + } \ + +#define VIRSH_COMMON_OPT_FSPOOL_X_AS \ + {.name = "name", \ + .type = VSH_OT_DATA, \ + .flags = VSH_OFLAG_REQ, \ + .help = N_("name of the fspool") \ + }, \ + {.name = "type", \ + .type = VSH_OT_DATA, \ + .flags = VSH_OFLAG_REQ, \ + .help = N_("type of the fspool") \ + }, \ + {.name = "print-xml", \ + .type = VSH_OT_BOOL, \ + .help = N_("print XML document, but don't define/create") \ + }, \ + {.name = "source-host", \ + .type = VSH_OT_STRING, \ + .help = N_("source-host for underlying storage") \ + }, \ + {.name = "source-path", \ + .type = VSH_OT_STRING, \ + .help = N_("source path for underlying storage") \ + }, \ + {.name = "source-name", \ + .type = VSH_OT_STRING, \ + .help = N_("source name for underlying storage") \ + }, \ + {.name = "target", \ + .type = VSH_OT_STRING, \ + .help = N_("target for underlying storage") \ + }, \ + {.name = "source-format", \ + .type = VSH_OT_STRING, \ + .help = N_("format for underlying storage") \ + } \ + +virFSPoolPtr +virshCommandOptFSPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname, + const char **name, unsigned int flags) +{ + virFSPoolPtr fspool = NULL; + const char *n = NULL; + virshControlPtr priv = ctl->privData; + + virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL); + + if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0) + return NULL; + + vshDebug(ctl, VSH_ERR_INFO, "%s: found option <%s>: %s\n", + cmd->def->name, optname, n); + + if (name) + *name = n; + + /* try it by UUID */ + if ((flags & VIRSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) { + vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as fspool UUID\n", + cmd->def->name, optname); + fspool = virFSPoolLookupByUUIDString(priv->conn, n); + } + /* try it by NAME */ + if (!fspool && (flags & VIRSH_BYNAME)) { + vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as fspool NAME\n", + cmd->def->name, optname); + fspool = virFSPoolLookupByName(priv->conn, n); + } + + if (!fspool) + vshError(ctl, _("failed to get fspool '%s'"), n); + + return fspool; +} + +/* + * "fspool-create" command + */ +static const vshCmdInfo info_fspool_create[] = { + {.name = "help", + .data = N_("create a fspool from an XML file") + }, + {.name = "desc", + .data = N_("Create a fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_create[] = { + VIRSH_COMMON_OPT_FILE(N_("file containing an XML fspool description")), + VIRSH_COMMON_OPT_FSPOOL_BUILD, + VIRSH_COMMON_OPT_FSPOOL_NO_OVERWRITE, + VIRSH_COMMON_OPT_FSPOOL_OVERWRITE, + + {.name = NULL} +}; + +static bool +cmdFSPoolCreate(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + const char *from = NULL; + bool ret = true; + char *buffer; + bool overwrite; + bool no_overwrite; + unsigned int flags = 0; + virshControlPtr priv = ctl->privData; + + if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0) + return false; + + overwrite = vshCommandOptBool(cmd, "overwrite"); + no_overwrite = vshCommandOptBool(cmd, "no-overwrite"); + + VSH_EXCLUSIVE_OPTIONS_EXPR("overwrite", overwrite, + "no-overwrite", no_overwrite); + + if (overwrite) + flags |= VIR_FSPOOL_CREATE_WITH_BUILD_OVERWRITE; + if (no_overwrite) + flags |= VIR_FSPOOL_CREATE_WITH_BUILD_NO_OVERWRITE; + + if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0) + return false; + + fspool = virFSPoolCreateXML(priv->conn, buffer, flags); + VIR_FREE(buffer); + + if (fspool != NULL) { + vshPrint(ctl, _("FSpool %s created from %s\n"), + virFSPoolGetName(fspool), from); + virFSPoolFree(fspool); + } else { + vshError(ctl, _("Failed to create fspool from %s"), from); + ret = false; + } + return ret; +} + +static const vshCmdOptDef opts_fspool_define_as[] = { + VIRSH_COMMON_OPT_FSPOOL_X_AS, + + {.name = NULL} +}; + +static int +virshBuildFSPoolXML(vshControl *ctl, + const vshCmd *cmd, + const char **retname, + char **xml) +{ + const char *name = NULL, *type = NULL, *srcHost = NULL, *srcPath = NULL, + *srcName = NULL, *srcFormat = NULL, *target = NULL; + virBuffer buf = VIR_BUFFER_INITIALIZER; + + if (vshCommandOptStringReq(ctl, cmd, "name", &name) < 0) + goto cleanup; + if (vshCommandOptStringReq(ctl, cmd, "type", &type) < 0) + goto cleanup; + + if (vshCommandOptStringReq(ctl, cmd, "source-host", &srcHost) < 0 || + vshCommandOptStringReq(ctl, cmd, "source-path", &srcPath) < 0 || + vshCommandOptStringReq(ctl, cmd, "source-name", &srcName) < 0 || + vshCommandOptStringReq(ctl, cmd, "source-format", &srcFormat) < 0 || + vshCommandOptStringReq(ctl, cmd, "target", &target) < 0) + goto cleanup; + + virBufferAsprintf(&buf, "<fspool type='%s'>\n", type); + virBufferAdjustIndent(&buf, 2); + virBufferAsprintf(&buf, "<name>%s</name>\n", name); + if (srcHost || srcPath || srcFormat || srcName) { + virBufferAddLit(&buf, "<source>\n"); + virBufferAdjustIndent(&buf, 2); + + if (srcHost) + virBufferAsprintf(&buf, "<host name='%s'/>\n", srcHost); + if (srcPath) + virBufferAsprintf(&buf, "<dir path='%s'/>\n", srcPath); + if (srcFormat) + virBufferAsprintf(&buf, "<format type='%s'/>\n", srcFormat); + if (srcName) + virBufferAsprintf(&buf, "<name>%s</name>\n", srcName); + + virBufferAdjustIndent(&buf, -2); + virBufferAddLit(&buf, "</source>\n"); + } + if (target) { + virBufferAddLit(&buf, "<target>\n"); + virBufferAdjustIndent(&buf, 2); + virBufferAsprintf(&buf, "<path>%s</path>\n", target); + virBufferAdjustIndent(&buf, -2); + virBufferAddLit(&buf, "</target>\n"); + } + virBufferAdjustIndent(&buf, -2); + virBufferAddLit(&buf, "</fspool>\n"); + + if (virBufferError(&buf)) { + vshPrint(ctl, "%s", _("Failed to allocate XML buffer")); + return false; + } + + *xml = virBufferContentAndReset(&buf); + *retname = name; + return true; + + cleanup: + virBufferFreeAndReset(&buf); + return false; +} + +/* + * "fspool-autostart" command + */ +static const vshCmdInfo info_fspool_autostart[] = { + {.name = "help", + .data = N_("autostart a fspool") + }, + {.name = "desc", + .data = N_("Configure a fspool to be automatically started at boot.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_autostart[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = "disable", + .type = VSH_OT_BOOL, + .help = N_("disable autostarting") + }, + {.name = NULL} +}; + +static bool +cmdFSPoolAutostart(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + const char *name; + int autostart; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", &name))) + return false; + + autostart = !vshCommandOptBool(cmd, "disable"); + + if (virFSPoolSetAutostart(fspool, autostart) < 0) { + if (autostart) + vshError(ctl, _("failed to mark fspool %s as autostarted"), name); + else + vshError(ctl, _("failed to unmark fspool %s as autostarted"), name); + virFSPoolFree(fspool); + return false; + } + + if (autostart) + vshPrint(ctl, _("Fspool %s marked as autostarted\n"), name); + else + vshPrint(ctl, _("Fspool %s unmarked as autostarted\n"), name); + + virFSPoolFree(fspool); + return true; +} + +/* + * "fspool-create-as" command + */ +static const vshCmdInfo info_fspool_create_as[] = { + {.name = "help", + .data = N_("create a fspool from a set of args") + }, + {.name = "desc", + .data = N_("Create a fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_create_as[] = { + VIRSH_COMMON_OPT_FSPOOL_X_AS, + VIRSH_COMMON_OPT_FSPOOL_BUILD, + VIRSH_COMMON_OPT_FSPOOL_NO_OVERWRITE, + VIRSH_COMMON_OPT_FSPOOL_OVERWRITE, + + {.name = NULL} +}; + +static bool +cmdFSPoolCreateAs(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + const char *name; + char *xml; + bool printXML = vshCommandOptBool(cmd, "print-xml"); + bool overwrite; + bool no_overwrite; + unsigned int flags = 0; + virshControlPtr priv = ctl->privData; + + overwrite = vshCommandOptBool(cmd, "overwrite"); + no_overwrite = vshCommandOptBool(cmd, "no-overwrite"); + + VSH_EXCLUSIVE_OPTIONS_EXPR("overwrite", overwrite, + "no-overwrite", no_overwrite); + + if (overwrite) + flags |= VIR_FSPOOL_CREATE_WITH_BUILD_OVERWRITE; + if (no_overwrite) + flags |= VIR_FSPOOL_CREATE_WITH_BUILD_NO_OVERWRITE; + + if (!virshBuildFSPoolXML(ctl, cmd, &name, &xml)) + return false; + + if (printXML) { + vshPrint(ctl, "%s", xml); + VIR_FREE(xml); + } else { + fspool = virFSPoolCreateXML(priv->conn, xml, flags); + VIR_FREE(xml); + + if (fspool != NULL) { + vshPrint(ctl, _("FSool %s created\n"), name); + virFSPoolFree(fspool); + } else { + vshError(ctl, _("Failed to create fspool %s"), name); + return false; + } + } + return true; +} + +/* + * "fspool-define" command + */ +static const vshCmdInfo info_fspool_define[] = { + {.name = "help", + .data = N_("define an inactive persistent fspool or modify " + "an existing persistent one from an XML file") + }, + {.name = "desc", + .data = N_("Define or modify a persistent fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_define[] = { + VIRSH_COMMON_OPT_FILE(N_("file containing an XML fspool description")), + + {.name = NULL} +}; + +static bool +cmdFSPoolDefine(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + const char *from = NULL; + bool ret = true; + char *buffer; + virshControlPtr priv = ctl->privData; + + if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0) + return false; + + if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0) + return false; + + fspool = virFSPoolDefineXML(priv->conn, buffer, 0); + VIR_FREE(buffer); + + if (fspool != NULL) { + vshPrint(ctl, _("FSool %s defined from %s\n"), + virFSPoolGetName(fspool), from); + virFSPoolFree(fspool); + } else { + vshError(ctl, _("Failed to define fspool from %s"), from); + ret = false; + } + return ret; +} + +/* + * "fspool-define-as" command + */ +static const vshCmdInfo info_fspool_define_as[] = { + {.name = "help", + .data = N_("define a fspool from a set of args") + }, + {.name = "desc", + .data = N_("Define a fspool.") + }, + {.name = NULL} +}; + +static bool +cmdFSPoolDefineAs(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + const char *name; + char *xml; + bool printXML = vshCommandOptBool(cmd, "print-xml"); + virshControlPtr priv = ctl->privData; + + if (!virshBuildFSPoolXML(ctl, cmd, &name, &xml)) + return false; + + if (printXML) { + vshPrint(ctl, "%s", xml); + VIR_FREE(xml); + } else { + fspool = virFSPoolDefineXML(priv->conn, xml, 0); + VIR_FREE(xml); + + if (fspool != NULL) { + vshPrint(ctl, _("FSpool %s defined\n"), name); + virFSPoolFree(fspool); + } else { + vshError(ctl, _("Failed to define fspool %s"), name); + return false; + } + } + return true; +} + +/* + * "fspool-build" command + */ +static const vshCmdInfo info_fspool_build[] = { + {.name = "help", + .data = N_("build a fspool") + }, + {.name = "desc", + .data = N_("Build a given fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_build[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + VIRSH_COMMON_OPT_FSPOOL_NO_OVERWRITE, + VIRSH_COMMON_OPT_FSPOOL_OVERWRITE, + + {.name = NULL} +}; + +static bool +cmdFSPoolBuild(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + bool ret = true; + const char *name; + unsigned int flags = 0; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", &name))) + return false; + + if (vshCommandOptBool(cmd, "no-overwrite")) + flags |= VIR_FSPOOL_BUILD_NO_OVERWRITE; + + if (vshCommandOptBool(cmd, "overwrite")) + flags |= VIR_FSPOOL_BUILD_OVERWRITE; + + if (virFSPoolBuild(fspool, flags) == 0) { + vshPrint(ctl, _("FSpool %s built\n"), name); + } else { + vshError(ctl, _("Failed to build fspool %s"), name); + ret = false; + } + + virFSPoolFree(fspool); + + return ret; +} + +/* + * "fspool-destroy" command + */ +static const vshCmdInfo info_fspool_destroy[] = { + {.name = "help", + .data = N_("stop a fspool") + }, + {.name = "desc", + .data = N_("Forcefully stop a given fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_destroy[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = NULL} +}; + +static bool +cmdFSPoolDestroy(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + bool ret = true; + const char *name; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", &name))) + return false; + + if (virFSPoolDestroy(fspool) == 0) { + vshPrint(ctl, _("FSpool %s destroyed\n"), name); + } else { + vshError(ctl, _("Failed to destroy fspool %s"), name); + ret = false; + } + + virFSPoolFree(fspool); + return ret; +} + +/* + * "fspool-delete" command + */ +static const vshCmdInfo info_fspool_delete[] = { + {.name = "help", + .data = N_("delete a fspool") + }, + {.name = "desc", + .data = N_("Delete a given fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_delete[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = NULL} +}; + +static bool +cmdFSPoolDelete(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + bool ret = true; + const char *name; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", &name))) + return false; + + if (virFSPoolDelete(fspool, 0) == 0) { + vshPrint(ctl, _("Pool %s deleted\n"), name); + } else { + vshError(ctl, _("Failed to delete fspool %s"), name); + ret = false; + } + + virFSPoolFree(fspool); + return ret; +} + +/* + * "fspool-refresh" command + */ +static const vshCmdInfo info_fspool_refresh[] = { + {.name = "help", + .data = N_("refresh a fspool") + }, + {.name = "desc", + .data = N_("Refresh a given fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_refresh[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = NULL} +}; + +static bool +cmdFSPoolRefresh(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + bool ret = true; + const char *name; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", &name))) + return false; + + if (virFSPoolRefresh(fspool, 0) == 0) { + vshPrint(ctl, _("Pool %s refreshed\n"), name); + } else { + vshError(ctl, _("Failed to refresh fspool %s"), name); + ret = false; + } + virFSPoolFree(fspool); + + return ret; +} + +/* + * "fspool-dumpxml" command + */ +static const vshCmdInfo info_fspool_dumpxml[] = { + {.name = "help", + .data = N_("fspool information in XML") + }, + {.name = "desc", + .data = N_("Output the fspool information as an XML dump to stdout.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_dumpxml[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = "inactive", + .type = VSH_OT_BOOL, + .help = N_("show inactive defined XML") + }, + {.name = NULL} +}; + +static bool +cmdFSPoolDumpXML(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + bool ret = true; + bool inactive = vshCommandOptBool(cmd, "inactive"); + unsigned int flags = 0; + char *dump; + + if (inactive) + flags |= VIR_FS_XML_INACTIVE; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", NULL))) + return false; + + dump = virFSPoolGetXMLDesc(fspool, flags); + if (dump != NULL) { + vshPrint(ctl, "%s", dump); + VIR_FREE(dump); + } else { + ret = false; + } + + virFSPoolFree(fspool); + return ret; +} + +static int +virshFSPoolSorter(const void *a, const void *b) +{ + virFSPoolPtr *pa = (virFSPoolPtr *) a; + virFSPoolPtr *pb = (virFSPoolPtr *) b; + + if (*pa && !*pb) + return -1; + + if (!*pa) + return *pb != NULL; + + return vshStrcasecmp(virFSPoolGetName(*pa), + virFSPoolGetName(*pb)); +} + +struct virshFSPoolList { + virFSPoolPtr *fspools; + size_t nfspools; +}; +typedef struct virshFSPoolList *virshFSPoolListPtr; + +static void +virshFSPoolListFree(virshFSPoolListPtr list) +{ + size_t i; + + if (list && list->fspools) { + for (i = 0; i < list->nfspools; i++) { + if (list->fspools[i]) + virFSPoolFree(list->fspools[i]); + } + VIR_FREE(list->fspools); + } + VIR_FREE(list); +} + +static virshFSPoolListPtr +virshFSPoolListCollect(vshControl *ctl, + unsigned int flags) +{ + virshFSPoolListPtr list = vshMalloc(ctl, sizeof(*list)); + int ret; + virshControlPtr priv = ctl->privData; + + /* try the list with flags support (0.10.2 and later) */ + if ((ret = virConnectListAllFSPools(priv->conn, + &list->fspools, + flags)) < 0) { + vshError(ctl, "%s", _("Failed to list fspools")); + return NULL; + } + + list->nfspools = ret; + + /* sort the list */ + if (list->fspools && list->nfspools) + qsort(list->fspools, list->nfspools, + sizeof(*list->fspools), virshFSPoolSorter); + + return list; +} + + +VIR_ENUM_DECL(virshFSPoolState) +VIR_ENUM_IMPL(virshFSPoolState, + VIR_FSPOOL_STATE_LAST, + N_("inactive"), + N_("building"), + N_("running")) + +static const char * +virshFSPoolStateToString(int state) +{ + const char *str = virshFSPoolStateTypeToString(state); + return str ? _(str) : _("unknown"); +} + + +/* + * "fspool-list" command + */ +static const vshCmdInfo info_fspool_list[] = { + {.name = "help", + .data = N_("list fspools") + }, + {.name = "desc", + .data = N_("Returns list of fspools.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_list[] = { + {.name = "inactive", + .type = VSH_OT_BOOL, + .help = N_("list inactive fspools") + }, + {.name = "all", + .type = VSH_OT_BOOL, + .help = N_("list inactive & active fspools") + }, + {.name = "transient", + .type = VSH_OT_BOOL, + .help = N_("list transient fspools") + }, + {.name = "persistent", + .type = VSH_OT_BOOL, + .help = N_("list persistent fspools") + }, + {.name = "autostart", + .type = VSH_OT_BOOL, + .help = N_("list fspools with autostart enabled") + }, + {.name = "no-autostart", + .type = VSH_OT_BOOL, + .help = N_("list fspools with autostart disabled") + }, + {.name = "type", + .type = VSH_OT_STRING, + .help = N_("only list fspool of specified type(s) (if supported)") + }, + {.name = "details", + .type = VSH_OT_BOOL, + .help = N_("display extended details for fspools") + }, + {.name = NULL} +}; + +static bool +cmdFSPoolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED) +{ + virFSPoolInfo info; + size_t i; + bool ret = false; + size_t stringLength = 0, nameStrLength = 0; + size_t autostartStrLength = 0, persistStrLength = 0; + size_t stateStrLength = 0, capStrLength = 0; + size_t allocStrLength = 0, availStrLength = 0; + struct fspoolInfoText { + char *state; + char *autostart; + char *persistent; + char *capacity; + char *allocation; + char *available; + }; + struct fspoolInfoText *fspoolInfoTexts = NULL; + unsigned int flags = VIR_CONNECT_LIST_FSPOOLS_ACTIVE; + virshFSPoolListPtr list = NULL; + const char *type = NULL; + bool details = vshCommandOptBool(cmd, "details"); + bool inactive, all; + char *outputStr = NULL; + + inactive = vshCommandOptBool(cmd, "inactive"); + all = vshCommandOptBool(cmd, "all"); + + if (inactive) + flags = VIR_CONNECT_LIST_FSPOOLS_INACTIVE; + + if (all) + flags = VIR_CONNECT_LIST_FSPOOLS_ACTIVE | + VIR_CONNECT_LIST_FSPOOLS_INACTIVE; + + if (vshCommandOptBool(cmd, "autostart")) + flags |= VIR_CONNECT_LIST_FSPOOLS_AUTOSTART; + + if (vshCommandOptBool(cmd, "no-autostart")) + flags |= VIR_CONNECT_LIST_FSPOOLS_NO_AUTOSTART; + + if (vshCommandOptBool(cmd, "persistent")) + flags |= VIR_CONNECT_LIST_FSPOOLS_PERSISTENT; + + if (vshCommandOptBool(cmd, "transient")) + flags |= VIR_CONNECT_LIST_FSPOOLS_TRANSIENT; + + if (vshCommandOptStringReq(ctl, cmd, "type", &type) < 0) + return false; + + if (type) { + int fspoolType = -1; + char **fspoolTypes = NULL; + int nfspoolTypes = 0; + + if ((nfspoolTypes = vshStringToArray(type, &fspoolTypes)) < 0) + return false; + + for (i = 0; i < nfspoolTypes; i++) { + if ((fspoolType = virFSPoolTypeFromString(fspoolTypes[i])) < 0) { + vshError(ctl, _("Invalid fspool type '%s'"), fspoolTypes[i]); + virStringFreeList(fspoolTypes); + return false; + } + + switch ((virFSPoolType) fspoolType) { + case VIR_FSPOOL_DIR: + flags |= VIR_CONNECT_LIST_FSPOOLS_DIR; + break; + case VIR_FSPOOL_LAST: + break; + } + } + virStringFreeList(fspoolTypes); + } + + if (!(list = virshFSPoolListCollect(ctl, flags))) + goto cleanup; + + fspoolInfoTexts = vshCalloc(ctl, list->nfspools, sizeof(*fspoolInfoTexts)); + + /* Collect the storage fspool information for display */ + for (i = 0; i < list->nfspools; i++) { + int autostart = 0, persistent = 0; + + /* Retrieve the autostart status of the fspool */ + if (virFSPoolGetAutostart(list->fspools[i], &autostart) < 0) + fspoolInfoTexts[i].autostart = vshStrdup(ctl, _("no autostart")); + else + fspoolInfoTexts[i].autostart = vshStrdup(ctl, autostart ? + _("yes") : _("no")); + + /* Retrieve the persistence status of the fspool */ + if (details) { + persistent = virFSPoolIsPersistent(list->fspools[i]); + vshDebug(ctl, VSH_ERR_DEBUG, "Persistent flag value: %d\n", + persistent); + if (persistent < 0) + fspoolInfoTexts[i].persistent = vshStrdup(ctl, _("unknown")); + else + fspoolInfoTexts[i].persistent = vshStrdup(ctl, persistent ? + _("yes") : _("no")); + + /* Keep the length of persistent string if longest so far */ + stringLength = strlen(fspoolInfoTexts[i].persistent); + if (stringLength > persistStrLength) + persistStrLength = stringLength; + } + + /* Collect further extended information about the fspool */ + if (virFSPoolGetInfo(list->fspools[i], &info) != 0) { + /* Something went wrong retrieving fspool info, cope with it */ + vshError(ctl, "%s", _("Could not retrieve fspool information")); + fspoolInfoTexts[i].state = vshStrdup(ctl, _("unknown")); + if (details) { + fspoolInfoTexts[i].capacity = vshStrdup(ctl, _("unknown")); + fspoolInfoTexts[i].allocation = vshStrdup(ctl, _("unknown")); + fspoolInfoTexts[i].available = vshStrdup(ctl, _("unknown")); + } + } else { + /* Decide which state string to display */ + if (details) { + const char *state = virshFSPoolStateToString(info.state); + + fspoolInfoTexts[i].state = vshStrdup(ctl, state); + + /* Create the fspool size related strings */ + if (info.state == VIR_FSPOOL_RUNNING) { + double val; + const char *unit; + + val = vshPrettyCapacity(info.capacity, &unit); + if (virAsprintf(&fspoolInfoTexts[i].capacity, + "%.2lf %s", val, unit) < 0) + goto cleanup; + + val = vshPrettyCapacity(info.allocation, &unit); + if (virAsprintf(&fspoolInfoTexts[i].allocation, + "%.2lf %s", val, unit) < 0) + goto cleanup; + + val = vshPrettyCapacity(info.available, &unit); + if (virAsprintf(&fspoolInfoTexts[i].available, + "%.2lf %s", val, unit) < 0) + goto cleanup; + } else { + /* Capacity related information isn't available */ + fspoolInfoTexts[i].capacity = vshStrdup(ctl, _("-")); + fspoolInfoTexts[i].allocation = vshStrdup(ctl, _("-")); + fspoolInfoTexts[i].available = vshStrdup(ctl, _("-")); + } + + /* Keep the length of capacity string if longest so far */ + stringLength = strlen(fspoolInfoTexts[i].capacity); + if (stringLength > capStrLength) + capStrLength = stringLength; + + /* Keep the length of allocation string if longest so far */ + stringLength = strlen(fspoolInfoTexts[i].allocation); + if (stringLength > allocStrLength) + allocStrLength = stringLength; + + /* Keep the length of available string if longest so far */ + stringLength = strlen(fspoolInfoTexts[i].available); + if (stringLength > availStrLength) + availStrLength = stringLength; + } else { + /* --details option was not specified, only active/inactive + * state strings are used */ + if (virFSPoolIsActive(list->fspools[i])) + fspoolInfoTexts[i].state = vshStrdup(ctl, _("active")); + else + fspoolInfoTexts[i].state = vshStrdup(ctl, _("inactive")); + } + } + + /* Keep the length of name string if longest so far */ + stringLength = strlen(virFSPoolGetName(list->fspools[i])); + if (stringLength > nameStrLength) + nameStrLength = stringLength; + + /* Keep the length of state string if longest so far */ + stringLength = strlen(fspoolInfoTexts[i].state); + if (stringLength > stateStrLength) + stateStrLength = stringLength; + + /* Keep the length of autostart string if longest so far */ + stringLength = strlen(fspoolInfoTexts[i].autostart); + if (stringLength > autostartStrLength) + autostartStrLength = stringLength; + } + + /* If the --details option wasn't selected, we output the fspool + * info using the fixed string format from previous versions to + * maintain backward compatibility. + */ + + /* Output basic info then return if --details option not selected */ + if (!details) { + /* Output old style header */ + vshPrintExtra(ctl, " %-20s %-10s %-10s\n", _("Name"), _("State"), + _("Autostart")); + vshPrintExtra(ctl, "-------------------------------------------\n"); + + /* Output old style fspool info */ + for (i = 0; i < list->nfspools; i++) { + const char *name = virFSPoolGetName(list->fspools[i]); + vshPrint(ctl, " %-20s %-10s %-10s\n", + name, + fspoolInfoTexts[i].state, + fspoolInfoTexts[i].autostart); + } + + /* Cleanup and return */ + ret = true; + goto cleanup; + } + + /* We only get here if the --details option was selected. */ + + /* Use the length of name header string if it's longest */ + stringLength = strlen(_("Name")); + if (stringLength > nameStrLength) + nameStrLength = stringLength; + + /* Use the length of state header string if it's longest */ + stringLength = strlen(_("State")); + if (stringLength > stateStrLength) + stateStrLength = stringLength; + + /* Use the length of autostart header string if it's longest */ + stringLength = strlen(_("Autostart")); + if (stringLength > autostartStrLength) + autostartStrLength = stringLength; + + /* Use the length of persistent header string if it's longest */ + stringLength = strlen(_("Persistent")); + if (stringLength > persistStrLength) + persistStrLength = stringLength; + + /* Use the length of capacity header string if it's longest */ + stringLength = strlen(_("Capacity")); + if (stringLength > capStrLength) + capStrLength = stringLength; + + /* Use the length of allocation header string if it's longest */ + stringLength = strlen(_("Allocation")); + if (stringLength > allocStrLength) + allocStrLength = stringLength; + + /* Use the length of available header string if it's longest */ + stringLength = strlen(_("Available")); + if (stringLength > availStrLength) + availStrLength = stringLength; + + /* Display the string lengths for debugging. */ + vshDebug(ctl, VSH_ERR_DEBUG, "Longest name string = %lu chars\n", + (unsigned long) nameStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, "Longest state string = %lu chars\n", + (unsigned long) stateStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, "Longest autostart string = %lu chars\n", + (unsigned long) autostartStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, "Longest persistent string = %lu chars\n", + (unsigned long) persistStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, "Longest capacity string = %lu chars\n", + (unsigned long) capStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, "Longest allocation string = %lu chars\n", + (unsigned long) allocStrLength); + vshDebug(ctl, VSH_ERR_DEBUG, "Longest available string = %lu chars\n", + (unsigned long) availStrLength); + + /* Create the output template. Each column is sized according to + * the longest string. + */ + if (virAsprintf(&outputStr, + " %%-%lus %%-%lus %%-%lus %%-%lus %%%lus %%%lus %%%lus\n", + (unsigned long) nameStrLength, + (unsigned long) stateStrLength, + (unsigned long) autostartStrLength, + (unsigned long) persistStrLength, + (unsigned long) capStrLength, + (unsigned long) allocStrLength, + (unsigned long) availStrLength) < 0) + goto cleanup; + + /* Display the header */ + vshPrint(ctl, outputStr, _("Name"), _("State"), _("Autostart"), + _("Persistent"), _("Capacity"), _("Allocation"), _("Available")); + for (i = nameStrLength + stateStrLength + autostartStrLength + + persistStrLength + capStrLength + + allocStrLength + availStrLength + + 14; i > 0; i--) + vshPrintExtra(ctl, "-"); + vshPrintExtra(ctl, "\n"); + + /* Display the fspool info rows */ + for (i = 0; i < list->nfspools; i++) { + vshPrint(ctl, outputStr, + virFSPoolGetName(list->fspools[i]), + fspoolInfoTexts[i].state, + fspoolInfoTexts[i].autostart, + fspoolInfoTexts[i].persistent, + fspoolInfoTexts[i].capacity, + fspoolInfoTexts[i].allocation, + fspoolInfoTexts[i].available); + } + + /* Cleanup and return */ + ret = true; + + cleanup: + VIR_FREE(outputStr); + if (list && list->nfspools) { + for (i = 0; i < list->nfspools; i++) { + VIR_FREE(fspoolInfoTexts[i].state); + VIR_FREE(fspoolInfoTexts[i].autostart); + VIR_FREE(fspoolInfoTexts[i].persistent); + VIR_FREE(fspoolInfoTexts[i].capacity); + VIR_FREE(fspoolInfoTexts[i].allocation); + VIR_FREE(fspoolInfoTexts[i].available); + } + } + VIR_FREE(fspoolInfoTexts); + + virshFSPoolListFree(list); + return ret; +} + +/* + * "fspool-info" command + */ +static const vshCmdInfo info_fspool_info[] = { + {.name = "help", + .data = N_("storage fspool information") + }, + {.name = "desc", + .data = N_("Returns basic information about the storage fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_info[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = NULL} +}; + +static bool +cmdFSPoolInfo(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolInfo info; + virFSPoolPtr fspool; + int autostart = 0; + int persistent = 0; + bool ret = true; + char uuid[VIR_UUID_STRING_BUFLEN]; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", NULL))) + return false; + + vshPrint(ctl, "%-15s %s\n", _("Name:"), virFSPoolGetName(fspool)); + + if (virFSPoolGetUUIDString(fspool, &uuid[0]) == 0) + vshPrint(ctl, "%-15s %s\n", _("UUID:"), uuid); + + if (virFSPoolGetInfo(fspool, &info) == 0) { + double val; + const char *unit; + vshPrint(ctl, "%-15s %s\n", _("State:"), + virshFSPoolStateToString(info.state)); + + /* Check and display whether the fspool is persistent or not */ + persistent = virFSPoolIsPersistent(fspool); + vshDebug(ctl, VSH_ERR_DEBUG, "Pool persistent flag value: %d\n", + persistent); + if (persistent < 0) + vshPrint(ctl, "%-15s %s\n", _("Persistent:"), _("unknown")); + else + vshPrint(ctl, "%-15s %s\n", _("Persistent:"), persistent ? _("yes") : _("no")); + + /* Check and display whether the fspool is autostarted or not */ + if (virFSPoolGetAutostart(fspool, &autostart) < 0) + vshPrint(ctl, "%-15s %s\n", _("Autostart:"), _("no autostart")); + else + vshPrint(ctl, "%-15s %s\n", _("Autostart:"), autostart ? _("yes") : _("no")); + + if (info.state == VIR_FSPOOL_RUNNING) { + val = vshPrettyCapacity(info.capacity, &unit); + vshPrint(ctl, "%-15s %2.2lf %s\n", _("Capacity:"), val, unit); + + val = vshPrettyCapacity(info.allocation, &unit); + vshPrint(ctl, "%-15s %2.2lf %s\n", _("Allocation:"), val, unit); + + val = vshPrettyCapacity(info.available, &unit); + vshPrint(ctl, "%-15s %2.2lf %s\n", _("Available:"), val, unit); + } + } else { + ret = false; + } + + virFSPoolFree(fspool); + return ret; +} + +/* + * "fspool-name" command + */ +static const vshCmdInfo info_fspool_name[] = { + {.name = "help", + .data = N_("convert a fspool UUID to fspool name") + }, + {.name = "desc", + .data = "" + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_name[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = NULL} +}; + +static bool +cmdFSPoolName(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + + if (!(fspool = virshCommandOptFSPoolBy(ctl, cmd, "fspool", NULL, VIRSH_BYUUID))) + return false; + + vshPrint(ctl, "%s\n", virFSPoolGetName(fspool)); + virFSPoolFree(fspool); + return true; +} + +/* + * "fspool-start" command + */ +static const vshCmdInfo info_fspool_start[] = { + {.name = "help", + .data = N_("start a (previously defined) inactive fspool") + }, + {.name = "desc", + .data = N_("Start a fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_start[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + VIRSH_COMMON_OPT_FSPOOL_BUILD, + VIRSH_COMMON_OPT_FSPOOL_NO_OVERWRITE, + VIRSH_COMMON_OPT_FSPOOL_OVERWRITE, + + {.name = NULL} +}; + +static bool +cmdFSPoolStart(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + bool ret = true; + const char *name = NULL; + bool overwrite; + bool no_overwrite; + unsigned int flags = 0; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", &name))) + return false; + + overwrite = vshCommandOptBool(cmd, "overwrite"); + no_overwrite = vshCommandOptBool(cmd, "no-overwrite"); + + VSH_EXCLUSIVE_OPTIONS_EXPR("overwrite", overwrite, + "no-overwrite", no_overwrite); + + if (overwrite) + flags |= VIR_FSPOOL_CREATE_WITH_BUILD_OVERWRITE; + if (no_overwrite) + flags |= VIR_FSPOOL_CREATE_WITH_BUILD_NO_OVERWRITE; + + if (virFSPoolCreate(fspool, flags) == 0) { + vshPrint(ctl, _("FSpool %s started\n"), name); + } else { + vshError(ctl, _("Failed to start fspool %s"), name); + ret = false; + } + + virFSPoolFree(fspool); + return ret; +} + +/* + * "fspool-undefine" command + */ +static const vshCmdInfo info_fspool_undefine[] = { + {.name = "help", + .data = N_("undefine an inactive fspool") + }, + {.name = "desc", + .data = N_("Undefine the configuration for an inactive fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_undefine[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = NULL} +}; + +static bool +cmdFSPoolUndefine(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + bool ret = true; + const char *name; + + if (!(fspool = virshCommandOptFSPool(ctl, cmd, "fspool", &name))) + return false; + + if (virFSPoolUndefine(fspool) == 0) { + vshPrint(ctl, _("Pool %s has been undefined\n"), name); + } else { + vshError(ctl, _("Failed to undefine fspool %s"), name); + ret = false; + } + + virFSPoolFree(fspool); + return ret; +} + +/* + * "fspool-uuid" command + */ +static const vshCmdInfo info_fspool_uuid[] = { + {.name = "help", + .data = N_("convert a fspool name to fspool UUID") + }, + {.name = "desc", + .data = "" + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_uuid[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = NULL} +}; + +static bool +cmdFSPoolUuid(vshControl *ctl, const vshCmd *cmd) +{ + virFSPoolPtr fspool; + char uuid[VIR_UUID_STRING_BUFLEN]; + + if (!(fspool = virshCommandOptFSPoolBy(ctl, cmd, "fspool", NULL, VIRSH_BYNAME))) + return false; + + if (virFSPoolGetUUIDString(fspool, uuid) != -1) + vshPrint(ctl, "%s\n", uuid); + else + vshError(ctl, "%s", _("failed to get fspool UUID")); + + virFSPoolFree(fspool); + return true; +} + +/* + * "fspool-edit" command + */ +static const vshCmdInfo info_fspool_edit[] = { + {.name = "help", + .data = N_("edit XML configuration for a fspool") + }, + {.name = "desc", + .data = N_("Edit the XML configuration for a fspool.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_fspool_edit[] = { + VIRSH_COMMON_OPT_FSPOOL_FULL, + + {.name = NULL} +}; + +static bool +cmdFSPoolEdit(vshControl *ctl, const vshCmd *cmd) +{ + bool ret = false; + virFSPoolPtr fspool = NULL; + virFSPoolPtr fspool_edited = NULL; + unsigned int flags = VIR_FS_XML_INACTIVE; + char *tmp_desc = NULL; + virshControlPtr priv = ctl->privData; + + fspool = virshCommandOptFSPool(ctl, cmd, "fspool", NULL); + if (fspool == NULL) + goto cleanup; + + /* Some old daemons don't support _INACTIVE flag */ + if (!(tmp_desc = virFSPoolGetXMLDesc(fspool, flags))) { + if (last_error->code == VIR_ERR_INVALID_ARG) { + flags &= ~VIR_FS_XML_INACTIVE; + vshResetLibvirtError(); + } else { + goto cleanup; + } + } else { + VIR_FREE(tmp_desc); + } + +#define EDIT_GET_XML virFSPoolGetXMLDesc(fspool, flags) +#define EDIT_NOT_CHANGED \ + do { \ + vshPrint(ctl, _("Pool %s XML configuration not changed.\n"), \ + virFSPoolGetName(fspool)); \ + ret = true; \ + goto edit_cleanup; \ + } while (0) +#define EDIT_DEFINE \ + (fspool_edited = virFSPoolDefineXML(priv->conn, doc_edited, 0)) +#include "virsh-edit.c" + + vshPrint(ctl, _("Pool %s XML configuration edited.\n"), + virFSPoolGetName(fspool_edited)); + + ret = true; + + cleanup: + if (fspool) + virFSPoolFree(fspool); + if (fspool_edited) + virFSPoolFree(fspool_edited); + + return ret; +} + +const vshCmdDef fsPoolCmds[] = { + {.name = "fspool-autostart", + .handler = cmdFSPoolAutostart, + .opts = opts_fspool_autostart, + .info = info_fspool_autostart, + .flags = 0 + }, + {.name = "fspool-build", + .handler = cmdFSPoolBuild, + .opts = opts_fspool_build, + .info = info_fspool_build, + .flags = 0 + }, + {.name = "fspool-create-as", + .handler = cmdFSPoolCreateAs, + .opts = opts_fspool_create_as, + .info = info_fspool_create_as, + .flags = 0 + }, + {.name = "fspool-create", + .handler = cmdFSPoolCreate, + .opts = opts_fspool_create, + .info = info_fspool_create, + .flags = 0 + }, + {.name = "fspool-define-as", + .handler = cmdFSPoolDefineAs, + .opts = opts_fspool_define_as, + .info = info_fspool_define_as, + .flags = 0 + }, + {.name = "fspool-define", + .handler = cmdFSPoolDefine, + .opts = opts_fspool_define, + .info = info_fspool_define, + .flags = 0 + }, + {.name = "fspool-delete", + .handler = cmdFSPoolDelete, + .opts = opts_fspool_delete, + .info = info_fspool_delete, + .flags = 0 + }, + {.name = "fspool-destroy", + .handler = cmdFSPoolDestroy, + .opts = opts_fspool_destroy, + .info = info_fspool_destroy, + .flags = 0 + }, + {.name = "fspool-dumpxml", + .handler = cmdFSPoolDumpXML, + .opts = opts_fspool_dumpxml, + .info = info_fspool_dumpxml, + .flags = 0 + }, + {.name = "fspool-edit", + .handler = cmdFSPoolEdit, + .opts = opts_fspool_edit, + .info = info_fspool_edit, + .flags = 0 + }, + {.name = "fspool-info", + .handler = cmdFSPoolInfo, + .opts = opts_fspool_info, + .info = info_fspool_info, + .flags = 0 + }, + {.name = "fspool-list", + .handler = cmdFSPoolList, + .opts = opts_fspool_list, + .info = info_fspool_list, + .flags = 0 + }, + {.name = "fspool-name", + .handler = cmdFSPoolName, + .opts = opts_fspool_name, + .info = info_fspool_name, + .flags = 0 + }, + {.name = "fspool-refresh", + .handler = cmdFSPoolRefresh, + .opts = opts_fspool_refresh, + .info = info_fspool_refresh, + .flags = 0 + }, + {.name = "fspool-undefine", + .handler = cmdFSPoolUndefine, + .opts = opts_fspool_undefine, + .info = info_fspool_undefine, + .flags = 0 + }, + {.name = "fspool-uuid", + .handler = cmdFSPoolUuid, + .opts = opts_fspool_uuid, + .info = info_fspool_uuid, + .flags = 0 + }, + {.name = "fspool-start", + .handler = cmdFSPoolStart, + .opts = opts_fspool_start, + .info = info_fspool_start, + .flags = 0 + }, + {.name = NULL} +}; diff --git a/tools/virsh-fspool.h b/tools/virsh-fspool.h new file mode 100644 index 0000000..9eb60f1 --- /dev/null +++ b/tools/virsh-fspool.h @@ -0,0 +1,38 @@ +/* + * virsh-fspool.h: Commands to manage fspool + * + * Copyright (C) 2016 Parallels IP Holdings GmbH + * + * 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 VIRSH_FSPOOL_H +# define VIRSH_FSPOOL_H + +# include "virsh.h" + +virFSPoolPtr +virshCommandOptFSPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname, + const char **name, unsigned int flags); + +/* default is lookup by Name and UUID */ +# define virshCommandOptFSPool(_ctl, _cmd, _optname, _name) \ + virshCommandOptFSPoolBy(_ctl, _cmd, _optname, _name, \ + VIRSH_BYUUID | VIRSH_BYNAME) + +extern const vshCmdDef fsPoolCmds[]; + +#endif /* VIRSH_FSPOOL_H */ diff --git a/tools/virsh.c b/tools/virsh.c index 1068447..7d7e619 100644 --- a/tools/virsh.c +++ b/tools/virsh.c @@ -68,9 +68,11 @@ #include "virsh-nodedev.h" #include "virsh-nwfilter.h" #include "virsh-pool.h" +#include "virsh-fspool.h" #include "virsh-secret.h" #include "virsh-snapshot.h" #include "virsh-volume.h" +#include "virsh-fsitem.h" /* Gnulib doesn't guarantee SA_SIGINFO support. */ #ifndef SA_SIGINFO @@ -878,6 +880,8 @@ static const vshCmdGrp cmdGroups[] = { {VIRSH_CMD_GRP_SNAPSHOT, "snapshot", snapshotCmds}, {VIRSH_CMD_GRP_STORAGE_POOL, "pool", storagePoolCmds}, {VIRSH_CMD_GRP_STORAGE_VOL, "volume", storageVolCmds}, + {VIRSH_CMD_GRP_FSPOOL, "fspool", fsPoolCmds}, + {VIRSH_CMD_GRP_FSITEM, "item", fsItemCmds}, {VIRSH_CMD_GRP_VIRSH, "virsh", virshCmds}, {NULL, NULL, NULL} }; diff --git a/tools/virsh.h b/tools/virsh.h index fd552bb..5b7a636 100644 --- a/tools/virsh.h +++ b/tools/virsh.h @@ -51,6 +51,8 @@ # define VIRSH_CMD_GRP_DOM_MONITORING "Domain Monitoring" # define VIRSH_CMD_GRP_STORAGE_POOL "Storage Pool" # define VIRSH_CMD_GRP_STORAGE_VOL "Storage Volume" +# define VIRSH_CMD_GRP_FSPOOL "Fspool" +# define VIRSH_CMD_GRP_FSITEM "Item" # define VIRSH_CMD_GRP_NETWORK "Networking" # define VIRSH_CMD_GRP_NODEDEV "Node Device" # define VIRSH_CMD_GRP_IFACE "Interface" @@ -70,6 +72,13 @@ .help = _helpstr \ } \ +# define VIRSH_COMMON_OPT_FSPOOL(_helpstr) \ + {.name = "fspool", \ + .type = VSH_OT_DATA, \ + .flags = VSH_OFLAG_REQ, \ + .help = _helpstr \ + } + # define VIRSH_COMMON_OPT_DOMAIN(_helpstr) \ {.name = "domain", \ .type = VSH_OT_DATA, \ diff --git a/tools/virsh.pod b/tools/virsh.pod index f278fec..1181391 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -699,7 +699,7 @@ Immediately terminate the domain I<domain>. This doesn't give the domain OS any chance to react, and it's the equivalent of ripping the power cord out on a physical machine. In most cases you will want to use the B<shutdown> command instead. However, this does not delete any -storage volumes used by the guest, and if the domain is persistent, it +storage volumes or fspool items used by the guest, and if the domain is persistent, it can be restarted later. If I<domain> is transient, then the metadata of any snapshots will @@ -3904,6 +3904,256 @@ B<blockresize> for live resizing. =back +=head1 FSPOOL COMMANDS + +The following commands manipulate filesystem pools. Many of the commands +for filesystem pools are similar to the ones used for storage pools. + +=over 4 + +=item B<fspool-autostart> I<pool-or-uuid> [I<--disable>] + +Configure whether I<fspool> should automatically start at boot. + +=item B<fspool-build> I<pool-or-uuid> [I<--overwrite>] [I<--no-overwrite>] + +Build a given fspool. + +=item B<pool-create> I<file> +[I<--build>] [[I<--overwrite>] | [I<--no-overwrite>]] + +Create and start a fspool object from the XML I<file>. + +[I<--build>] perform a B<fspool-build> after creation in order +to remove the need for a follow-up command to build the fspool. + +=item B<pool-create-as> I<name> I<type> [I<--print-xml>] +[I<--source-host hostname>] [I<--source-path path>] +[I<--source-name name>] [I<--target path>] [I<--source-format format>] +[I<--build>] [[I<--overwrite>] | [I<--no-overwrite>]] + +Create and start a fspool object I<name> from the raw parameters. If +I<--print-xml> is specified, then print the XML of the fspool object +without creating the fspool. Otherwise, the fspool has the specified +I<type>. +[I<--source-host hostname>] provides the source hostname for fspools backed +by fspool from a remote server (fspool netfs, etc). + +[I<--source-path path>] provides the source directory path for fspools backed +by directories (fspool type dir). + +[I<--source-name name>] provides the source name for fspools backed by storage +from a named element. + +[I<--target path>] is the path for the mapping of the fspool into +the host file system. + +[I<--source-format format>] provides information about the format of the +fspool filesystem type. + +[I<--build>] [[I<--overwrite>] | [I<--no-overwrite>]] perform a +B<fspool-build> after creation in order to remove the need for a +follow-up command to build the fspool. The I<--overwrite> and +I<--no-overwrite> flags follow the same rules as B<fspool-build>. If +just I<--build> is provided, then B<fspool-build> is called with no flags. + +=item B<fspool-define> I<file> + +Define an inactive persistent fspool or modify an existing persistent one +from the XML I<file>. + +=item B<pool-define-as> I<name> I<type> [I<--print-xml>] +[I<--source-host hostname>] [I<--source-path path>] +[I<--source-name name>] [I<--target path>] [I<--source-format format>] + +Create, but do not start, a fspool object I<name> from the raw parameters. +If I<--print-xml> is specified, then print the XML of the pool object +without defining the pool. Otherwise, the pool has the specified +I<type>. + +Use the same arguments as B<fspool-create-as>, except for the I<--build>, +I<--overwrite>, and I<--no-overwrite> options. + +=item B<fspool-destroy> I<fspool-or-uuid> + +Destroy (stop) a given I<fspool> object. Libvirt will no longer manage the fspool +object, but the raw data contained in +the fspool is not changed, and can be later recovered with +B<fspool-create>. + +=item B<fspool-delete> I<fspool-or-uuid> + +Destroy the resources used by a given I<fspool> object. This operation +is non-recoverable. The I<fspool> object will still exist after this +command, ready for the creation of new fspool item. + +=item B<fspool-dumpxml> [I<--inactive>] I<fspool-or-uuid> + +Returns the XML information about the I<fspool> object. +I<--inactive> tells virsh to dump fspool configuration that will be used +on next start of the fspool as opposed to the current fspool configuration. + +=item B<fspool-edit> I<fspool-or-uuid> + +Edit the XML configuration file for a fspool. + +This is equivalent to: + + virsh fspool-dumpxml fspool > fspool.xml + vi fspool.xml (or make changes with your other text editor) + virsh pool-define pool.xml + +except that it does some error checking. + +The editor used can be supplied by the C<$VISUAL> or C<$EDITOR> environment +variables, and defaults to C<vi>. + +=item B<fspool-info> I<fspool-or-uuid> + +Returns basic information about the I<fspool> object. + +=item B<pool-fslist> [I<--inactive>] [I<--all>] + [I<--persistent>] [I<--transient>] + [I<--autostart>] [I<--no-autostart>] + [[I<--details>] [<type>] + +List fspool objects known to libvirt. By default, only active pools +are listed; I<--inactive> lists just the inactive pools, and I<--all> +lists all pools. + +In addition, there are several sets of filtering flags. I<--persistent> is to +list the persistent fspools, I<--transient> is to list the transient fspools. +I<--autostart> lists the autostarting fspools, I<--no-autostart> lists the fspools +with autostarting disabled. + +You may also want to list fspools with specified types using I<type>, the +pool types must be separated by comma, e.g. --type dir. + +The I<--details> option instructs virsh to additionally +display fspool persistence and capacity related information where available. + +=item B<fspool-name> I<uuid> + +Convert the I<uuid> to a fspool name. + +=item B<fspool-refresh> I<fspool-or-uuid> + +Refresh the list of items contained in I<fspool>. + +=item B<fspool-start> I<fspool-or-uuid> +[I<--build>] [[I<--overwrite>] | [I<--no-overwrite>]] + +Start the I<fspool>, which is previously defined but inactive. + +=item B<fspool-undefine> I<fspool-or-uuid> + +Undefine the configuration for an inactive I<fspool>. + +=item B<fspool-uuid> I<fspool> + +Returns the UUID of the named I<fspool>. + +=back + +=head1 FS ITEMS COMMANDS + +=over 4 + +=item B<item-create> I<fspool-or-uuid> I<FILE> + +Create a item from an XML <file>. +I<fspool-or-uuid> is the name or UUID of the fspool to create the item in. +I<FILE> is the XML <file> with the item definition. An easy way to create the +XML <file> is to use the B<item-dumpxml> command to obtain the definition of a +pre-existing item. + +=item B<vol-create-from> I<pool-or-uuid> I<FILE> [I<--inputpool> +I<pool-or-uuid>] I<vol-name-or-key-or-path> [I<--prealloc-metadata>] +[I<--reflink>] + +Create a volume, using another item as input. +I<fspool-or-uuid> is the name or UUID of the fspool to create the item in. +I<FILE> is the XML <file> with the volume definition. +I<--inputfspool> I<fspool-or-uuid> is the name or uuid of the fspool the +source item is in. +I<item-name-or-key-or-path> is the name or key or path of the source item. + +=item B<item-create-as> I<fspool-or-uuid> I<name> I<capacity> +[I<--allocation> I<size>] [I<--format> I<string>][I<--print-xml>] + +Create a item from a set of arguments unless I<--print-xml> is specified, in +which case just the XML of the item object is printed out without any actual +object creation. +I<fspool-or-uuid> is the name or UUID of the fspool to create the item +in. +I<name> is the name of the new item. +I<capacity> is the size of the item to be created, as a scaled integer +(see B<NOTES> above), defaulting to bytes if there is no suffix. +I<--allocation> I<size> is the initial size to be allocated in the item, +also as a scaled integer defaulting to bytes. + +=item B<item-clone> [I<--fspool> I<fspool-or-uuid>] I<item-name-or-key-or-path> +I<name> + +Clone an existing item within the parent fspool. Less powerful, +but easier to type, version of B<item-create-from>. +I<--fspool> I<fspool-or-uuid> is the name or UUID of the fspool +that contains the source item, and will contain the new item. +I<item-name-or-key-or-path> is the name or key or path of the source item. +I<name> is the name of the new item. + +=item B<item-delete> [I<--fspool> I<fspool-or-uuid>] I<item-name-or-key-or-path> + +Delete a given item. +I<--pool> I<fspool-or-uuid> is the name or UUID of the fspool the item +is in. +I<item-name-or-key-or-path> is the name or key or path of the item to delete. + +=item B<item-dumpxml> [I<--fspool> I<fspool-or-uuid>] I<item-name-or-key-or-path> + +Output the item information as an XML dump to stdout. +I<--fspool> I<fspool-or-uuid> is the name or UUID of the fspool the item +is in. I<item-name-or-key-or-path> is the name or key or path of the item +to output the XML of. + +=item B<item-info> [I<--fspool> I<fspool-or-uuid>] I<item-name-or-key-or-path> +[I<--bytes>] + +Returns basic information about the given item. +I<--fspool> I<fspool-or-uuid> is the name or UUID of the fspool the item +is in. I<item-name-or-key-or-path> is the name or key or path of the item +to return information for. If I<--bytes> is specified the sizes are not +converted to human friendly units. + +=item B<item-list> [I<--pool> I<pool-or-uuid>] [I<--details>] + +Return the list of volumes in the given fspool. +I<--fspool> I<fspool-or-uuid> is the name or UUID of the fspool. +The I<--details> option instructs virsh to additionally display item +type and capacity related information where available. + + +=item B<item-path> [I<--fspool> I<fspool-or-uuid>] I<item-name-or-key> + +Return the path for a given item. +I<--fspool> I<fspool-or-uuid> is the name or UUID of the fspool the item +is in. +I<item-name-or-key> is the name or key of the item to return the path for. + +=item B<item-name> I<item-key-or-path> + +Return the name for a given item. +I<item-key-or-path> is the key or path of the item to return the name for. + +=item B<item-key> [I<--fspool> I<fspool-or-uuid>] I<item-name-or-path> + +Return the item key for a given volume. +I<--fspool> I<fspool-or-uuid> is the name or UUID of the fspool the item +is in. I<item-name-or-path> is the name or path of the item to return the +item key for. + +=back + =head1 SECRET COMMANDS The following commands manipulate "secrets" (e.g. passwords, passphrases and -- 1.8.3.1

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

Patch adds general documentation for fspool and tests for directory backend. Signed-off-by: Olga Krishtal <okrishtal(a)virtuozzo.com&gt; --- docs/formatfs.html.in | 206 +++++++++++++++++++++ docs/fspool.html.in | 41 ++++ docs/sitemap.html.in | 4 + tests/Makefile.am | 12 ++ tests/fsitemxml2xmlin/item.xml | 13 ++ tests/fsitemxml2xmlout/item.xml | 13 ++ tests/fsitemxml2xmltest.c | 105 +++++++++++ .../dir-missing-target-path-invalid.xml | 12 ++ tests/fspoolxml2xmlin/fspool-dir.xml | 16 ++ tests/fspoolxml2xmlout/fspool-dir.xml | 16 ++ tests/fspoolxml2xmltest.c | 81 ++++++++ 11 files changed, 519 insertions(+) create mode 100644 docs/formatfs.html.in create mode 100644 docs/fspool.html.in create mode 100644 tests/fsitemxml2xmlin/item.xml create mode 100644 tests/fsitemxml2xmlout/item.xml create mode 100644 tests/fsitemxml2xmltest.c create mode 100644 tests/fspoolschemadata/dir-missing-target-path-invalid.xml create mode 100644 tests/fspoolxml2xmlin/fspool-dir.xml create mode 100644 tests/fspoolxml2xmlout/fspool-dir.xml create mode 100644 tests/fspoolxml2xmltest.c diff --git a/docs/formatfs.html.in b/docs/formatfs.html.in new file mode 100644 index 0000000..b50034c --- /dev/null +++ b/docs/formatfs.html.in @@ -0,0 +1,206 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml"> + <body> + <h1>Filesystem pool and item XML format</h1> + + <ul id="toc"></ul> + + <h2><a name="FSPool">Filesystem pool XML</a></h2> + + <p> + Filesystem pools is a facility to manage filesystems. They has a lot in common with + storage pools (nearly the same api and way of managment). However the managment units + are completely different. To avoid the misunderstanding in fspool usage use this XML + description. See <a href="fspool.html">fspool driver page</a> + </p> + + <p> + The root element is named <code>fspool</code>. It has attribute <code>type</code>, + at the moment fspool has only one type <code>dir</code>. It represents fspool that + holds filesystems in subdirectories on a host filesystem. + </p> + + <h3><a name="FSPoolFirst">General metadata</a></h3> + + <pre> + &lt;fspool type="dir"&gt; + &lt;name&gt;virfs&lt;/name&gt; + &lt;uuid&gt;4584ee21-db40-4e98-980e-44802c47b62f&lt;/uuid&gt; + &lt;allocation&gt;10000000&lt;/allocation&gt; + &lt;capacity&gt;50000000&lt;/capacity&gt; + &lt;available&gt;40000000&lt;/available&gt; + ...</pre> + + <dl> + <dt><code>name</code></dt> + <dd>Providing a name for the fspool which is unique to the host. + This is mandatory when defining a filesystem pool.</dd> + <dt><code>uuid</code></dt> + <dd>Providing an identifier for the fspool which is globally unique. + This is optional when defining a fspool, a UUID will be generated if + omitted.</dd> + <dt><code>allocation</code></dt> + <dd>Providing the total storage allocation for the pool. This value is in bytes. + This is not applicable when creating a fspool.</dd> + <dt><code>capacity</code></dt> + <dd>Providing the total capacity for the fspool. This value is in bytes. This + is not applicable when creating a fspool.</dd> + <dt><code>available</code></dt> + <dd>Providing the free space available for allocating new items + in the fspool. This value is in bytes. This is not applicable when creating a + fspool.</dd> + </dl> + + <h3><a name="FSPoolSource">Source elements</a></h3> + + <p> + A single <code>source</code> element is contained within the top level + <code>fspool</code> element. This tag is used to describe the source of + the fspool. At the moment it is left empty. + </p> + + <h3><a name="FSPoolTarget">Target elements</a></h3> + + <p> + A single <code>target</code> element is contained within the top level + <code>fspool</code> element for all types of fspools (fspool types <code>dir</code>). + This tag is used to describe the mapping of fspool into the host filesystem. + It can contain the following child elements: + </p> + + <pre> + ... + &lt;target&gt; + &lt;path&gt;/path/in/host/fs&lt;/path&gt; + &lt;permissions&gt; + &lt;owner&gt;107&lt;/owner&gt; + &lt;group&gt;107&lt;/group&gt; + &lt;mode&gt;0744&lt;/mode&gt; + &lt;/permissions&gt; + &lt;/target&gt; + &lt;/fspool&gt;</pre> + + <dl> + <dt><code>path</code></dt> + <dd>Provides the location at which the fspool will be mapped into + the local filesystem namespace, as an absolute path. For a fspool with directory + backend it will be a fully qualified name of the directory in which items + will be created. + </dd> + <dt><code>permissions</code></dt> + <dd> It provides information about the permissions to use for the + final directory when the fspool is built. There are 4 child elements. + The <code>mode</code> element contains the octal permission set. + The <code>mode</code> defaults to 0755 when not provided. + The <code>owner</code> element contains the numeric user ID. + The <code>group</code> element contains the numeric group ID. + If <code>owner</code> or <code>group</code> aren't specified when + creating a directory, the values are inherited from the parent + directory. + </dd> + </dl> + + <h2><a name="FSItem">Item XML</a></h2> + <p> + An item is a directory that holds single filesystem. The filesystem item + XML format is available. + </p> + + <h3><a name="FSItemFirst">General metadata</a></h3> + + <pre> + &lt;item&gt; + &lt;name&gt;item1&lt;/name&gt; + &lt;key&gt;/path/to/fspool/&lt;/key&gt; + &lt;allocation&gt;0&lt;/allocation&gt; + &lt;capacity unit="T"&gt;1&lt;/capacity&gt; + ...</pre> + + <dl> + <dt><code>name</code></dt> + <dd>Providing a name for the item which is unique to the fspool. + This is mandatory when defining an item.</dd> + <dt><code>key</code></dt> + <dd>Providing an identifier for the item which identifies a + single item. It is impossible to have two distinct keys + identifying a single item. This field cannot be set when creating + an item: it is always generated.</dd> + <dt><code>allocation</code></dt> + <dd>Providing the total storage allocation for the item.</dd> + <dt><code>capacity</code></dt> + <dd>Providing the logical capacity for the item.</dd> + </dl> + + <h3><a name="FsItemTarget">Target elements</a></h3> + + <p> + A single <code>target</code> element is contained within the top level + <code>item</code> element. This tag is used to describe the mapping of + the fspool item into the host filesystem. It can contain the following + child elements: + </p> + + <pre> + ... + &lt;target&gt; + &lt;path&gt;/var/lib/virt/images/sparse.img&lt;/path&gt; + &lt;format type='qcow2'/&gt; + &lt;permissions&gt; + &lt;owner&gt;107&lt;/owner&gt; + &lt;group&gt;107&lt;/group&gt; + &lt;mode&gt;0744&lt;/mode&gt; + &lt;/permissions&gt; + &lt;/target&gt;</pre> + + <dl> + <dt><code>permissions</code></dt> + <dd>Provides information about the permissions to use + when creating items. There are 4 child elements. + The <code>mode</code> element contains the octal permission set. + The <code>mode</code> defaults to 0600 when not provided. + The <code>owner</code> element contains the numeric user ID. + The <code>group</code> element contains the numeric group ID. + If <code>owner</code> or <code>group</code> aren't specified when + creating fspool item, the values are inherited from the parent + directory. + </dd> + </dl> + + + <h2><a name="examples">Example configuration</a></h2> + + <p> + Here is an example of fspool and item. + </p> + + <h3><a name="exampleDir">Directory based fspool</a></h3> + + <pre> + &lt;fspool type="dir"&gt; + &lt;name&gt;my_fspool&lt;/name&gt; + &lt;source&gt; + &lt;/source&gt; + &lt;target&gt; + &lt;path&gt;/my_fspool_dir&lt;/path&gt; + &lt;/target&gt; + &lt;/fspool&gt;</pre> + + <h3><a name="exampleItem">Fspool Item</a></h3> + + <pre> + &lt;item&gt; + &lt;name&gt;item1&lt;/name&gt; + &lt;allocation&gt;0&lt;/allocation&gt; + &lt;capacity unit="T"&gt;1&lt;/capacity&gt; + &lt;target&gt; + &lt;permissions&gt; + &lt;owner&gt;107&lt;/owner&gt; + &lt;group&gt;107&lt;/group&gt; + &lt;mode&gt;0744&lt;/mode&gt; + &lt;/permissions&gt; + &lt;/target&gt; + &lt;/item&gt;</pre> + + </body> +</html> diff --git a/docs/fspool.html.in b/docs/fspool.html.in new file mode 100644 index 0000000..a501ad3 --- /dev/null +++ b/docs/fspool.html.in @@ -0,0 +1,41 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml"> + <body> + <h1 >Filesystem Pool Management</h1> + <p> + Libvirt provides filesystems managment on the physical host through + fspools and items. + </p> + <p> + Fspool is the entity that holds filesystems. It has a lot in + common with storage pools and volumes. However, fspool deals with + filesystems and has the only one unit managment type - filesystem. + Single filesystem in fspool is called an item. + </p> + <p> + Libvirt supports the following fspool types: + </p> + <ul> + <li> + <a href="#FSPoolBackendDir">Directory backend</a> + </li> + </ul> + + <h2><a name="FSPoolBackendDir">Fspool with directory backend</a></h2> + <p> + A fspool with a type of <code>dir</code> provides the means to manage + filesystems within a directory on a single host. + </p> + + <h3>Example pool input definition</h3> + <pre> + &lt;fspool type="dir"&gt; + &lt;name&gt;virtfs&lt;/name&gt; + &lt;target&gt; + &lt;path&gt;/var/lib/virt/fs&lt;/path&gt; + &lt;/target&gt; + &lt;/fspool&gt;</pre> + + </body> +</html> diff --git a/docs/sitemap.html.in b/docs/sitemap.html.in index 757d5aa..31606d1 100644 --- a/docs/sitemap.html.in +++ b/docs/sitemap.html.in @@ -177,6 +177,10 @@ <span>Network filter XML format</span> </li> <li> + <a href="formatfs.html">Filesystem pool</a> + <span>The filesystem pool and filesystem item XML format</span> + </li> + <li> <a href="formatstorage.html">Storage</a> <span>The storage pool and volume XML format</span> </li> diff --git a/tests/Makefile.am b/tests/Makefile.am index 924029a..cf4eb1c 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -351,6 +351,8 @@ test_programs += secretxml2xmltest test_programs += genericxml2xmltest +test_programs += fsitemxml2xmltest fspoolxml2xmltest + if WITH_LINUX test_programs += virusbtest \ virnetdevbandwidthtest \ @@ -873,6 +875,16 @@ interfacexml2xmltest_SOURCES = \ testutils.c testutils.h interfacexml2xmltest_LDADD = $(LDADDS) +fsitemxml2xmltest_SOURCES = \ + fsitemxml2xmltest.c \ + testutils.c testutils.h +fsitemxml2xmltest_LDADD = $(LDADDS) + +fspoolxml2xmltest_SOURCES = \ + fspoolxml2xmltest.c \ + testutils.c testutils.h +fspoolxml2xmltest_LDADD = $(LDADDS) + cputest_SOURCES = \ cputest.c \ testutils.c testutils.h diff --git a/tests/fsitemxml2xmlin/item.xml b/tests/fsitemxml2xmlin/item.xml new file mode 100644 index 0000000..ae1be59 --- /dev/null +++ b/tests/fsitemxml2xmlin/item.xml @@ -0,0 +1,13 @@ +<item> + <name>item1</name> + <key>/var/lib/libvirt/images/fs/item1</key> + <capacity unit='bytes'>0</capacity> + <allocation unit='bytes'>4096</allocation> + <target> + <permissions> + <mode>0600</mode> + <owner>0</owner> + <group>0</group> + </permissions> + </target> +</item> diff --git a/tests/fsitemxml2xmlout/item.xml b/tests/fsitemxml2xmlout/item.xml new file mode 100644 index 0000000..ae1be59 --- /dev/null +++ b/tests/fsitemxml2xmlout/item.xml @@ -0,0 +1,13 @@ +<item> + <name>item1</name> + <key>/var/lib/libvirt/images/fs/item1</key> + <capacity unit='bytes'>0</capacity> + <allocation unit='bytes'>4096</allocation> + <target> + <permissions> + <mode>0600</mode> + <owner>0</owner> + <group>0</group> + </permissions> + </target> +</item> diff --git a/tests/fsitemxml2xmltest.c b/tests/fsitemxml2xmltest.c new file mode 100644 index 0000000..a6fec33 --- /dev/null +++ b/tests/fsitemxml2xmltest.c @@ -0,0 +1,105 @@ +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> + +#include <sys/types.h> +#include <fcntl.h> + +#include "internal.h" +#include "testutils.h" +#include "fs_conf.h" +#include "testutilsqemu.h" +#include "virstring.h" + +#define VIR_FROM_THIS VIR_FROM_NONE + +static int +testCompareXMLToXMLFiles(const char *fspoolxml, const char *inxml, + const char *outxml, unsigned int flags) +{ + char *actual = NULL; + int ret = -1; + virFSPoolDefPtr fspool = NULL; + virFSItemDefPtr dev = NULL; + + if (!(fspool = virFSPoolDefParseFile(fspoolxml))) + goto fail; + + if (!(dev = virFSItemDefParseFile(fspool, inxml, flags))) + goto fail; + + if (!(actual = virFSItemDefFormat(fspool, dev))) + goto fail; + + if (virTestCompareToFile(actual, outxml) < 0) + goto fail; + + ret = 0; + + fail: + VIR_FREE(actual); + virStoragePoolDefFree(fspool); + virFSItemDefFree(dev); + return ret; +} + +struct testInfo { + const char *fspool; + const char *name; + unsigned int flags; +}; + +static int +testCompareXMLToXMLHelper(const void *data) +{ + int result = -1; + const struct testInfo *info = data; + char *fspoolxml = NULL; + char *inxml = NULL; + char *outxml = NULL; + + if (virAsprintf(&fspoolxml, "%s/fspoolxml2xmlin/%s.xml", + abs_srcdir, info->fspool) < 0 || + virAsprintf(&inxml, "%s/fsitemxml2xmlin/%s.xml", + abs_srcdir, info->name) < 0 || + virAsprintf(&outxml, "%s/fsitemxml2xmlout/%s.xml", + abs_srcdir, info->name) < 0) { + goto cleanup; + } + + result = testCompareXMLToXMLFiles(fspoolxml, inxml, outxml, info->flags); + + cleanup: + VIR_FREE(fspoolxml); + VIR_FREE(inxml); + VIR_FREE(outxml); + + return result; +} + + +static int +mymain(void) +{ + int ret = 0; + +#define DO_TEST_FULL(fspool, name, flags) \ + do { \ + struct testInfo info = { fspool, name, flags }; \ + if (virTestRun("FS Item XML-2-XML " name, \ + testCompareXMLToXMLHelper, &info) < 0) \ + ret = -1; \ + } \ + while (0); + +#define DO_TEST(fspool, name) DO_TEST_FULL(fspool, name, 0) + + DO_TEST("fspool-dir", "item"); + + return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE; +} + +VIRT_TEST_MAIN(mymain) diff --git a/tests/fspoolschemadata/dir-missing-target-path-invalid.xml b/tests/fspoolschemadata/dir-missing-target-path-invalid.xml new file mode 100644 index 0000000..a52bf49 --- /dev/null +++ b/tests/fspoolschemadata/dir-missing-target-path-invalid.xml @@ -0,0 +1,12 @@ +<fspool type='dir'> + <name>test</name> + <source> + </source> + <target> + <permissions> + <mode>0700</mode> + <owner>-1</owner> + <group>-1</group> + </permissions> + </target> +</fspool> diff --git a/tests/fspoolxml2xmlin/fspool-dir.xml b/tests/fspoolxml2xmlin/fspool-dir.xml new file mode 100644 index 0000000..d1a3f28 --- /dev/null +++ b/tests/fspoolxml2xmlin/fspool-dir.xml @@ -0,0 +1,16 @@ +<fspool type='dir'> + <name>virtfs</name> + <uuid>5584ee21-db40-4e98-980e-44802c47b62f</uuid> + <capacity unit='bytes'>0</capacity> + <allocation unit='bytes'>0</allocation> + <available unit='bytes'>0</available> + <source> + </source> + <target> + <path>///var/////lib/libvirt/fs//</path> + <permissions> + <mode>0700</mode> + <label>some_lable_t</label> + </permissions> + </target> +</fspool> diff --git a/tests/fspoolxml2xmlout/fspool-dir.xml b/tests/fspoolxml2xmlout/fspool-dir.xml new file mode 100644 index 0000000..dbca470 --- /dev/null +++ b/tests/fspoolxml2xmlout/fspool-dir.xml @@ -0,0 +1,16 @@ +<fspool type='dir'> + <name>virtfs</name> + <uuid>5584ee21-db40-4e98-980e-44802c47b62f</uuid> + <capacity unit='bytes'>0</capacity> + <allocation unit='bytes'>0</allocation> + <available unit='bytes'>0</available> + <source> + </source> + <target> + <path>/var/lib/libvirt/fs</path> + <permissions> + <mode>0700</mode> + <label>some_lable_t</label> + </permissions> + </target> +</fspool> diff --git a/tests/fspoolxml2xmltest.c b/tests/fspoolxml2xmltest.c new file mode 100644 index 0000000..7883d65 --- /dev/null +++ b/tests/fspoolxml2xmltest.c @@ -0,0 +1,81 @@ +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> + +#include <sys/types.h> +#include <fcntl.h> + +#include "internal.h" +#include "testutils.h" +#include "fs_conf.h" +#include "testutilsqemu.h" +#include "virstring.h" + +#define VIR_FROM_THIS VIR_FROM_NONE + +static int +testCompareXMLToXMLFiles(const char *inxml, const char *outxml) +{ + char *actual = NULL; + int ret = -1; + virFSPoolDefPtr dev = NULL; + + if (!(dev = virFSPoolDefParseFile(inxml))) + goto fail; + + if (!(actual = virFSPoolDefFormat(dev))) + goto fail; + + if (virTestCompareToFile(actual, outxml) < 0) + goto fail; + + ret = 0; + + fail: + VIR_FREE(actual); + virStoragePoolDefFree(dev); + return ret; +} + +static int +testCompareXMLToXMLHelper(const void *data) +{ + int result = -1; + char *inxml = NULL; + char *outxml = NULL; + + if (virAsprintf(&inxml, "%s/fspoolxml2xmlin/%s.xml", + abs_srcdir, (const char*)data) < 0 || + virAsprintf(&outxml, "%s/fspoolxml2xmlout/%s.xml", + abs_srcdir, (const char*)data) < 0) { + goto cleanup; + } + + result = testCompareXMLToXMLFiles(inxml, outxml); + + cleanup: + VIR_FREE(inxml); + VIR_FREE(outxml); + + return result; +} + +static int +mymain(void) +{ + int ret = 0; + +#define DO_TEST(name) \ + if (virTestRun("FS Pool XML-2-XML " name, \ + testCompareXMLToXMLHelper, (name)) < 0) \ + ret = -1 + + DO_TEST("fspool-dir"); + + return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE; +} + +VIRT_TEST_MAIN(mymain) -- 1.8.3.1