2001-10-16 20:25:28 +04:00
/*
2004-03-30 23:35:44 +04:00
* Copyright ( C ) 2001 - 2004 Sistina Software , Inc . All rights reserved .
* Copyright ( C ) 2004 Red Hat , Inc . All rights reserved .
2001-10-16 20:25:28 +04:00
*
2004-03-30 23:35:44 +04:00
* This file is part of LVM2 .
2001-10-16 20:25:28 +04:00
*
2004-03-30 23:35:44 +04:00
* This copyrighted material is made available to anyone wishing to use ,
* modify , copy , or redistribute it subject to the terms and conditions
* of the GNU General Public License v .2 .
2001-10-16 20:25:28 +04:00
*
* You should have received a copy of the GNU General Public License
2004-03-30 23:35:44 +04:00
* along with this program ; if not , write to the Free Software Foundation ,
* Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
2001-10-16 20:25:28 +04:00
*/
# include "tools.h"
2006-05-12 23:16:48 +04:00
static int _register_lvs_in_vg ( struct cmd_context * cmd ,
struct volume_group * vg , int reg )
{
struct lv_list * lvl ;
struct logical_volume * lv ;
struct lvinfo info ;
int lv_active ;
int count = 0 ;
int r ;
list_iterate_items ( lvl , & vg - > lvs ) {
lv = lvl - > lv ;
if ( ! lv_info ( cmd , lv , & info , 0 ) )
lv_active = 0 ;
else
lv_active = info . exists ;
/*
* FIXME : Need to consider all cases . . . PVMOVE , etc
*/
if ( ( lv - > status & PVMOVE ) | | ! lv_active )
continue ;
r = register_dev_for_events ( cmd , lv , reg ) ;
if ( r < 0 ) {
log_error ( " Failed to %s logical volume, %s " ,
( reg ) ? " register " : " unregister " ,
lv - > name ) ;
continue ;
}
if ( r )
count + + ;
}
/*
* returns the number of monitored devices , not the number
* of _new_ monitored devices
*/
return count ;
}
2002-03-01 22:08:11 +03:00
static int _activate_lvs_in_vg ( struct cmd_context * cmd ,
2004-05-05 16:03:07 +04:00
struct volume_group * vg , int activate )
2002-03-01 22:08:11 +03:00
{
2003-10-16 00:02:46 +04:00
struct lv_list * lvl ;
2002-03-01 22:08:11 +03:00
struct logical_volume * lv ;
2004-05-05 21:56:20 +04:00
const char * pvname ;
2002-03-01 22:08:11 +03:00
int count = 0 ;
2003-10-16 00:02:46 +04:00
list_iterate_items ( lvl , & vg - > lvs ) {
lv = lvl - > lv ;
2002-03-01 22:08:11 +03:00
2003-05-06 16:14:36 +04:00
/* Only request activation of snapshot origin devices */
2005-04-07 16:39:44 +04:00
if ( ( lv - > status & SNAPSHOT ) | | lv_is_cow ( lv ) )
2002-03-18 16:09:27 +03:00
continue ;
2005-06-01 20:51:55 +04:00
/* Can't deactive a pvmove or log LV */
2004-06-16 21:13:41 +04:00
/* FIXME There needs to be a controlled way of doing this */
if ( ( ( activate = = CHANGE_AN ) | | ( activate = = CHANGE_ALN ) ) & &
2005-06-01 20:51:55 +04:00
( ( lv - > status & PVMOVE ) | | ( lv - > status & MIRROR_LOG ) ) )
2003-05-06 16:14:36 +04:00
continue ;
2004-06-16 21:13:41 +04:00
if ( activate = = CHANGE_AN ) {
2005-08-15 16:00:04 +04:00
if ( ! deactivate_lv ( cmd , lv ) )
2004-05-05 16:03:07 +04:00
continue ;
2004-06-16 21:13:41 +04:00
} else if ( activate = = CHANGE_ALN ) {
2005-08-15 16:00:04 +04:00
if ( ! deactivate_lv_local ( cmd , lv ) )
2004-06-16 21:13:41 +04:00
continue ;
} else if ( lv_is_origin ( lv ) | | ( activate = = CHANGE_AE ) ) {
2005-08-15 16:00:04 +04:00
if ( ! activate_lv_excl ( cmd , lv ) )
2004-05-05 16:03:07 +04:00
continue ;
2004-06-16 21:13:41 +04:00
} else if ( activate = = CHANGE_ALY ) {
2005-08-15 16:00:04 +04:00
if ( ! activate_lv_local ( cmd , lv ) )
2004-06-16 21:13:41 +04:00
continue ;
2005-08-15 16:00:04 +04:00
} else if ( ! activate_lv ( cmd , lv ) )
2002-03-01 22:08:11 +03:00
continue ;
2003-05-06 16:14:36 +04:00
if ( ( lv - > status & PVMOVE ) & &
2004-05-05 21:56:20 +04:00
( pvname = get_pvmove_pvname_from_lv_mirr ( lv ) ) ) {
2003-05-06 16:14:36 +04:00
log_verbose ( " Spawning background process for %s %s " ,
2004-05-05 21:56:20 +04:00
lv - > name , pvname ) ;
pvmove_poll ( cmd , pvname , 1 ) ;
2003-05-06 16:14:36 +04:00
continue ;
}
2002-03-01 22:08:11 +03:00
count + + ;
}
return count ;
}
2006-05-12 23:16:48 +04:00
static int _vgchange_monitoring ( struct cmd_context * cmd , struct volume_group * vg )
{
int active , monitored ;
if ( ( active = lvs_in_vg_activated ( vg ) ) ) {
monitored = _register_lvs_in_vg ( cmd , vg , dmeventd_register_mode ( ) ) ;
log_print ( " %d logical volume(s) in volume group "
" \" %s \" now %smonitored " ,
monitored , vg - > name , ( dmeventd_register_mode ( ) ) ? " " : " un " ) ;
}
return ECMD_PROCESSED ;
}
2004-05-05 01:25:57 +04:00
static int _vgchange_available ( struct cmd_context * cmd , struct volume_group * vg )
2001-10-16 20:25:28 +04:00
{
2006-05-12 23:16:48 +04:00
int lv_open , active , monitored ;
2004-05-24 17:44:10 +04:00
int available ;
2004-06-24 18:48:01 +04:00
int activate = 1 ;
2004-05-24 17:44:10 +04:00
available = arg_uint_value ( cmd , available_ARG , 0 ) ;
2001-10-16 20:25:28 +04:00
2004-06-24 18:48:01 +04:00
if ( ( available = = CHANGE_AN ) | | ( available = = CHANGE_ALN ) )
activate = 0 ;
2001-10-16 20:25:28 +04:00
/* FIXME: Force argument to deactivate them? */
2004-06-24 18:48:01 +04:00
if ( ! activate & & ( lv_open = lvs_in_vg_opened ( vg ) ) ) {
2002-01-30 18:04:48 +03:00
log_error ( " Can't deactivate volume group \" %s \" with %d open "
2001-10-16 20:25:28 +04:00
" logical volume(s) " , vg - > name , lv_open ) ;
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2001-10-16 20:25:28 +04:00
}
2005-03-22 01:55:12 +03:00
if ( activate & & lockingfailed ( ) & & ( vg - > status & CLUSTERED ) ) {
log_error ( " Locking inactive: ignoring clustered "
" volume group %s " , vg - > name ) ;
return ECMD_FAILED ;
}
2005-05-17 17:44:02 +04:00
/* FIXME Move into library where clvmd can use it */
if ( activate & & ! lockingfailed ( ) )
check_current_backup ( vg ) ;
2006-05-12 23:16:48 +04:00
if ( activate & & ( active = lvs_in_vg_activated ( vg ) ) ) {
2002-01-30 18:04:48 +03:00
log_verbose ( " %d logical volume(s) in volume group \" %s \" "
2002-03-01 22:08:11 +03:00
" already active " , active , vg - > name ) ;
2006-05-12 23:16:48 +04:00
monitored = _register_lvs_in_vg ( cmd , vg , dmeventd_register_mode ( ) ) ;
log_verbose ( " %d existing logical volume(s) in volume "
" group \" %s \" now %smonitored " ,
monitored , vg - > name ,
dmeventd_register_mode ( ) ? " " : " un " ) ;
}
2001-11-21 22:32:35 +03:00
2004-06-24 18:48:01 +04:00
if ( activate & & _activate_lvs_in_vg ( cmd , vg , available ) )
2002-03-01 22:08:11 +03:00
log_verbose ( " Activated logical volumes in "
" volume group \" %s \" " , vg - > name ) ;
2001-10-16 20:25:28 +04:00
2004-06-24 18:48:01 +04:00
if ( ! activate & & _activate_lvs_in_vg ( cmd , vg , available ) )
2002-03-01 22:08:11 +03:00
log_verbose ( " Deactivated logical volumes in "
" volume group \" %s \" " , vg - > name ) ;
2001-10-16 20:25:28 +04:00
2002-01-30 18:04:48 +03:00
log_print ( " %d logical volume(s) in volume group \" %s \" now active " ,
2002-01-22 22:58:37 +03:00
lvs_in_vg_activated ( vg ) , vg - > name ) ;
2003-10-22 02:06:07 +04:00
return ECMD_PROCESSED ;
2001-10-16 20:25:28 +04:00
}
2004-05-19 02:12:53 +04:00
static int _vgchange_alloc ( struct cmd_context * cmd , struct volume_group * vg )
{
alloc_policy_t alloc ;
2006-05-10 01:23:51 +04:00
alloc = arg_uint_value ( cmd , alloc_ARG , ALLOC_NORMAL ) ;
2004-05-19 02:12:53 +04:00
if ( alloc = = ALLOC_INHERIT ) {
log_error ( " Volume Group allocation policy cannot inherit "
2004-06-16 21:13:41 +04:00
" from anything " ) ;
2004-05-19 02:12:53 +04:00
return EINVALID_CMD_LINE ;
}
if ( alloc = = vg - > alloc ) {
log_error ( " Volume group allocation policy is already %s " ,
get_alloc_string ( vg - > alloc ) ) ;
return ECMD_FAILED ;
}
if ( ! archive ( vg ) )
return ECMD_FAILED ;
vg - > alloc = alloc ;
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) )
return ECMD_FAILED ;
backup ( vg ) ;
log_print ( " Volume group \" %s \" successfully changed " , vg - > name ) ;
return ECMD_PROCESSED ;
}
2003-10-22 02:06:07 +04:00
static int _vgchange_resizeable ( struct cmd_context * cmd ,
struct volume_group * vg )
2001-10-16 20:25:28 +04:00
{
2002-02-12 00:00:35 +03:00
int resizeable = ! strcmp ( arg_str_value ( cmd , resizeable_ARG , " n " ) , " y " ) ;
2001-10-16 20:25:28 +04:00
2002-01-10 18:09:51 +03:00
if ( resizeable & & ( vg - > status & RESIZEABLE_VG ) ) {
2002-02-12 00:00:35 +03:00
log_error ( " Volume group \" %s \" is already resizeable " ,
vg - > name ) ;
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2001-10-16 20:25:28 +04:00
}
2002-01-10 18:09:51 +03:00
if ( ! resizeable & & ! ( vg - > status & RESIZEABLE_VG ) ) {
2002-01-30 18:04:48 +03:00
log_error ( " Volume group \" %s \" is already not resizeable " ,
2001-10-16 20:25:28 +04:00
vg - > name ) ;
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2001-10-16 20:25:28 +04:00
}
2002-01-09 16:17:14 +03:00
if ( ! archive ( vg ) )
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2002-01-09 16:17:14 +03:00
2002-01-10 18:09:51 +03:00
if ( resizeable )
vg - > status | = RESIZEABLE_VG ;
2001-10-16 20:25:28 +04:00
else
2002-01-10 18:09:51 +03:00
vg - > status & = ~ RESIZEABLE_VG ;
2001-10-16 20:25:28 +04:00
2003-07-05 02:34:56 +04:00
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) )
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2001-10-16 20:25:28 +04:00
2002-01-07 14:12:11 +03:00
backup ( vg ) ;
2001-10-16 20:25:28 +04:00
2002-01-30 18:04:48 +03:00
log_print ( " Volume group \" %s \" successfully changed " , vg - > name ) ;
2001-10-16 20:25:28 +04:00
2003-10-22 02:06:07 +04:00
return ECMD_PROCESSED ;
2001-10-16 20:25:28 +04:00
}
2005-03-22 01:55:12 +03:00
static int _vgchange_clustered ( struct cmd_context * cmd ,
struct volume_group * vg )
{
int clustered = ! strcmp ( arg_str_value ( cmd , clustered_ARG , " n " ) , " y " ) ;
2005-08-15 03:18:28 +04:00
struct lv_list * lvl ;
2005-03-22 01:55:12 +03:00
if ( clustered & & ( vg - > status & CLUSTERED ) ) {
log_error ( " Volume group \" %s \" is already clustered " ,
vg - > name ) ;
return ECMD_FAILED ;
}
if ( ! clustered & & ! ( vg - > status & CLUSTERED ) ) {
log_error ( " Volume group \" %s \" is already not clustered " ,
vg - > name ) ;
return ECMD_FAILED ;
}
2005-08-15 03:18:28 +04:00
if ( clustered ) {
list_iterate_items ( lvl , & vg - > lvs ) {
2006-04-06 17:39:16 +04:00
if ( lv_is_origin ( lvl - > lv ) | | lv_is_cow ( lvl - > lv ) ) {
2005-08-15 03:18:28 +04:00
log_error ( " Volume group %s contains snapshots "
" that are not yet supported. " ,
vg - > name ) ;
return ECMD_FAILED ;
}
}
}
2005-03-22 01:55:12 +03:00
if ( ! archive ( vg ) )
return ECMD_FAILED ;
if ( clustered )
vg - > status | = CLUSTERED ;
else
vg - > status & = ~ CLUSTERED ;
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) )
return ECMD_FAILED ;
backup ( vg ) ;
log_print ( " Volume group \" %s \" successfully changed " , vg - > name ) ;
return ECMD_PROCESSED ;
}
2003-10-22 02:06:07 +04:00
static int _vgchange_logicalvolume ( struct cmd_context * cmd ,
struct volume_group * vg )
2001-10-16 20:25:28 +04:00
{
2002-12-20 02:25:55 +03:00
uint32_t max_lv = arg_uint_value ( cmd , logicalvolume_ARG , 0 ) ;
2001-10-16 20:25:28 +04:00
2002-01-10 18:09:51 +03:00
if ( ! ( vg - > status & RESIZEABLE_VG ) ) {
2002-01-30 18:04:48 +03:00
log_error ( " Volume group \" %s \" must be resizeable "
2001-10-16 20:25:28 +04:00
" to change MaxLogicalVolume " , vg - > name ) ;
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2001-10-16 20:25:28 +04:00
}
2003-11-06 23:33:34 +03:00
if ( ! ( vg - > fid - > fmt - > features & FMT_UNLIMITED_VOLS ) ) {
if ( ! max_lv )
max_lv = 255 ;
else if ( max_lv > 255 ) {
log_error ( " MaxLogicalVolume limit is 255 " ) ;
return ECMD_FAILED ;
}
}
if ( max_lv & & max_lv < vg - > lv_count ) {
2001-10-16 20:25:28 +04:00
log_error ( " MaxLogicalVolume is less than the current number "
2006-08-16 18:41:42 +04:00
" %d of LVs for \" %s \" " , vg - > lv_count ,
2001-10-16 20:25:28 +04:00
vg - > name ) ;
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2001-10-16 20:25:28 +04:00
}
2002-01-09 16:17:14 +03:00
if ( ! archive ( vg ) )
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2002-01-09 16:17:14 +03:00
2001-10-16 20:25:28 +04:00
vg - > max_lv = max_lv ;
2003-07-05 02:34:56 +04:00
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) )
2003-10-22 02:06:07 +04:00
return ECMD_FAILED ;
2001-10-16 20:25:28 +04:00
2002-01-07 14:12:11 +03:00
backup ( vg ) ;
2002-01-01 00:27:39 +03:00
2002-01-30 18:04:48 +03:00
log_print ( " Volume group \" %s \" successfully changed " , vg - > name ) ;
2001-10-16 20:25:28 +04:00
2003-10-22 02:06:07 +04:00
return ECMD_PROCESSED ;
2001-10-16 20:25:28 +04:00
}
2002-11-18 17:04:08 +03:00
2006-08-16 18:41:42 +04:00
static int _vgchange_physicalvolumes ( struct cmd_context * cmd ,
struct volume_group * vg )
{
uint32_t max_pv = arg_uint_value ( cmd , maxphysicalvolumes_ARG , 0 ) ;
if ( ! ( vg - > status & RESIZEABLE_VG ) ) {
log_error ( " Volume group \" %s \" must be resizeable "
" to change MaxPhysicalVolumes " , vg - > name ) ;
return ECMD_FAILED ;
}
if ( arg_sign_value ( cmd , maxphysicalvolumes_ARG , 0 ) = = SIGN_MINUS ) {
log_error ( " MaxPhysicalVolumes may not be negative " ) ;
return EINVALID_CMD_LINE ;
}
if ( ! ( vg - > fid - > fmt - > features & FMT_UNLIMITED_VOLS ) ) {
if ( ! max_pv )
max_pv = 255 ;
else if ( max_pv > 255 ) {
log_error ( " MaxPhysicalVolume limit is 255 " ) ;
return ECMD_FAILED ;
}
}
if ( max_pv & & max_pv < vg - > pv_count ) {
log_error ( " MaxPhysicalVolumes is less than the current number "
" %d of PVs for \" %s \" " , vg - > pv_count ,
vg - > name ) ;
return ECMD_FAILED ;
}
if ( ! archive ( vg ) )
return ECMD_FAILED ;
vg - > max_pv = max_pv ;
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) )
return ECMD_FAILED ;
backup ( vg ) ;
log_print ( " Volume group \" %s \" successfully changed " , vg - > name ) ;
return ECMD_PROCESSED ;
}
2005-04-18 18:56:42 +04:00
static int _vgchange_pesize ( struct cmd_context * cmd , struct volume_group * vg )
{
uint32_t extent_size ;
if ( ! ( vg - > status & RESIZEABLE_VG ) ) {
log_error ( " Volume group \" %s \" must be resizeable "
" to change PE size " , vg - > name ) ;
return ECMD_FAILED ;
}
if ( arg_sign_value ( cmd , physicalextentsize_ARG , 0 ) = = SIGN_MINUS ) {
log_error ( " Physical extent size may not be negative " ) ;
return EINVALID_CMD_LINE ;
}
extent_size = arg_uint_value ( cmd , physicalextentsize_ARG , 0 ) * 2 ;
if ( ! extent_size ) {
log_error ( " Physical extent size may not be zero " ) ;
return EINVALID_CMD_LINE ;
}
if ( extent_size = = vg - > extent_size ) {
log_error ( " Physical extent size of VG %s is already %s " ,
2006-05-10 01:23:51 +04:00
vg - > name , display_size ( cmd , ( uint64_t ) extent_size ) ) ;
2005-04-18 18:56:42 +04:00
return ECMD_PROCESSED ;
}
if ( extent_size & ( extent_size - 1 ) ) {
log_error ( " Physical extent size must be a power of 2. " ) ;
return EINVALID_CMD_LINE ;
}
if ( extent_size > vg - > extent_size ) {
if ( ( uint64_t ) vg - > extent_size * vg - > extent_count % extent_size ) {
/* FIXME Adjust used PV sizes instead */
log_error ( " New extent size is not a perfect fit " ) ;
return EINVALID_CMD_LINE ;
}
}
if ( ! archive ( vg ) )
return ECMD_FAILED ;
if ( ! vg_change_pesize ( cmd , vg , extent_size ) ) {
stack ;
return ECMD_FAILED ;
}
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) )
return ECMD_FAILED ;
backup ( vg ) ;
log_print ( " Volume group \" %s \" successfully changed " , vg - > name ) ;
return ECMD_PROCESSED ;
}
2004-03-08 20:19:15 +03:00
static int _vgchange_tag ( struct cmd_context * cmd , struct volume_group * vg ,
int arg )
{
const char * tag ;
if ( ! ( tag = arg_str_value ( cmd , arg , NULL ) ) ) {
log_error ( " Failed to get tag " ) ;
return ECMD_FAILED ;
}
if ( ! ( vg - > fid - > fmt - > features & FMT_TAGS ) ) {
log_error ( " Volume group %s does not support tags " , vg - > name ) ;
return ECMD_FAILED ;
}
if ( ! archive ( vg ) )
return ECMD_FAILED ;
if ( ( arg = = addtag_ARG ) ) {
if ( ! str_list_add ( cmd - > mem , & vg - > tags , tag ) ) {
log_error ( " Failed to add tag %s to volume group %s " ,
tag , vg - > name ) ;
return ECMD_FAILED ;
}
} else {
if ( ! str_list_del ( & vg - > tags , tag ) ) {
log_error ( " Failed to remove tag %s from volume group "
" %s " , tag , vg - > name ) ;
return ECMD_FAILED ;
}
}
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) )
return ECMD_FAILED ;
backup ( vg ) ;
log_print ( " Volume group \" %s \" successfully changed " , vg - > name ) ;
return ECMD_PROCESSED ;
}
2006-05-10 01:23:51 +04:00
static int _vgchange_uuid ( struct cmd_context * cmd __attribute ( ( unused ) ) ,
struct volume_group * vg )
2004-01-13 21:42:05 +03:00
{
struct lv_list * lvl ;
if ( lvs_in_vg_activated ( vg ) ) {
log_error ( " Volume group has active logical volumes " ) ;
return ECMD_FAILED ;
}
if ( ! archive ( vg ) )
return ECMD_FAILED ;
2005-01-20 21:11:53 +03:00
if ( ! id_create ( & vg - > id ) ) {
log_error ( " Failed to generate new random UUID for VG %s. " ,
vg - > name ) ;
return ECMD_FAILED ;
}
2004-01-13 21:42:05 +03:00
list_iterate_items ( lvl , & vg - > lvs ) {
memcpy ( & lvl - > lv - > lvid , & vg - > id , sizeof ( vg - > id ) ) ;
}
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) )
return ECMD_FAILED ;
backup ( vg ) ;
log_print ( " Volume group \" %s \" successfully changed " , vg - > name ) ;
return ECMD_PROCESSED ;
}
2002-11-18 17:04:08 +03:00
static int vgchange_single ( struct cmd_context * cmd , const char * vg_name ,
struct volume_group * vg , int consistent ,
2006-05-10 01:23:51 +04:00
void * handle __attribute ( ( unused ) ) )
2002-11-18 17:04:08 +03:00
{
2004-03-08 20:19:15 +03:00
int r = ECMD_FAILED ;
2003-10-22 02:06:07 +04:00
2002-11-18 17:04:08 +03:00
if ( ! vg ) {
log_error ( " Unable to find volume group \" %s \" " , vg_name ) ;
return ECMD_FAILED ;
}
if ( ! consistent ) {
unlock_vg ( cmd , vg_name ) ;
2003-11-21 22:54:40 +03:00
dev_close_all ( ) ;
2002-11-18 17:04:08 +03:00
log_error ( " Volume group \" %s \" inconsistent " , vg_name ) ;
if ( ! ( vg = recover_vg ( cmd , vg_name , LCK_VG_WRITE ) ) )
return ECMD_FAILED ;
}
if ( ! ( vg - > status & LVM_WRITE ) & & ! arg_count ( cmd , available_ARG ) ) {
log_error ( " Volume group \" %s \" is read-only " , vg - > name ) ;
return ECMD_FAILED ;
}
if ( vg - > status & EXPORTED_VG ) {
log_error ( " Volume group \" %s \" is exported " , vg_name ) ;
return ECMD_FAILED ;
}
2006-05-12 23:16:48 +04:00
init_dmeventd_register ( arg_int_value ( cmd , monitor_ARG , DEFAULT_DMEVENTD_MONITOR ) ) ;
2002-11-18 17:04:08 +03:00
if ( arg_count ( cmd , available_ARG ) )
2003-10-22 02:06:07 +04:00
r = _vgchange_available ( cmd , vg ) ;
2002-11-18 17:04:08 +03:00
2006-05-12 23:16:48 +04:00
else if ( arg_count ( cmd , monitor_ARG ) )
r = _vgchange_monitoring ( cmd , vg ) ;
2003-10-22 02:06:07 +04:00
else if ( arg_count ( cmd , resizeable_ARG ) )
r = _vgchange_resizeable ( cmd , vg ) ;
2002-11-18 17:04:08 +03:00
2003-10-22 02:06:07 +04:00
else if ( arg_count ( cmd , logicalvolume_ARG ) )
r = _vgchange_logicalvolume ( cmd , vg ) ;
2002-11-18 17:04:08 +03:00
2006-08-16 18:41:42 +04:00
else if ( arg_count ( cmd , maxphysicalvolumes_ARG ) )
r = _vgchange_physicalvolumes ( cmd , vg ) ;
2004-03-08 20:19:15 +03:00
else if ( arg_count ( cmd , addtag_ARG ) )
r = _vgchange_tag ( cmd , vg , addtag_ARG ) ;
else if ( arg_count ( cmd , deltag_ARG ) )
r = _vgchange_tag ( cmd , vg , deltag_ARG ) ;
2005-04-18 18:56:42 +04:00
else if ( arg_count ( cmd , physicalextentsize_ARG ) )
r = _vgchange_pesize ( cmd , vg ) ;
2004-01-13 21:42:05 +03:00
else if ( arg_count ( cmd , uuid_ARG ) )
r = _vgchange_uuid ( cmd , vg ) ;
2004-05-19 02:12:53 +04:00
else if ( arg_count ( cmd , alloc_ARG ) )
r = _vgchange_alloc ( cmd , vg ) ;
2005-03-22 01:55:12 +03:00
else if ( arg_count ( cmd , clustered_ARG ) )
r = _vgchange_clustered ( cmd , vg ) ;
2003-10-22 02:06:07 +04:00
return r ;
2002-11-18 17:04:08 +03:00
}
int vgchange ( struct cmd_context * cmd , int argc , char * * argv )
{
if ( !
( arg_count ( cmd , available_ARG ) + arg_count ( cmd , logicalvolume_ARG ) +
2006-08-16 18:41:42 +04:00
arg_count ( cmd , maxphysicalvolumes_ARG ) +
2004-03-08 20:19:15 +03:00
arg_count ( cmd , resizeable_ARG ) + arg_count ( cmd , deltag_ARG ) +
2004-05-19 02:12:53 +04:00
arg_count ( cmd , addtag_ARG ) + arg_count ( cmd , uuid_ARG ) +
2005-04-18 18:56:42 +04:00
arg_count ( cmd , physicalextentsize_ARG ) +
2006-05-12 23:16:48 +04:00
arg_count ( cmd , clustered_ARG ) + arg_count ( cmd , alloc_ARG ) +
arg_count ( cmd , monitor_ARG ) ) ) {
2006-08-16 18:41:42 +04:00
log_error ( " One of -a, -c, -l, -p, -s, -x, --uuid, --alloc, "
" --addtag or --deltag required " ) ;
2002-11-18 17:04:08 +03:00
return EINVALID_CMD_LINE ;
}
2004-05-19 02:12:53 +04:00
/* FIXME Cope with several changes at once! */
2002-11-18 17:04:08 +03:00
if ( arg_count ( cmd , available_ARG ) + arg_count ( cmd , logicalvolume_ARG ) +
2006-08-16 18:41:42 +04:00
arg_count ( cmd , maxphysicalvolumes_ARG ) +
2004-03-08 20:19:15 +03:00
arg_count ( cmd , resizeable_ARG ) + arg_count ( cmd , deltag_ARG ) +
2004-05-19 02:12:53 +04:00
arg_count ( cmd , addtag_ARG ) + arg_count ( cmd , alloc_ARG ) +
2005-04-18 18:56:42 +04:00
arg_count ( cmd , uuid_ARG ) + arg_count ( cmd , clustered_ARG ) +
arg_count ( cmd , physicalextentsize_ARG ) > 1 ) {
2006-08-16 18:41:42 +04:00
log_error ( " Only one of -a, -c, -l, -p, -s, -x, --uuid, "
" --alloc, --addtag or --deltag allowed " ) ;
2002-11-18 17:04:08 +03:00
return EINVALID_CMD_LINE ;
}
if ( arg_count ( cmd , ignorelockingfailure_ARG ) & &
! arg_count ( cmd , available_ARG ) ) {
log_error ( " --ignorelockingfailure only available with -a " ) ;
return EINVALID_CMD_LINE ;
}
if ( arg_count ( cmd , available_ARG ) = = 1
& & arg_count ( cmd , autobackup_ARG ) ) {
log_error ( " -A option not necessary with -a option " ) ;
return EINVALID_CMD_LINE ;
}
return process_each_vg ( cmd , argc , argv ,
( arg_count ( cmd , available_ARG ) ) ?
LCK_VG_READ : LCK_VG_WRITE , 0 , NULL ,
& vgchange_single ) ;
}