2012-07-24 12:49:27 +04:00
/*
* virsh - pool . c : Commands to manage storage pool
*
2013-05-09 22:59:04 +04:00
* Copyright ( C ) 2005 , 2007 - 2013 Red Hat , Inc .
2012-07-24 12:49:27 +04:00
*
* 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
2012-09-21 02:30:55 +04:00
* License along with this library . If not , see
2012-07-24 12:49:27 +04:00
* < http : //www.gnu.org/licenses/>.
*
* Daniel Veillard < veillard @ redhat . com >
* Karel Zak < kzak @ redhat . com >
* Daniel P . Berrange < berrange @ redhat . com >
*
*/
2012-08-21 02:56:53 +04:00
# include <config.h>
# include "virsh-pool.h"
2012-07-24 12:49:27 +04:00
2012-08-21 02:56:53 +04:00
# include <libxml/parser.h>
# include <libxml/tree.h>
# include <libxml/xpath.h>
# include <libxml/xmlsave.h>
# include "internal.h"
2012-12-04 16:04:07 +04:00
# include "virbuffer.h"
2012-12-12 22:06:53 +04:00
# include "viralloc.h"
2013-05-09 22:59:04 +04:00
# include "virfile.h"
2012-12-13 22:13:21 +04:00
# include "virxml.h"
2012-09-05 10:36:33 +04:00
# include "conf/storage_conf.h"
2013-04-03 14:36:23 +04:00
# include "virstring.h"
2012-08-21 02:56:53 +04:00
virStoragePoolPtr
2012-07-24 12:49:27 +04:00
vshCommandOptPoolBy ( vshControl * ctl , const vshCmd * cmd , const char * optname ,
2012-08-21 02:56:53 +04:00
const char * * name , unsigned int flags )
2012-07-24 12:49:27 +04:00
{
virStoragePoolPtr pool = NULL ;
const char * n = NULL ;
2012-08-21 02:56:53 +04:00
virCheckFlags ( VSH_BYUUID | VSH_BYNAME , NULL ) ;
2012-07-24 12:49:27 +04:00
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , optname , & n ) < 0 )
2012-07-24 12:49:27 +04:00
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 */
2012-08-21 02:56:53 +04:00
if ( ( flags & VSH_BYUUID ) & & strlen ( n ) = = VIR_UUID_STRING_BUFLEN - 1 ) {
2012-07-24 12:49:27 +04:00
vshDebug ( ctl , VSH_ERR_DEBUG , " %s: <%s> trying as pool UUID \n " ,
cmd - > def - > name , optname ) ;
pool = virStoragePoolLookupByUUIDString ( ctl - > conn , n ) ;
}
/* try it by NAME */
2012-08-21 02:56:53 +04:00
if ( ! pool & & ( flags & VSH_BYNAME ) ) {
2012-07-24 12:49:27 +04:00
vshDebug ( ctl , VSH_ERR_DEBUG , " %s: <%s> trying as pool NAME \n " ,
cmd - > def - > name , optname ) ;
pool = virStoragePoolLookupByName ( ctl - > conn , n ) ;
}
if ( ! pool )
vshError ( ctl , _ ( " failed to get pool '%s' " ) , n ) ;
return pool ;
}
/*
* " pool-autostart " command
*/
static const vshCmdInfo info_pool_autostart [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " autostart a pool " )
} ,
{ . name = " desc " ,
. data = N_ ( " Configure a pool to be automatically started at boot. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_autostart [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = " disable " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " disable autostarting " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolAutostart ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
const char * name ;
int autostart ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return false ;
autostart = ! vshCommandOptBool ( cmd , " disable " ) ;
if ( virStoragePoolSetAutostart ( pool , autostart ) < 0 ) {
if ( autostart )
vshError ( ctl , _ ( " failed to mark pool %s as autostarted " ) , name ) ;
else
vshError ( ctl , _ ( " failed to unmark pool %s as autostarted " ) , name ) ;
virStoragePoolFree ( pool ) ;
return false ;
}
if ( autostart )
vshPrint ( ctl , _ ( " Pool %s marked as autostarted \n " ) , name ) ;
else
vshPrint ( ctl , _ ( " Pool %s unmarked as autostarted \n " ) , name ) ;
virStoragePoolFree ( pool ) ;
return true ;
}
/*
* " pool-create " command
*/
static const vshCmdInfo info_pool_create [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " create a pool from an XML file " )
} ,
{ . name = " desc " ,
. data = N_ ( " Create a pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_create [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " file " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " file containing an XML pool description " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolCreate ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
const char * from = NULL ;
bool ret = true ;
char * buffer ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " file " , & from ) < 0 )
2012-07-24 12:49:27 +04:00
return false ;
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
if ( virFileReadAll ( from , VSH_MAX_XML_FILE , & buffer ) < 0 )
2012-07-24 12:49:27 +04:00
return false ;
pool = virStoragePoolCreateXML ( ctl - > conn , buffer , 0 ) ;
VIR_FREE ( buffer ) ;
if ( pool ! = NULL ) {
vshPrint ( ctl , _ ( " Pool %s created from %s \n " ) ,
virStoragePoolGetName ( pool ) , from ) ;
virStoragePoolFree ( pool ) ;
} else {
vshError ( ctl , _ ( " Failed to create pool from %s " ) , from ) ;
ret = false ;
}
return ret ;
}
/*
* XML Building helper for pool - define - as and pool - create - as
*/
static const vshCmdOptDef opts_pool_X_as [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " name " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " name of the pool " )
} ,
{ . name = " print-xml " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " print XML document, but don't define/create " )
} ,
{ . name = " type " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " type of the pool " )
} ,
{ . name = " source-host " ,
. type = VSH_OT_DATA ,
. help = N_ ( " source-host for underlying storage " )
} ,
{ . name = " source-path " ,
. type = VSH_OT_DATA ,
. help = N_ ( " source path for underlying storage " )
} ,
{ . name = " source-dev " ,
. type = VSH_OT_DATA ,
. help = N_ ( " source device for underlying storage " )
} ,
{ . name = " source-name " ,
. type = VSH_OT_DATA ,
. help = N_ ( " source name for underlying storage " )
} ,
{ . name = " target " ,
. type = VSH_OT_DATA ,
. help = N_ ( " target for underlying storage " )
} ,
{ . name = " source-format " ,
. type = VSH_OT_STRING ,
. help = N_ ( " format for underlying storage " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
2013-01-21 18:11:12 +04:00
static int
2013-01-21 18:15:01 +04:00
vshBuildPoolXML ( vshControl * ctl ,
const vshCmd * cmd ,
2013-01-21 18:11:12 +04:00
const char * * retname ,
char * * xml )
{
2012-07-24 12:49:27 +04:00
const char * name = NULL , * type = NULL , * srcHost = NULL , * srcPath = NULL ,
2013-01-21 18:11:12 +04:00
* srcDev = NULL , * srcName = NULL , * srcFormat = NULL ,
* target = NULL ;
2012-07-24 12:49:27 +04:00
virBuffer buf = VIR_BUFFER_INITIALIZER ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " name " , & name ) < 0 )
2012-07-24 12:49:27 +04:00
goto cleanup ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " type " , & type ) < 0 )
2012-07-24 12:49:27 +04:00
goto cleanup ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " source-host " , & srcHost ) < 0 | |
vshCommandOptStringReq ( ctl , cmd , " source-path " , & srcPath ) < 0 | |
vshCommandOptStringReq ( ctl , cmd , " source-dev " , & srcDev ) < 0 | |
vshCommandOptStringReq ( ctl , cmd , " source-name " , & srcName ) < 0 | |
vshCommandOptStringReq ( ctl , cmd , " source-format " , & srcFormat ) < 0 | |
vshCommandOptStringReq ( ctl , cmd , " target " , & target ) < 0 )
2012-07-24 12:49:27 +04:00
goto cleanup ;
virBufferAsprintf ( & buf , " <pool type='%s'> \n " , type ) ;
virBufferAsprintf ( & buf , " <name>%s</name> \n " , name ) ;
if ( srcHost | | srcPath | | srcDev | | srcFormat | | srcName ) {
virBufferAddLit ( & buf , " <source> \n " ) ;
if ( srcHost )
virBufferAsprintf ( & buf , " <host name='%s'/> \n " , srcHost ) ;
if ( srcPath )
virBufferAsprintf ( & buf , " <dir path='%s'/> \n " , srcPath ) ;
if ( srcDev )
virBufferAsprintf ( & buf , " <device path='%s'/> \n " , srcDev ) ;
if ( srcFormat )
virBufferAsprintf ( & buf , " <format type='%s'/> \n " , srcFormat ) ;
if ( srcName )
virBufferAsprintf ( & buf , " <name>%s</name> \n " , srcName ) ;
virBufferAddLit ( & buf , " </source> \n " ) ;
}
if ( target ) {
virBufferAddLit ( & buf , " <target> \n " ) ;
virBufferAsprintf ( & buf , " <path>%s</path> \n " , target ) ;
virBufferAddLit ( & buf , " </target> \n " ) ;
}
virBufferAddLit ( & buf , " </pool> \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 ;
}
/*
* " pool-create-as " command
*/
static const vshCmdInfo info_pool_create_as [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " create a pool from a set of args " )
} ,
{ . name = " desc " ,
. data = N_ ( " Create a pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolCreateAs ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
const char * name ;
char * xml ;
bool printXML = vshCommandOptBool ( cmd , " print-xml " ) ;
2013-01-21 18:15:01 +04:00
if ( ! vshBuildPoolXML ( ctl , cmd , & name , & xml ) )
2012-07-24 12:49:27 +04:00
return false ;
if ( printXML ) {
vshPrint ( ctl , " %s " , xml ) ;
VIR_FREE ( xml ) ;
} else {
pool = virStoragePoolCreateXML ( ctl - > conn , xml , 0 ) ;
VIR_FREE ( xml ) ;
if ( pool ! = NULL ) {
vshPrint ( ctl , _ ( " Pool %s created \n " ) , name ) ;
virStoragePoolFree ( pool ) ;
} else {
vshError ( ctl , _ ( " Failed to create pool %s " ) , name ) ;
return false ;
}
}
return true ;
}
/*
* " pool-define " command
*/
static const vshCmdInfo info_pool_define [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " define (but don't start) a pool from an XML file " )
} ,
{ . name = " desc " ,
. data = N_ ( " Define a pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_define [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " file " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " file containing an XML pool description " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolDefine ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
const char * from = NULL ;
bool ret = true ;
char * buffer ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " file " , & from ) < 0 )
2012-07-24 12:49:27 +04:00
return false ;
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
if ( virFileReadAll ( from , VSH_MAX_XML_FILE , & buffer ) < 0 )
2012-07-24 12:49:27 +04:00
return false ;
pool = virStoragePoolDefineXML ( ctl - > conn , buffer , 0 ) ;
VIR_FREE ( buffer ) ;
if ( pool ! = NULL ) {
vshPrint ( ctl , _ ( " Pool %s defined from %s \n " ) ,
virStoragePoolGetName ( pool ) , from ) ;
virStoragePoolFree ( pool ) ;
} else {
vshError ( ctl , _ ( " Failed to define pool from %s " ) , from ) ;
ret = false ;
}
return ret ;
}
/*
* " pool-define-as " command
*/
static const vshCmdInfo info_pool_define_as [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " define a pool from a set of args " )
} ,
{ . name = " desc " ,
. data = N_ ( " Define a pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolDefineAs ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
const char * name ;
char * xml ;
bool printXML = vshCommandOptBool ( cmd , " print-xml " ) ;
2013-01-21 18:15:01 +04:00
if ( ! vshBuildPoolXML ( ctl , cmd , & name , & xml ) )
2012-07-24 12:49:27 +04:00
return false ;
if ( printXML ) {
vshPrint ( ctl , " %s " , xml ) ;
VIR_FREE ( xml ) ;
} else {
pool = virStoragePoolDefineXML ( ctl - > conn , xml , 0 ) ;
VIR_FREE ( xml ) ;
if ( pool ! = NULL ) {
vshPrint ( ctl , _ ( " Pool %s defined \n " ) , name ) ;
virStoragePoolFree ( pool ) ;
} else {
vshError ( ctl , _ ( " Failed to define pool %s " ) , name ) ;
return false ;
}
}
return true ;
}
/*
* " pool-build " command
*/
static const vshCmdInfo info_pool_build [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " build a pool " )
} ,
{ . name = " desc " ,
. data = N_ ( " Build a given pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_build [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = " no-overwrite " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " do not overwrite an existing pool of this type " )
} ,
{ . name = " overwrite " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " overwrite any existing data " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolBuild ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
bool ret = true ;
const char * name ;
unsigned int flags = 0 ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return false ;
if ( vshCommandOptBool ( cmd , " no-overwrite " ) ) {
flags | = VIR_STORAGE_POOL_BUILD_NO_OVERWRITE ;
}
if ( vshCommandOptBool ( cmd , " overwrite " ) ) {
flags | = VIR_STORAGE_POOL_BUILD_OVERWRITE ;
}
if ( virStoragePoolBuild ( pool , flags ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s built \n " ) , name ) ;
} else {
vshError ( ctl , _ ( " Failed to build pool %s " ) , name ) ;
ret = false ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-destroy " command
*/
static const vshCmdInfo info_pool_destroy [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " destroy (stop) a pool " )
} ,
{ . name = " desc " ,
. data = N_ ( " Forcefully stop a given pool. Raw data in the pool is untouched " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_destroy [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolDestroy ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
bool ret = true ;
const char * name ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return false ;
if ( virStoragePoolDestroy ( pool ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s destroyed \n " ) , name ) ;
} else {
vshError ( ctl , _ ( " Failed to destroy pool %s " ) , name ) ;
ret = false ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-delete " command
*/
static const vshCmdInfo info_pool_delete [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " delete a pool " )
} ,
{ . name = " desc " ,
. data = N_ ( " Delete a given pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_delete [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolDelete ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
bool ret = true ;
const char * name ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return false ;
if ( virStoragePoolDelete ( pool , 0 ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s deleted \n " ) , name ) ;
} else {
vshError ( ctl , _ ( " Failed to delete pool %s " ) , name ) ;
ret = false ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-refresh " command
*/
static const vshCmdInfo info_pool_refresh [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " refresh a pool " )
} ,
{ . name = " desc " ,
. data = N_ ( " Refresh a given pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_refresh [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolRefresh ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
bool ret = true ;
const char * name ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return false ;
if ( virStoragePoolRefresh ( pool , 0 ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s refreshed \n " ) , name ) ;
} else {
vshError ( ctl , _ ( " Failed to refresh pool %s " ) , name ) ;
ret = false ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-dumpxml " command
*/
static const vshCmdInfo info_pool_dumpxml [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " pool information in XML " )
} ,
{ . name = " desc " ,
. data = N_ ( " Output the pool information as an XML dump to stdout. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_dumpxml [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = " inactive " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " show inactive defined XML " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolDumpXML ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
bool ret = true ;
bool inactive = vshCommandOptBool ( cmd , " inactive " ) ;
unsigned int flags = 0 ;
char * dump ;
if ( inactive )
flags | = VIR_STORAGE_XML_INACTIVE ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , NULL ) ) )
return false ;
dump = virStoragePoolGetXMLDesc ( pool , flags ) ;
if ( dump ! = NULL ) {
vshPrint ( ctl , " %s " , dump ) ;
VIR_FREE ( dump ) ;
} else {
ret = false ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
2012-09-05 10:36:33 +04:00
static int
vshStoragePoolSorter ( const void * a , const void * b )
{
virStoragePoolPtr * pa = ( virStoragePoolPtr * ) a ;
virStoragePoolPtr * pb = ( virStoragePoolPtr * ) b ;
if ( * pa & & ! * pb )
return - 1 ;
if ( ! * pa )
return * pb ! = NULL ;
return vshStrcasecmp ( virStoragePoolGetName ( * pa ) ,
virStoragePoolGetName ( * pb ) ) ;
}
struct vshStoragePoolList {
virStoragePoolPtr * pools ;
size_t npools ;
} ;
typedef struct vshStoragePoolList * vshStoragePoolListPtr ;
static void
vshStoragePoolListFree ( vshStoragePoolListPtr list )
{
Convert 'int i' to 'size_t i' in tools/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
size_t i ;
2012-09-05 10:36:33 +04:00
if ( list & & list - > pools ) {
for ( i = 0 ; i < list - > npools ; i + + ) {
if ( list - > pools [ i ] )
virStoragePoolFree ( list - > pools [ i ] ) ;
}
VIR_FREE ( list - > pools ) ;
}
VIR_FREE ( list ) ;
}
static vshStoragePoolListPtr
vshStoragePoolListCollect ( vshControl * ctl ,
unsigned int flags )
{
vshStoragePoolListPtr list = vshMalloc ( ctl , sizeof ( * list ) ) ;
Convert 'int i' to 'size_t i' in tools/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
size_t i ;
2012-09-05 10:36:33 +04:00
int ret ;
char * * names = NULL ;
virStoragePoolPtr pool ;
bool success = false ;
size_t deleted = 0 ;
int persistent ;
int autostart ;
int nActivePools = 0 ;
int nInactivePools = 0 ;
int nAllPools = 0 ;
2012-09-13 12:56:07 +04:00
/* try the list with flags support (0.10.2 and later) */
2012-09-05 10:36:33 +04:00
if ( ( ret = virConnectListAllStoragePools ( ctl - > conn ,
& list - > pools ,
flags ) ) > = 0 ) {
list - > npools = ret ;
goto finished ;
}
/* check if the command is actually supported */
2012-09-13 12:56:07 +04:00
if ( last_error & & last_error - > code = = VIR_ERR_NO_SUPPORT )
2012-09-05 10:36:33 +04:00
goto fallback ;
if ( last_error & & last_error - > code = = VIR_ERR_INVALID_ARG ) {
/* try the new API again but mask non-guaranteed flags */
unsigned int newflags = flags & ( VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE |
VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE ) ;
vshResetLibvirtError ( ) ;
if ( ( ret = virConnectListAllStoragePools ( ctl - > conn , & list - > pools ,
newflags ) ) > = 0 ) {
list - > npools = ret ;
goto filter ;
}
}
/* there was an error during the first or second call */
vshError ( ctl , " %s " , _ ( " Failed to list pools " ) ) ;
goto cleanup ;
fallback :
2012-09-13 12:56:07 +04:00
/* fall back to old method (0.10.1 and older) */
2012-09-05 10:36:33 +04:00
vshResetLibvirtError ( ) ;
/* There is no way to get the pool type */
2012-09-06 19:35:00 +04:00
if ( VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_POOL_TYPE ) ) {
2012-09-05 10:36:33 +04:00
vshError ( ctl , " %s " , _ ( " Filtering using --type is not supported "
" by this libvirt " ) ) ;
goto cleanup ;
}
/* Get the number of active pools */
2012-09-06 19:35:00 +04:00
if ( ! VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE ) | |
VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE ) ) {
2012-09-05 10:36:33 +04:00
if ( ( nActivePools = virConnectNumOfStoragePools ( ctl - > conn ) ) < 0 ) {
vshError ( ctl , " %s " , _ ( " Failed to get the number of active pools " ) ) ;
goto cleanup ;
}
}
/* Get the number of inactive pools */
2012-09-06 19:35:00 +04:00
if ( ! VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE ) | |
VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE ) ) {
2012-09-05 10:36:33 +04:00
if ( ( nInactivePools = virConnectNumOfDefinedStoragePools ( ctl - > conn ) ) < 0 ) {
vshError ( ctl , " %s " , _ ( " Failed to get the number of inactive pools " ) ) ;
goto cleanup ;
}
}
nAllPools = nActivePools + nInactivePools ;
if ( nAllPools = = 0 )
return list ;
names = vshMalloc ( ctl , sizeof ( char * ) * nAllPools ) ;
/* Retrieve a list of active storage pool names */
2012-09-06 19:35:00 +04:00
if ( ! VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE ) | |
VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE ) ) {
2012-09-05 10:36:33 +04:00
if ( virConnectListStoragePools ( ctl - > conn ,
names , nActivePools ) < 0 ) {
vshError ( ctl , " %s " , _ ( " Failed to list active pools " ) ) ;
goto cleanup ;
}
}
/* Add the inactive storage pools to the end of the name list */
2012-09-06 19:35:00 +04:00
if ( ! VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE ) | |
VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE ) ) {
2012-09-05 10:36:33 +04:00
if ( virConnectListDefinedStoragePools ( ctl - > conn ,
& names [ nActivePools ] ,
nInactivePools ) < 0 ) {
vshError ( ctl , " %s " , _ ( " Failed to list inactive pools " ) ) ;
goto cleanup ;
}
}
list - > pools = vshMalloc ( ctl , sizeof ( virStoragePoolPtr ) * ( nAllPools ) ) ;
list - > npools = 0 ;
/* get active pools */
for ( i = 0 ; i < nActivePools ; i + + ) {
if ( ! ( pool = virStoragePoolLookupByName ( ctl - > conn , names [ i ] ) ) )
continue ;
list - > pools [ list - > npools + + ] = pool ;
}
/* get inactive pools */
for ( i = 0 ; i < nInactivePools ; i + + ) {
if ( ! ( pool = virStoragePoolLookupByName ( ctl - > conn , names [ i ] ) ) )
continue ;
list - > pools [ list - > npools + + ] = pool ;
}
/* truncate pools that weren't found */
deleted = nAllPools - list - > npools ;
filter :
/* filter list the list if the list was acquired by fallback means */
for ( i = 0 ; i < list - > npools ; i + + ) {
pool = list - > pools [ i ] ;
/* persistence filter */
2012-09-06 19:35:00 +04:00
if ( VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_PERSISTENT ) ) {
2012-09-05 10:36:33 +04:00
if ( ( persistent = virStoragePoolIsPersistent ( pool ) ) < 0 ) {
vshError ( ctl , " %s " , _ ( " Failed to get pool persistence info " ) ) ;
goto cleanup ;
}
2012-09-06 19:35:00 +04:00
if ( ! ( ( VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT ) & & persistent ) | |
( VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT ) & & ! persistent ) ) )
2012-09-05 10:36:33 +04:00
goto remove_entry ;
}
/* autostart filter */
2012-09-06 19:35:00 +04:00
if ( VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_AUTOSTART ) ) {
2012-09-05 10:36:33 +04:00
if ( virStoragePoolGetAutostart ( pool , & autostart ) < 0 ) {
vshError ( ctl , " %s " , _ ( " Failed to get pool autostart state " ) ) ;
goto cleanup ;
}
2012-09-06 19:35:00 +04:00
if ( ! ( ( VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART ) & & autostart ) | |
( VSH_MATCH ( VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART ) & & ! autostart ) ) )
2012-09-05 10:36:33 +04:00
goto remove_entry ;
}
/* the pool matched all filters, it may stay */
continue ;
remove_entry :
/* the pool has to be removed as it failed one of the filters */
virStoragePoolFree ( list - > pools [ i ] ) ;
list - > pools [ i ] = NULL ;
deleted + + ;
}
finished :
/* sort the list */
if ( list - > pools & & list - > npools )
qsort ( list - > pools , list - > npools ,
sizeof ( * list - > pools ) , vshStoragePoolSorter ) ;
/* truncate the list if filter simulation deleted entries */
if ( deleted )
VIR_SHRINK_N ( list - > pools , list - > npools , deleted ) ;
success = true ;
cleanup :
for ( i = 0 ; i < nAllPools ; i + + )
VIR_FREE ( names [ i ] ) ;
if ( ! success ) {
vshStoragePoolListFree ( list ) ;
list = NULL ;
}
VIR_FREE ( names ) ;
return list ;
}
2012-07-24 12:49:27 +04:00
/*
* " pool-list " command
*/
static const vshCmdInfo info_pool_list [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " list pools " )
} ,
{ . name = " desc " ,
. data = N_ ( " Returns list of pools. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_list [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " inactive " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " list inactive pools " )
} ,
{ . name = " all " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " list inactive & active pools " )
} ,
{ . name = " transient " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " list transient pools " )
} ,
{ . name = " persistent " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " list persistent pools " )
} ,
{ . name = " autostart " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " list pools with autostart enabled " )
} ,
{ . name = " no-autostart " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " list pools with autostart disabled " )
} ,
{ . name = " type " ,
. type = VSH_OT_STRING ,
. help = N_ ( " only list pool of specified type(s) (if supported) " )
} ,
{ . name = " details " ,
. type = VSH_OT_BOOL ,
. help = N_ ( " display extended details for pools " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolList ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
{
virStoragePoolInfo info ;
Convert 'int i' to 'size_t i' in tools/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
int ret ;
size_t i ;
2012-09-05 10:36:33 +04:00
bool functionReturn = false ;
2012-07-24 12:49:27 +04:00
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 poolInfoText {
char * state ;
char * autostart ;
char * persistent ;
char * capacity ;
char * allocation ;
char * available ;
} ;
struct poolInfoText * poolInfoTexts = NULL ;
2012-09-05 10:36:33 +04:00
unsigned int flags = VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE ;
vshStoragePoolListPtr list = NULL ;
const char * type = NULL ;
2012-07-24 12:49:27 +04:00
bool details = vshCommandOptBool ( cmd , " details " ) ;
2012-09-05 10:36:33 +04:00
bool inactive , all ;
2013-08-28 11:25:59 +04:00
char * outputStr = NULL ;
2012-07-24 12:49:27 +04:00
2012-09-05 10:36:33 +04:00
inactive = vshCommandOptBool ( cmd , " inactive " ) ;
all = vshCommandOptBool ( cmd , " all " ) ;
2012-07-24 12:49:27 +04:00
2012-09-05 10:36:33 +04:00
if ( inactive )
flags = VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE ;
2012-07-24 12:49:27 +04:00
2012-09-05 10:36:33 +04:00
if ( all )
flags = VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE |
VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE ;
2012-07-24 12:49:27 +04:00
2012-09-05 10:36:33 +04:00
if ( vshCommandOptBool ( cmd , " autostart " ) )
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART ;
2012-07-24 12:49:27 +04:00
2012-09-05 10:36:33 +04:00
if ( vshCommandOptBool ( cmd , " no-autostart " ) )
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART ;
if ( vshCommandOptBool ( cmd , " persistent " ) )
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT ;
if ( vshCommandOptBool ( cmd , " transient " ) )
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " type " , & type ) < 0 )
2012-09-05 10:36:33 +04:00
return false ;
2012-07-24 12:49:27 +04:00
2012-09-05 10:36:33 +04:00
if ( type ) {
int poolType = - 1 ;
char * * poolTypes = NULL ;
int npoolTypes = 0 ;
2013-08-15 20:20:05 +04:00
if ( ( npoolTypes = vshStringToArray ( type , & poolTypes ) ) < 0 )
return false ;
2012-09-05 10:36:33 +04:00
for ( i = 0 ; i < npoolTypes ; i + + ) {
if ( ( poolType = virStoragePoolTypeFromString ( poolTypes [ i ] ) ) < 0 ) {
2013-08-15 20:27:37 +04:00
vshError ( ctl , _ ( " Invalid pool type '%s' " ) , poolTypes [ i ] ) ;
2013-08-15 20:20:05 +04:00
virStringFreeList ( poolTypes ) ;
2012-09-05 10:36:33 +04:00
return false ;
}
2013-12-13 13:31:50 +04:00
switch ( ( enum virStoragePoolType ) poolType ) {
2012-09-05 10:36:33 +04:00
case VIR_STORAGE_POOL_DIR :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_DIR ;
break ;
case VIR_STORAGE_POOL_FS :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_FS ;
break ;
case VIR_STORAGE_POOL_NETFS :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_NETFS ;
break ;
case VIR_STORAGE_POOL_LOGICAL :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL ;
break ;
case VIR_STORAGE_POOL_DISK :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_DISK ;
break ;
case VIR_STORAGE_POOL_ISCSI :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI ;
break ;
case VIR_STORAGE_POOL_SCSI :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_SCSI ;
break ;
case VIR_STORAGE_POOL_MPATH :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_MPATH ;
break ;
case VIR_STORAGE_POOL_RBD :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_RBD ;
break ;
2013-12-13 13:31:50 +04:00
case VIR_STORAGE_POOL_SHEEPDOG :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG ;
break ;
case VIR_STORAGE_POOL_GLUSTER :
flags | = VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER ;
break ;
case VIR_STORAGE_POOL_LAST :
2012-09-05 10:36:33 +04:00
break ;
}
2012-07-24 12:49:27 +04:00
}
2013-08-15 20:20:05 +04:00
virStringFreeList ( poolTypes ) ;
2012-07-24 12:49:27 +04:00
}
2012-09-05 10:36:33 +04:00
if ( ! ( list = vshStoragePoolListCollect ( ctl , flags ) ) )
goto cleanup ;
poolInfoTexts = vshCalloc ( ctl , list - > npools , sizeof ( * poolInfoTexts ) ) ;
2012-07-24 12:49:27 +04:00
/* Collect the storage pool information for display */
2012-09-05 10:36:33 +04:00
for ( i = 0 ; i < list - > npools ; i + + ) {
2012-07-24 12:49:27 +04:00
int autostart = 0 , persistent = 0 ;
/* Retrieve the autostart status of the pool */
2012-09-05 10:36:33 +04:00
if ( virStoragePoolGetAutostart ( list - > pools [ i ] , & autostart ) < 0 )
2012-07-24 12:49:27 +04:00
poolInfoTexts [ i ] . autostart = vshStrdup ( ctl , _ ( " no autostart " ) ) ;
else
poolInfoTexts [ i ] . autostart = vshStrdup ( ctl , autostart ?
_ ( " yes " ) : _ ( " no " ) ) ;
/* Retrieve the persistence status of the pool */
if ( details ) {
2012-09-05 10:36:33 +04:00
persistent = virStoragePoolIsPersistent ( list - > pools [ i ] ) ;
2012-07-24 12:49:27 +04:00
vshDebug ( ctl , VSH_ERR_DEBUG , " Persistent flag value: %d \n " ,
persistent ) ;
if ( persistent < 0 )
poolInfoTexts [ i ] . persistent = vshStrdup ( ctl , _ ( " unknown " ) ) ;
else
poolInfoTexts [ i ] . persistent = vshStrdup ( ctl , persistent ?
_ ( " yes " ) : _ ( " no " ) ) ;
/* Keep the length of persistent string if longest so far */
stringLength = strlen ( poolInfoTexts [ i ] . persistent ) ;
if ( stringLength > persistStrLength )
persistStrLength = stringLength ;
}
/* Collect further extended information about the pool */
2012-09-05 10:36:33 +04:00
if ( virStoragePoolGetInfo ( list - > pools [ i ] , & info ) ! = 0 ) {
2012-07-24 12:49:27 +04:00
/* Something went wrong retrieving pool info, cope with it */
vshError ( ctl , " %s " , _ ( " Could not retrieve pool information " ) ) ;
poolInfoTexts [ i ] . state = vshStrdup ( ctl , _ ( " unknown " ) ) ;
if ( details ) {
poolInfoTexts [ i ] . capacity = vshStrdup ( ctl , _ ( " unknown " ) ) ;
poolInfoTexts [ i ] . allocation = vshStrdup ( ctl , _ ( " unknown " ) ) ;
poolInfoTexts [ i ] . available = vshStrdup ( ctl , _ ( " unknown " ) ) ;
}
} else {
/* Decide which state string to display */
if ( details ) {
/* --details option was specified, we're using detailed state
* strings */
switch ( info . state ) {
case VIR_STORAGE_POOL_INACTIVE :
poolInfoTexts [ i ] . state = vshStrdup ( ctl , _ ( " inactive " ) ) ;
break ;
case VIR_STORAGE_POOL_BUILDING :
poolInfoTexts [ i ] . state = vshStrdup ( ctl , _ ( " building " ) ) ;
break ;
case VIR_STORAGE_POOL_RUNNING :
poolInfoTexts [ i ] . state = vshStrdup ( ctl , _ ( " running " ) ) ;
break ;
case VIR_STORAGE_POOL_DEGRADED :
poolInfoTexts [ i ] . state = vshStrdup ( ctl , _ ( " degraded " ) ) ;
break ;
case VIR_STORAGE_POOL_INACCESSIBLE :
poolInfoTexts [ i ] . state = vshStrdup ( ctl , _ ( " inaccessible " ) ) ;
break ;
}
/* Create the pool size related strings */
if ( info . state = = VIR_STORAGE_POOL_RUNNING | |
info . state = = VIR_STORAGE_POOL_DEGRADED ) {
double val ;
const char * unit ;
/* Create the capacity output string */
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
val = vshPrettyCapacity ( info . capacity , & unit ) ;
2012-07-24 12:49:27 +04:00
ret = virAsprintf ( & poolInfoTexts [ i ] . capacity ,
" %.2lf %s " , val , unit ) ;
2012-09-05 10:36:33 +04:00
if ( ret < 0 )
2012-07-24 12:49:27 +04:00
/* An error occurred creating the string, return */
goto asprintf_failure ;
/* Create the allocation output string */
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
val = vshPrettyCapacity ( info . allocation , & unit ) ;
2012-07-24 12:49:27 +04:00
ret = virAsprintf ( & poolInfoTexts [ i ] . allocation ,
" %.2lf %s " , val , unit ) ;
2012-09-05 10:36:33 +04:00
if ( ret < 0 )
2012-07-24 12:49:27 +04:00
/* An error occurred creating the string, return */
goto asprintf_failure ;
/* Create the available space output string */
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
val = vshPrettyCapacity ( info . available , & unit ) ;
2012-07-24 12:49:27 +04:00
ret = virAsprintf ( & poolInfoTexts [ i ] . available ,
" %.2lf %s " , val , unit ) ;
2012-09-05 10:36:33 +04:00
if ( ret < 0 )
2012-07-24 12:49:27 +04:00
/* An error occurred creating the string, return */
goto asprintf_failure ;
} else {
/* Capacity related information isn't available */
poolInfoTexts [ i ] . capacity = vshStrdup ( ctl , _ ( " - " ) ) ;
poolInfoTexts [ i ] . allocation = vshStrdup ( ctl , _ ( " - " ) ) ;
poolInfoTexts [ i ] . available = vshStrdup ( ctl , _ ( " - " ) ) ;
}
/* Keep the length of capacity string if longest so far */
stringLength = strlen ( poolInfoTexts [ i ] . capacity ) ;
if ( stringLength > capStrLength )
capStrLength = stringLength ;
/* Keep the length of allocation string if longest so far */
stringLength = strlen ( poolInfoTexts [ i ] . allocation ) ;
if ( stringLength > allocStrLength )
allocStrLength = stringLength ;
/* Keep the length of available string if longest so far */
stringLength = strlen ( poolInfoTexts [ i ] . available ) ;
if ( stringLength > availStrLength )
availStrLength = stringLength ;
} else {
/* --details option was not specified, only active/inactive
2012-09-05 10:36:33 +04:00
* state strings are used */
if ( virStoragePoolIsActive ( list - > pools [ i ] ) )
2012-07-24 12:49:27 +04:00
poolInfoTexts [ i ] . state = vshStrdup ( ctl , _ ( " active " ) ) ;
2012-09-05 10:36:33 +04:00
else
poolInfoTexts [ i ] . state = vshStrdup ( ctl , _ ( " inactive " ) ) ;
}
2012-07-24 12:49:27 +04:00
}
/* Keep the length of name string if longest so far */
2012-09-05 10:36:33 +04:00
stringLength = strlen ( virStoragePoolGetName ( list - > pools [ i ] ) ) ;
2012-07-24 12:49:27 +04:00
if ( stringLength > nameStrLength )
nameStrLength = stringLength ;
/* Keep the length of state string if longest so far */
stringLength = strlen ( poolInfoTexts [ i ] . state ) ;
if ( stringLength > stateStrLength )
stateStrLength = stringLength ;
/* Keep the length of autostart string if longest so far */
stringLength = strlen ( poolInfoTexts [ i ] . autostart ) ;
if ( stringLength > autostartStrLength )
autostartStrLength = stringLength ;
}
/* If the --details option wasn't selected, we output the pool
* 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 */
2013-11-12 20:22:36 +04:00
vshPrintExtra ( ctl , " %-20s %-10s %-10s \n " , _ ( " Name " ) , _ ( " State " ) ,
2012-07-24 12:49:27 +04:00
_ ( " Autostart " ) ) ;
2013-11-12 20:22:36 +04:00
vshPrintExtra ( ctl , " ------------------------------------------- \n " ) ;
2012-07-24 12:49:27 +04:00
/* Output old style pool info */
2012-09-05 10:36:33 +04:00
for ( i = 0 ; i < list - > npools ; i + + ) {
const char * name = virStoragePoolGetName ( list - > pools [ i ] ) ;
2013-11-12 20:22:36 +04:00
vshPrint ( ctl , " %-20s %-10s %-10s \n " ,
2012-09-05 10:36:33 +04:00
name ,
2012-07-24 12:49:27 +04:00
poolInfoTexts [ i ] . state ,
poolInfoTexts [ i ] . autostart ) ;
}
/* Cleanup and return */
functionReturn = 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 .
*/
ret = virAsprintf ( & outputStr ,
2013-11-12 20:22:36 +04:00
" %%-%lus %%-%lus %%-%lus %%-%lus %%%lus %%%lus %%%lus \n " ,
2012-07-24 12:49:27 +04:00
( unsigned long ) nameStrLength ,
( unsigned long ) stateStrLength ,
( unsigned long ) autostartStrLength ,
( unsigned long ) persistStrLength ,
( unsigned long ) capStrLength ,
( unsigned long ) allocStrLength ,
( unsigned long ) availStrLength ) ;
if ( ret < 0 ) {
/* An error occurred creating the string, return */
goto asprintf_failure ;
}
/* Display the header */
vshPrint ( ctl , outputStr , _ ( " Name " ) , _ ( " State " ) , _ ( " Autostart " ) ,
_ ( " Persistent " ) , _ ( " Capacity " ) , _ ( " Allocation " ) , _ ( " Available " ) ) ;
for ( i = nameStrLength + stateStrLength + autostartStrLength
+ persistStrLength + capStrLength
+ allocStrLength + availStrLength
2013-11-12 20:22:36 +04:00
+ 14 ; i > 0 ; i - - )
2012-07-24 12:49:27 +04:00
vshPrintExtra ( ctl , " - " ) ;
vshPrintExtra ( ctl , " \n " ) ;
/* Display the pool info rows */
2012-09-05 10:36:33 +04:00
for ( i = 0 ; i < list - > npools ; i + + ) {
2012-07-24 12:49:27 +04:00
vshPrint ( ctl , outputStr ,
2012-09-05 10:36:33 +04:00
virStoragePoolGetName ( list - > pools [ i ] ) ,
2012-07-24 12:49:27 +04:00
poolInfoTexts [ i ] . state ,
poolInfoTexts [ i ] . autostart ,
poolInfoTexts [ i ] . persistent ,
poolInfoTexts [ i ] . capacity ,
poolInfoTexts [ i ] . allocation ,
poolInfoTexts [ i ] . available ) ;
}
/* Cleanup and return */
functionReturn = true ;
goto cleanup ;
asprintf_failure :
/* Display an appropriate error message then cleanup and return */
switch ( errno ) {
case ENOMEM :
/* Couldn't allocate memory */
vshError ( ctl , " %s " , _ ( " Out of memory " ) ) ;
break ;
default :
/* Some other error */
vshError ( ctl , _ ( " virAsprintf failed (errno %d) " ) , errno ) ;
}
functionReturn = false ;
cleanup :
2013-08-27 15:34:09 +04:00
VIR_FREE ( outputStr ) ;
2012-09-05 10:36:33 +04:00
if ( list & & list - > npools ) {
for ( i = 0 ; i < list - > npools ; i + + ) {
VIR_FREE ( poolInfoTexts [ i ] . state ) ;
VIR_FREE ( poolInfoTexts [ i ] . autostart ) ;
VIR_FREE ( poolInfoTexts [ i ] . persistent ) ;
VIR_FREE ( poolInfoTexts [ i ] . capacity ) ;
VIR_FREE ( poolInfoTexts [ i ] . allocation ) ;
VIR_FREE ( poolInfoTexts [ i ] . available ) ;
}
2012-07-24 12:49:27 +04:00
}
VIR_FREE ( poolInfoTexts ) ;
2012-09-05 10:36:33 +04:00
vshStoragePoolListFree ( list ) ;
2012-07-24 12:49:27 +04:00
return functionReturn ;
}
/*
* " find-storage-pool-sources-as " command
*/
static const vshCmdInfo info_find_storage_pool_sources_as [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " find potential storage pool sources " )
} ,
{ . name = " desc " ,
. data = N_ ( " Returns XML <sources> document. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_find_storage_pool_sources_as [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " type " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " type of storage pool sources to find " )
} ,
{ . name = " host " ,
. type = VSH_OT_DATA ,
. help = N_ ( " optional host to query " )
} ,
{ . name = " port " ,
. type = VSH_OT_DATA ,
. help = N_ ( " optional port to query " )
} ,
{ . name = " initiator " ,
. type = VSH_OT_DATA ,
. help = N_ ( " optional initiator IQN to use for query " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolDiscoverSourcesAs ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
{
const char * type = NULL , * host = NULL ;
char * srcSpec = NULL ;
char * srcList ;
const char * initiator = NULL ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " type " , & type ) < 0 | |
vshCommandOptStringReq ( ctl , cmd , " host " , & host ) < 0 | |
vshCommandOptStringReq ( ctl , cmd , " initiator " , & initiator ) < 0 )
2012-07-24 12:49:27 +04:00
return false ;
if ( host ) {
const char * port = NULL ;
virBuffer buf = VIR_BUFFER_INITIALIZER ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " port " , & port ) < 0 ) {
2012-07-24 12:49:27 +04:00
vshError ( ctl , " %s " , _ ( " missing argument " ) ) ;
virBufferFreeAndReset ( & buf ) ;
return false ;
}
virBufferAddLit ( & buf , " <source> \n " ) ;
virBufferAsprintf ( & buf , " <host name='%s' " , host ) ;
if ( port )
virBufferAsprintf ( & buf , " port='%s' " , port ) ;
virBufferAddLit ( & buf , " /> \n " ) ;
if ( initiator ) {
virBufferAddLit ( & buf , " <initiator> \n " ) ;
virBufferAsprintf ( & buf , " <iqn name='%s'/> \n " , initiator ) ;
virBufferAddLit ( & buf , " </initiator> \n " ) ;
}
virBufferAddLit ( & buf , " </source> \n " ) ;
if ( virBufferError ( & buf ) ) {
vshError ( ctl , " %s " , _ ( " Out of memory " ) ) ;
return false ;
}
srcSpec = virBufferContentAndReset ( & buf ) ;
}
srcList = virConnectFindStoragePoolSources ( ctl - > conn , type , srcSpec , 0 ) ;
VIR_FREE ( srcSpec ) ;
if ( srcList = = NULL ) {
vshError ( ctl , _ ( " Failed to find any %s pool sources " ) , type ) ;
return false ;
}
vshPrint ( ctl , " %s " , srcList ) ;
VIR_FREE ( srcList ) ;
return true ;
}
/*
* " find-storage-pool-sources " command
*/
static const vshCmdInfo info_find_storage_pool_sources [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " discover potential storage pool sources " )
} ,
{ . name = " desc " ,
. data = N_ ( " Returns XML <sources> document. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_find_storage_pool_sources [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " type " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " type of storage pool sources to discover " )
} ,
{ . name = " srcSpec " ,
. type = VSH_OT_DATA ,
. help = N_ ( " optional file of source xml to query for pools " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolDiscoverSources ( vshControl * ctl , const vshCmd * cmd ATTRIBUTE_UNUSED )
{
const char * type = NULL , * srcSpecFile = NULL ;
char * srcSpec = NULL , * srcList ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " type " , & type ) < 0 )
2012-07-24 12:49:27 +04:00
return false ;
2013-01-21 18:15:01 +04:00
if ( vshCommandOptStringReq ( ctl , cmd , " srcSpec " , & srcSpecFile ) < 0 )
2012-07-24 12:49:27 +04:00
return false ;
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
if ( srcSpecFile & & virFileReadAll ( srcSpecFile , VSH_MAX_XML_FILE ,
& srcSpec ) < 0 )
2012-07-24 12:49:27 +04:00
return false ;
srcList = virConnectFindStoragePoolSources ( ctl - > conn , type , srcSpec , 0 ) ;
VIR_FREE ( srcSpec ) ;
if ( srcList = = NULL ) {
vshError ( ctl , _ ( " Failed to find any %s pool sources " ) , type ) ;
return false ;
}
vshPrint ( ctl , " %s " , srcList ) ;
VIR_FREE ( srcList ) ;
return true ;
}
/*
* " pool-info " command
*/
static const vshCmdInfo info_pool_info [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " storage pool information " )
} ,
{ . name = " desc " ,
. data = N_ ( " Returns basic information about the storage pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_info [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolInfo ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolInfo info ;
virStoragePoolPtr pool ;
int autostart = 0 ;
int persistent = 0 ;
bool ret = true ;
char uuid [ VIR_UUID_STRING_BUFLEN ] ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , NULL ) ) )
return false ;
vshPrint ( ctl , " %-15s %s \n " , _ ( " Name: " ) , virStoragePoolGetName ( pool ) ) ;
if ( virStoragePoolGetUUIDString ( pool , & uuid [ 0 ] ) = = 0 )
vshPrint ( ctl , " %-15s %s \n " , _ ( " UUID: " ) , uuid ) ;
if ( virStoragePoolGetInfo ( pool , & info ) = = 0 ) {
double val ;
const char * unit ;
switch ( info . state ) {
case VIR_STORAGE_POOL_INACTIVE :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " inactive " ) ) ;
break ;
case VIR_STORAGE_POOL_BUILDING :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " building " ) ) ;
break ;
case VIR_STORAGE_POOL_RUNNING :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " running " ) ) ;
break ;
case VIR_STORAGE_POOL_DEGRADED :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " degraded " ) ) ;
break ;
case VIR_STORAGE_POOL_INACCESSIBLE :
vshPrint ( ctl , " %-15s %s \n " , _ ( " State: " ) ,
_ ( " inaccessible " ) ) ;
break ;
}
/* Check and display whether the pool is persistent or not */
persistent = virStoragePoolIsPersistent ( pool ) ;
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 pool is autostarted or not */
2012-11-30 16:09:21 +04:00
if ( virStoragePoolGetAutostart ( pool , & autostart ) < 0 )
2012-07-24 12:49:27 +04:00
vshPrint ( ctl , " %-15s %s \n " , _ ( " Autostart: " ) , _ ( " no autostart " ) ) ;
else
vshPrint ( ctl , " %-15s %s \n " , _ ( " Autostart: " ) , autostart ? _ ( " yes " ) : _ ( " no " ) ) ;
if ( info . state = = VIR_STORAGE_POOL_RUNNING | |
info . state = = VIR_STORAGE_POOL_DEGRADED ) {
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
val = vshPrettyCapacity ( info . capacity , & unit ) ;
2012-07-24 12:49:27 +04:00
vshPrint ( ctl , " %-15s %2.2lf %s \n " , _ ( " Capacity: " ) , val , unit ) ;
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
val = vshPrettyCapacity ( info . allocation , & unit ) ;
2012-07-24 12:49:27 +04:00
vshPrint ( ctl , " %-15s %2.2lf %s \n " , _ ( " Allocation: " ) , val , unit ) ;
virsh: use common namespacing
Convert the exported items in virsh.h to use a common 'vsh' prefix.
* tools/virsh.h (VIRSH_MAX_XML_FILE): Rename...
(VSH_MAX_XML_FILE): ...and parenthesize.
(DIFF_MSEC, CTRL_CLOSE_BRACKET): Delete.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Remove prototype.
(editWriteToTempFile, editFile, editReadBackFile, prettyCapacity)
(virshReportError): Rename...
(vshEditWriteToTempFile, vshEditFile, vshEditReadBackFile)
(vshPrettyCapacity, vshReportError): ...into vsh namespace.
(jobWatchTimeoutFunc): Move to virsh-domain.c.
* tools/virsh.c (vshCommandRun): Inline former DIFF_MSEC.
(main): Inline former CTRL_CLOSE_BRACKET.
(vshUsage, vshInit, vshDeinit, vshParseArgv): Make static.
(prettyCapacity, virshReportError, editWriteToTempFile, editFile):
Fix naming, and adjust usage.
(vshAskReedit, vshCommandRun, vshEventLoop, vshInit): Adjust
usage.
* tools/virsh-domain.c (cmdAttachDevice, cmdCPUCompare)
(cmdCPUBaseline, cmdCreate, cmdDefine, cmdDetachDevice)
(cmdUpdateDevice, cmdDesc, cmdUndefine, cmdStart, cmdVcpucount)
(cmdAttachDevice, cmdDomjobinfo): Likewise.
* tools/virsh-edit.c (do): Likewise.
* tools/virsh-interface.c (cmdInterfaceDefine): Likewise.
* tools/virsh-network.c (cmdNetworkCreate, cmdNetworkDefine):
Likewise.
* tools/virsh-nodedev.c (cmdNodeDeviceCreate): Likewise.
* tools/virsh-nwfilter.c (cmdNWFilterDefine): Likewise.
* tools/virsh-pool.c (cmdPoolCreate, cmdPoolDefine)
(cmdPoolDiscoverSources, cmdPoolList): Likewise.
* tools/virsh-secret.c (cmdSecretDefine): Likewise.
* tools/virsh-snapshot.c (cmdSnapshotCreate, vshSnapshotCreate)
(vshLookupSnapshot, cmdSnapshotEdit, cmdSnapshotCurrent)
(vshGetSnapshotParent): Likewise.
* tools/virsh-volume.c (cmdVolCreate, cmdVolCreateFrom)
(cmdVolInfo, cmdVolList): Likewise.
2012-08-19 08:10:17 +04:00
val = vshPrettyCapacity ( info . available , & unit ) ;
2012-07-24 12:49:27 +04:00
vshPrint ( ctl , " %-15s %2.2lf %s \n " , _ ( " Available: " ) , val , unit ) ;
}
} else {
ret = false ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-name " command
*/
static const vshCmdInfo info_pool_name [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " convert a pool UUID to pool name " )
} ,
{ . name = " desc " ,
. data = " "
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_name [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool uuid " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolName ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
if ( ! ( pool = vshCommandOptPoolBy ( ctl , cmd , " pool " , NULL ,
VSH_BYUUID ) ) )
return false ;
vshPrint ( ctl , " %s \n " , virStoragePoolGetName ( pool ) ) ;
virStoragePoolFree ( pool ) ;
return true ;
}
/*
* " pool-start " command
*/
static const vshCmdInfo info_pool_start [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " start a (previously defined) inactive pool " )
} ,
{ . name = " desc " ,
. data = N_ ( " Start a pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_start [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " name or uuid of the inactive pool " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolStart ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
bool ret = true ;
const char * name = NULL ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return false ;
if ( virStoragePoolCreate ( pool , 0 ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s started \n " ) , name ) ;
} else {
vshError ( ctl , _ ( " Failed to start pool %s " ) , name ) ;
ret = false ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-undefine " command
*/
static const vshCmdInfo info_pool_undefine [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " undefine an inactive pool " )
} ,
{ . name = " desc " ,
. data = N_ ( " Undefine the configuration for an inactive pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_undefine [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolUndefine ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
bool ret = true ;
const char * name ;
if ( ! ( pool = vshCommandOptPool ( ctl , cmd , " pool " , & name ) ) )
return false ;
if ( virStoragePoolUndefine ( pool ) = = 0 ) {
vshPrint ( ctl , _ ( " Pool %s has been undefined \n " ) , name ) ;
} else {
vshError ( ctl , _ ( " Failed to undefine pool %s " ) , name ) ;
ret = false ;
}
virStoragePoolFree ( pool ) ;
return ret ;
}
/*
* " pool-uuid " command
*/
static const vshCmdInfo info_pool_uuid [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " convert a pool name to pool UUID " )
} ,
{ . name = " desc " ,
. data = " "
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_uuid [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolUuid ( vshControl * ctl , const vshCmd * cmd )
{
virStoragePoolPtr pool ;
char uuid [ VIR_UUID_STRING_BUFLEN ] ;
if ( ! ( pool = vshCommandOptPoolBy ( ctl , cmd , " pool " , NULL ,
VSH_BYNAME ) ) )
return false ;
if ( virStoragePoolGetUUIDString ( pool , uuid ) ! = - 1 )
vshPrint ( ctl , " %s \n " , uuid ) ;
else
vshError ( ctl , " %s " , _ ( " failed to get pool UUID " ) ) ;
virStoragePoolFree ( pool ) ;
return true ;
}
/*
* " pool-edit " command
*/
static const vshCmdInfo info_pool_edit [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " help " ,
. data = N_ ( " edit XML configuration for a storage pool " )
} ,
{ . name = " desc " ,
. data = N_ ( " Edit the XML configuration for a storage pool. " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static const vshCmdOptDef opts_pool_edit [ ] = {
2013-01-14 18:36:53 +04:00
{ . name = " pool " ,
. type = VSH_OT_DATA ,
. flags = VSH_OFLAG_REQ ,
. help = N_ ( " pool name or uuid " )
} ,
{ . name = NULL }
2012-07-24 12:49:27 +04:00
} ;
static bool
cmdPoolEdit ( vshControl * ctl , const vshCmd * cmd )
{
bool ret = false ;
virStoragePoolPtr pool = NULL ;
virStoragePoolPtr pool_edited = NULL ;
unsigned int flags = VIR_STORAGE_XML_INACTIVE ;
char * tmp_desc = NULL ;
pool = vshCommandOptPool ( ctl , cmd , " pool " , NULL ) ;
if ( pool = = NULL )
goto cleanup ;
/* Some old daemons don't support _INACTIVE flag */
if ( ! ( tmp_desc = virStoragePoolGetXMLDesc ( pool , flags ) ) ) {
if ( last_error - > code = = VIR_ERR_INVALID_ARG ) {
flags & = ~ VIR_STORAGE_XML_INACTIVE ;
2012-07-25 15:41:49 +04:00
vshResetLibvirtError ( ) ;
2012-07-24 12:49:27 +04:00
} else {
goto cleanup ;
}
} else {
VIR_FREE ( tmp_desc ) ;
}
# define EDIT_GET_XML virStoragePoolGetXMLDesc(pool, flags)
# define EDIT_NOT_CHANGED \
vshPrint ( ctl , _ ( " Pool %s XML configuration not changed. \n " ) , \
virStoragePoolGetName ( pool ) ) ; \
ret = true ; goto edit_cleanup ;
# define EDIT_DEFINE \
( pool_edited = virStoragePoolDefineXML ( ctl - > conn , doc_edited , 0 ) )
# define EDIT_FREE \
if ( pool_edited ) \
virStoragePoolFree ( pool_edited ) ;
# include "virsh-edit.c"
vshPrint ( ctl , _ ( " Pool %s XML configuration edited. \n " ) ,
virStoragePoolGetName ( pool_edited ) ) ;
ret = true ;
cleanup :
if ( pool )
virStoragePoolFree ( pool ) ;
if ( pool_edited )
virStoragePoolFree ( pool_edited ) ;
return ret ;
}
2012-07-23 11:19:04 +04:00
2012-08-21 02:56:53 +04:00
const vshCmdDef storagePoolCmds [ ] = {
2013-02-07 19:25:10 +04:00
{ . name = " find-storage-pool-sources-as " ,
. handler = cmdPoolDiscoverSourcesAs ,
. opts = opts_find_storage_pool_sources_as ,
. info = info_find_storage_pool_sources_as ,
. flags = 0
} ,
{ . name = " find-storage-pool-sources " ,
. handler = cmdPoolDiscoverSources ,
. opts = opts_find_storage_pool_sources ,
. info = info_find_storage_pool_sources ,
. flags = 0
} ,
{ . name = " pool-autostart " ,
. handler = cmdPoolAutostart ,
. opts = opts_pool_autostart ,
. info = info_pool_autostart ,
. flags = 0
} ,
{ . name = " pool-build " ,
. handler = cmdPoolBuild ,
. opts = opts_pool_build ,
. info = info_pool_build ,
. flags = 0
} ,
{ . name = " pool-create-as " ,
. handler = cmdPoolCreateAs ,
. opts = opts_pool_X_as ,
. info = info_pool_create_as ,
. flags = 0
} ,
{ . name = " pool-create " ,
. handler = cmdPoolCreate ,
. opts = opts_pool_create ,
. info = info_pool_create ,
. flags = 0
} ,
{ . name = " pool-define-as " ,
. handler = cmdPoolDefineAs ,
. opts = opts_pool_X_as ,
. info = info_pool_define_as ,
. flags = 0
} ,
{ . name = " pool-define " ,
. handler = cmdPoolDefine ,
. opts = opts_pool_define ,
. info = info_pool_define ,
. flags = 0
} ,
{ . name = " pool-delete " ,
. handler = cmdPoolDelete ,
. opts = opts_pool_delete ,
. info = info_pool_delete ,
. flags = 0
} ,
{ . name = " pool-destroy " ,
. handler = cmdPoolDestroy ,
. opts = opts_pool_destroy ,
. info = info_pool_destroy ,
. flags = 0
} ,
{ . name = " pool-dumpxml " ,
. handler = cmdPoolDumpXML ,
. opts = opts_pool_dumpxml ,
. info = info_pool_dumpxml ,
. flags = 0
} ,
{ . name = " pool-edit " ,
. handler = cmdPoolEdit ,
. opts = opts_pool_edit ,
. info = info_pool_edit ,
. flags = 0
} ,
{ . name = " pool-info " ,
. handler = cmdPoolInfo ,
. opts = opts_pool_info ,
. info = info_pool_info ,
. flags = 0
} ,
{ . name = " pool-list " ,
. handler = cmdPoolList ,
. opts = opts_pool_list ,
. info = info_pool_list ,
. flags = 0
} ,
{ . name = " pool-name " ,
. handler = cmdPoolName ,
. opts = opts_pool_name ,
. info = info_pool_name ,
. flags = 0
} ,
{ . name = " pool-refresh " ,
. handler = cmdPoolRefresh ,
. opts = opts_pool_refresh ,
. info = info_pool_refresh ,
. flags = 0
} ,
{ . name = " pool-start " ,
. handler = cmdPoolStart ,
. opts = opts_pool_start ,
. info = info_pool_start ,
. flags = 0
} ,
{ . name = " pool-undefine " ,
. handler = cmdPoolUndefine ,
. opts = opts_pool_undefine ,
. info = info_pool_undefine ,
. flags = 0
} ,
{ . name = " pool-uuid " ,
. handler = cmdPoolUuid ,
. opts = opts_pool_uuid ,
. info = info_pool_uuid ,
. flags = 0
} ,
{ . name = NULL }
2012-07-23 11:19:04 +04:00
} ;