2001-10-16 20:25:28 +04:00
/*
2008-01-30 17:00:02 +03:00
* Copyright ( C ) 2001 - 2004 Sistina Software , Inc . All rights reserved .
2007-08-21 00:55:30 +04:00
* Copyright ( C ) 2004 - 2007 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
2007-08-21 00:55:30 +04:00
* of the GNU Lesser General Public License v .2 .1 .
2001-10-16 20:25:28 +04:00
*
2007-08-21 00:55:30 +04:00
* You should have received a copy of the GNU Lesser 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"
2007-01-20 01:21:45 +03:00
static int _monitor_lvs_in_vg ( struct cmd_context * cmd ,
2006-05-12 23:16:48 +04:00
struct volume_group * vg , int reg )
{
struct lv_list * lvl ;
struct logical_volume * lv ;
struct lvinfo info ;
int lv_active ;
int count = 0 ;
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( lvl , & vg - > lvs ) {
2006-05-12 23:16:48 +04:00
lv = lvl - > lv ;
2007-11-12 23:51:54 +03:00
if ( ! lv_info ( cmd , lv , & info , 0 , 0 ) )
2006-05-12 23:16:48 +04:00
lv_active = 0 ;
else
lv_active = info . exists ;
/*
* FIXME : Need to consider all cases . . . PVMOVE , etc
*/
if ( ( lv - > status & PVMOVE ) | | ! lv_active )
continue ;
2007-01-20 01:21:45 +03:00
if ( ! monitor_dev_for_events ( cmd , lv , reg ) ) {
2006-05-12 23:16:48 +04:00
continue ;
2007-01-20 01:21:45 +03:00
} else
2006-05-12 23:16:48 +04:00
count + + ;
}
/*
2007-01-12 23:38:30 +03:00
* returns the number of _new_ monitored devices
2006-05-12 23:16:48 +04:00
*/
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 ;
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( lvl , & vg - > lvs ) {
2003-10-16 00:02:46 +04:00
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 ;
2008-06-12 15:49:46 +04:00
/* Only request activation of mirror LV */
if ( ( lv - > status & MIRROR_IMAGE ) | | ( lv - > status & MIRROR_LOG ) )
continue ;
/* Can't deactivate a pvmove 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 ) ) & &
2008-06-12 15:49:46 +04:00
( ( lv - > status & PVMOVE ) ) )
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 ;
2007-01-25 02:43:27 +03:00
if ( ( active = lvs_in_vg_activated ( vg ) ) & &
dmeventd_monitor_mode ( ) ! = DMEVENTD_MONITOR_IGNORE ) {
2007-01-20 01:21:45 +03:00
monitored = _monitor_lvs_in_vg ( cmd , vg , dmeventd_monitor_mode ( ) ) ;
2006-05-12 23:16:48 +04:00
log_print ( " %d logical volume(s) in volume group "
2007-01-12 23:38:30 +03:00
" \" %s \" %smonitored " ,
2007-01-20 01:21:45 +03:00
monitored , vg - > name , ( dmeventd_monitor_mode ( ) ) ? " " : " un " ) ;
2006-05-12 23:16:48 +04:00
}
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
}
2008-04-10 21:09:32 +04:00
if ( activate & & lockingfailed ( ) & & ( vg_is_clustered ( vg ) ) ) {
2005-03-22 01:55:12 +03:00
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 ) ;
2007-01-25 02:43:27 +03:00
if ( dmeventd_monitor_mode ( ) ! = DMEVENTD_MONITOR_IGNORE ) {
monitored = _monitor_lvs_in_vg ( cmd , vg , dmeventd_monitor_mode ( ) ) ;
log_verbose ( " %d existing logical volume(s) in volume "
" group \" %s \" %smonitored " ,
monitored , vg - > name ,
dmeventd_monitor_mode ( ) ? " " : " un " ) ;
}
2006-05-12 23:16:48 +04:00
}
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
2007-06-19 08:23:32 +04:00
if ( resizeable & & ( vg_status ( vg ) & 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
}
2007-06-19 08:23:32 +04:00
if ( ! resizeable & & ! ( vg_status ( vg ) & 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
2008-04-10 21:09:32 +04:00
if ( clustered & & ( vg_is_clustered ( vg ) ) ) {
2005-03-22 01:55:12 +03:00
log_error ( " Volume group \" %s \" is already clustered " ,
vg - > name ) ;
return ECMD_FAILED ;
}
2008-04-10 21:09:32 +04:00
if ( ! clustered & & ! ( vg_is_clustered ( vg ) ) ) {
2005-03-22 01:55:12 +03:00
log_error ( " Volume group \" %s \" is already not clustered " ,
vg - > name ) ;
return ECMD_FAILED ;
}
2005-08-15 03:18:28 +04:00
if ( clustered ) {
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( lvl , & vg - > lvs ) {
2008-01-30 17:00:02 +03: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
2007-06-19 08:23:32 +04:00
if ( ! ( vg_status ( vg ) & 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 ;
}
}
2009-05-14 01:27:43 +04:00
if ( max_lv & & max_lv < vg_visible_lvs ( vg ) ) {
2001-10-16 20:25:28 +04:00
log_error ( " MaxLogicalVolume is less than the current number "
2009-05-14 01:27:43 +04:00
" %d of LVs for %s " , vg_visible_lvs ( vg ) ,
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 ) ;
2007-06-19 08:23:32 +04:00
if ( ! ( vg_status ( vg ) & RESIZEABLE_VG ) ) {
2006-08-16 18:41:42 +04:00
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 ( arg_sign_value ( cmd , physicalextentsize_ARG , 0 ) = = SIGN_MINUS ) {
log_error ( " Physical extent size may not be negative " ) ;
return EINVALID_CMD_LINE ;
}
2007-11-14 03:08:25 +03:00
extent_size = arg_uint_value ( cmd , physicalextentsize_ARG , 0 ) ;
2009-07-09 14:02:15 +04:00
/* FIXME: remove check - redundant with vg_change_pesize */
2005-04-18 18:56:42 +04:00
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 ( ! archive ( vg ) )
return ECMD_FAILED ;
2009-07-09 14:04:52 +04:00
if ( ! vg_set_extent_size ( vg , extent_size ) ) {
2005-04-18 18:56:42 +04:00
stack ;
2009-07-09 14:02:15 +04:00
return EINVALID_CMD_LINE ;
2005-04-18 18:56:42 +04:00
}
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
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( lvl , & vg - > lvs ) {
2004-01-13 21:42:05 +03:00
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 ;
}
2008-12-22 12:00:51 +03:00
static int _vgchange_refresh ( struct cmd_context * cmd , struct volume_group * vg )
{
log_verbose ( " Refreshing volume group \" %s \" " , vg - > name ) ;
if ( ! vg_refresh_visible ( cmd , vg ) )
return ECMD_FAILED ;
return ECMD_PROCESSED ;
}
2002-11-18 17:04:08 +03:00
static int vgchange_single ( struct cmd_context * cmd , const char * vg_name ,
2009-07-01 21:00:50 +04:00
struct volume_group * vg ,
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
2009-07-01 21:00:50 +04:00
if ( vg_read_error ( vg ) )
2002-11-18 17:04:08 +03:00
return ECMD_FAILED ;
2007-06-19 08:23:32 +04:00
if ( vg_status ( vg ) & EXPORTED_VG ) {
2002-11-18 17:04:08 +03:00
log_error ( " Volume group \" %s \" is exported " , vg_name ) ;
return ECMD_FAILED ;
}
2007-01-25 02:43:27 +03:00
init_dmeventd_monitor ( arg_int_value ( cmd , monitor_ARG ,
2008-12-18 08:27:17 +03:00
( is_static ( ) | | arg_count ( cmd , ignoremonitoring_ARG ) ) ?
2007-01-25 02:43:27 +03:00
DMEVENTD_MONITOR_IGNORE : DEFAULT_DMEVENTD_MONITOR ) ) ;
2006-05-12 23:16:48 +04:00
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 ) ;
2008-12-22 12:00:51 +03:00
else if ( arg_count ( cmd , refresh_ARG ) )
r = _vgchange_refresh ( 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 ) +
2008-12-22 12:00:51 +03:00
arg_count ( cmd , monitor_ARG ) + arg_count ( cmd , refresh_ARG ) ) ) {
log_error ( " One of -a, -c, -l, -p, -s, -x, --refresh, "
" --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 ) ) ?
2009-07-01 21:00:50 +04:00
0 : READ_FOR_UPDATE ,
NULL ,
2002-11-18 17:04:08 +03:00
& vgchange_single ) ;
}