2001-10-12 01:35:55 +04:00
/*
2008-01-30 17:00:02 +03:00
* Copyright ( C ) 2001 - 2004 Sistina Software , Inc . All rights reserved .
2009-02-09 12:45:49 +03:00
* Copyright ( C ) 2004 - 2009 Red Hat , Inc . All rights reserved .
2001-10-12 01:35:55 +04:00
*
2004-03-30 23:35:44 +04:00
* This file is part of LVM2 .
2001-10-12 01:35:55 +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-12 01:35:55 +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-12 01:35:55 +04:00
*/
# include "tools.h"
2005-12-21 21:51:50 +03:00
# include "lv_alloc.h"
2001-10-12 01:35:55 +04:00
2008-09-19 10:42:00 +04:00
static int _remove_pv ( struct volume_group * vg , struct pv_list * pvl , int silent )
2003-01-18 00:04:26 +03:00
{
2010-07-09 19:34:40 +04:00
char uuid [ 64 ] __attribute__ ( ( aligned ( 8 ) ) ) ;
2003-01-18 00:04:26 +03:00
if ( vg - > pv_count = = 1 ) {
log_error ( " Volume Groups must always contain at least one PV " ) ;
return 0 ;
}
2008-01-30 16:19:47 +03:00
if ( ! id_write_format ( & pvl - > pv - > id , uuid , sizeof ( uuid ) ) )
return_0 ;
2003-01-18 00:04:26 +03:00
log_verbose ( " Removing PV with UUID %s from VG %s " , uuid , vg - > name ) ;
if ( pvl - > pv - > pe_alloc_count ) {
2008-09-19 10:42:00 +04:00
if ( ! silent )
log_error ( " LVs still present on PV with UUID %s: "
" Can't remove from VG %s " , uuid , vg - > name ) ;
2003-01-18 00:04:26 +03:00
return 0 ;
}
vg - > free_count - = pvl - > pv - > pe_count ;
vg - > extent_count - = pvl - > pv - > pe_count ;
2010-04-13 21:26:03 +04:00
del_pvl_from_vgs ( vg , pvl ) ;
2003-01-18 00:04:26 +03:00
return 1 ;
}
static int _remove_lv ( struct cmd_context * cmd , struct logical_volume * lv ,
2008-11-04 01:14:30 +03:00
int * list_unsafe , struct dm_list * lvs_changed )
2003-01-18 00:04:26 +03:00
{
2008-01-16 22:00:59 +03:00
struct lv_segment * snap_seg ;
2008-11-04 01:14:30 +03:00
struct dm_list * snh , * snht ;
2005-04-07 16:39:44 +04:00
struct logical_volume * cow ;
2005-12-21 21:51:50 +03:00
struct lv_list * lvl ;
struct lvinfo info ;
2005-12-21 23:24:22 +03:00
int first = 1 ;
2003-01-18 00:04:26 +03:00
log_verbose ( " %s/%s has missing extents: removing (including "
" dependencies) " , lv - > vg - > name , lv - > name ) ;
2005-12-21 21:51:50 +03:00
/* FIXME Cope properly with stacked devices & snapshots. */
2003-01-18 00:04:26 +03:00
2005-12-21 21:51:50 +03:00
/* If snapshot device is missing, deactivate origin. */
if ( lv_is_cow ( lv ) & & ( snap_seg = find_cow ( lv ) ) ) {
2003-01-18 00:04:26 +03:00
log_verbose ( " Deactivating (if active) logical volume %s "
2005-04-07 16:39:44 +04:00
" (origin of %s) " , snap_seg - > origin - > name , lv - > name ) ;
2003-01-18 00:04:26 +03:00
2005-12-21 23:24:22 +03:00
if ( ! test_mode ( ) & & ! deactivate_lv ( cmd , snap_seg - > origin ) ) {
2003-01-18 00:04:26 +03:00
log_error ( " Failed to deactivate LV %s " ,
2005-04-07 16:39:44 +04:00
snap_seg - > origin - > name ) ;
2003-01-18 00:04:26 +03:00
return 0 ;
}
/* Use the origin LV */
2005-04-07 16:39:44 +04:00
lv = snap_seg - > origin ;
2003-01-18 00:04:26 +03:00
}
/* Remove snapshot dependencies */
2008-11-04 01:14:30 +03:00
dm_list_iterate_safe ( snh , snht , & lv - > snapshot_segs ) {
snap_seg = dm_list_struct_base ( snh , struct lv_segment ,
2005-04-07 16:39:44 +04:00
origin_list ) ;
cow = snap_seg - > cow ;
2005-12-21 23:24:22 +03:00
if ( first & & ! test_mode ( ) & &
! deactivate_lv ( cmd , snap_seg - > origin ) ) {
log_error ( " Failed to deactivate LV %s " ,
snap_seg - > origin - > name ) ;
return 0 ;
}
2003-01-18 00:04:26 +03:00
* list_unsafe = 1 ; /* May remove caller's lvht! */
2008-01-30 16:19:47 +03:00
if ( ! vg_remove_snapshot ( cow ) )
return_0 ;
2005-04-07 16:39:44 +04:00
log_verbose ( " Removing LV %s from VG %s " , cow - > name ,
2003-01-18 00:04:26 +03:00
lv - > vg - > name ) ;
2008-01-30 16:19:47 +03:00
if ( ! lv_remove ( cow ) )
return_0 ;
2005-12-21 23:24:22 +03:00
first = 0 ;
2003-01-18 00:04:26 +03:00
}
2005-12-21 21:51:50 +03:00
/*
2008-01-30 17:00:02 +03:00
* If LV is active , replace it with error segment
2005-12-21 21:51:50 +03:00
* and add to list of LVs to be removed later .
* Doesn ' t apply to snapshots / origins yet - they ' re already deactivated .
*/
2006-05-12 23:16:48 +04:00
/*
* If the LV is a part of mirror segment ,
* the mirrored LV also should be cleaned up .
* Clean - up is currently done by caller ( _make_vg_consistent ( ) ) .
*/
2010-08-17 20:25:32 +04:00
if ( ( lv_info ( cmd , lv , 0 , & info , 0 , 0 ) & & info . exists ) | |
2008-01-17 16:54:05 +03:00
find_mirror_seg ( first_seg ( lv ) ) ) {
if ( ! replace_lv_with_error_segment ( lv ) )
return_0 ;
2005-12-21 21:51:50 +03:00
if ( ! ( lvl = dm_pool_alloc ( cmd - > mem , sizeof ( * lvl ) ) ) ) {
log_error ( " lv_list alloc failed " ) ;
return 0 ;
}
lvl - > lv = lv ;
2008-11-04 01:14:30 +03:00
dm_list_add ( lvs_changed , & lvl - > list ) ;
2005-12-21 21:51:50 +03:00
} else {
/* Remove LV immediately. */
log_verbose ( " Removing LV %s from VG %s " , lv - > name , lv - > vg - > name ) ;
2008-01-30 16:19:47 +03:00
if ( ! lv_remove ( lv ) )
return_0 ;
2003-01-18 00:04:26 +03:00
}
return 1 ;
}
2008-09-19 10:42:00 +04:00
static int _consolidate_vg ( struct cmd_context * cmd , struct volume_group * vg )
{
struct pv_list * pvl ;
struct lv_list * lvl ;
int r = 1 ;
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( lvl , & vg - > lvs )
2008-09-19 10:42:00 +04:00
if ( lvl - > lv - > status & PARTIAL_LV ) {
log_warn ( " WARNING: Partial LV %s needs to be repaired "
" or removed. " , lvl - > lv - > name ) ;
r = 0 ;
}
if ( ! r ) {
cmd - > handles_missing_pvs = 1 ;
log_warn ( " WARNING: There are still partial LVs in VG %s. " , vg - > name ) ;
log_warn ( " To remove them unconditionally use: vgreduce --removemissing --force. " ) ;
log_warn ( " Proceeding to remove empty missing PVs. " ) ;
}
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( pvl , & vg - > pvs ) {
2010-03-16 17:37:38 +03:00
if ( pvl - > pv - > dev & & ! is_missing_pv ( pvl - > pv ) )
2008-09-19 10:42:00 +04:00
continue ;
if ( r & & ! _remove_pv ( vg , pvl , 0 ) )
return_0 ;
}
return r ;
}
2003-01-18 00:04:26 +03:00
static int _make_vg_consistent ( struct cmd_context * cmd , struct volume_group * vg )
{
2008-11-04 01:14:30 +03:00
struct dm_list * pvh , * pvht ;
struct dm_list * lvh , * lvht ;
2008-09-19 19:44:03 +04:00
struct pv_list * pvl ;
2006-01-04 21:09:52 +03:00
struct lv_list * lvl , * lvl2 , * lvlt ;
2003-01-18 00:04:26 +03:00
struct logical_volume * lv ;
struct physical_volume * pv ;
2006-01-04 21:09:52 +03:00
struct lv_segment * seg , * mirrored_seg ;
2006-05-10 01:23:51 +04:00
unsigned s ;
2006-05-11 23:01:11 +04:00
uint32_t mimages , remove_log ;
2005-12-22 00:21:45 +03:00
int list_unsafe , only_mirror_images_found ;
2008-11-04 01:14:30 +03:00
DM_LIST_INIT ( lvs_changed ) ;
2005-12-22 00:21:45 +03:00
only_mirror_images_found = 1 ;
2003-01-18 00:04:26 +03:00
/* Deactivate & remove necessary LVs */
restart_loop :
list_unsafe = 0 ; /* Set if we delete a different list-member */
2008-11-04 01:14:30 +03:00
dm_list_iterate_safe ( lvh , lvht , & vg - > lvs ) {
lv = dm_list_item ( lvh , struct lv_list ) - > lv ;
2003-01-18 00:04:26 +03:00
/* Are any segments of this LV on missing PVs? */
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( seg , & lv - > segments ) {
2003-04-25 02:23:24 +04:00
for ( s = 0 ; s < seg - > area_count ; s + + ) {
2005-06-01 20:51:55 +04:00
if ( seg_type ( seg , s ) ! = AREA_PV )
2003-04-25 02:23:24 +04:00
continue ;
2007-11-19 21:24:08 +03:00
/* FIXME Also check for segs on deleted LVs (incl pvmove) */
2003-04-25 02:23:24 +04:00
2005-06-01 20:51:55 +04:00
pv = seg_pv ( seg , s ) ;
2008-09-19 19:44:03 +04:00
if ( ! pv | | ! pv_dev ( pv ) | |
2010-03-16 17:37:38 +03:00
is_missing_pv ( pv ) ) {
2005-12-22 00:21:45 +03:00
if ( arg_count ( cmd , mirrorsonly_ARG ) & &
! ( lv - > status & MIRROR_IMAGE ) ) {
log_error ( " Non-mirror-image LV %s found: can't remove. " , lv - > name ) ;
only_mirror_images_found = 0 ;
continue ;
}
2008-01-30 16:19:47 +03:00
if ( ! _remove_lv ( cmd , lv , & list_unsafe , & lvs_changed ) )
return_0 ;
2003-01-18 00:04:26 +03:00
if ( list_unsafe )
goto restart_loop ;
}
}
}
}
2005-12-22 00:21:45 +03:00
if ( ! only_mirror_images_found ) {
log_error ( " Aborting because --mirrorsonly was specified. " ) ;
return 0 ;
}
2008-09-19 19:44:03 +04:00
/*
* Remove missing PVs . FIXME : This duplicates _consolidate_vg above ,
* but we cannot use that right now , since the LV removal code in this
* function leaves the VG in a " somewhat inconsistent " state and
* _consolidate_vg doesn ' t like that - - specifically , mirrors are fixed
* up * after * the PVs are removed . All this should be gradually
* superseded by lvconvert - - repair .
*/
2008-11-04 01:14:30 +03:00
dm_list_iterate_safe ( pvh , pvht , & vg - > pvs ) {
pvl = dm_list_item ( pvh , struct pv_list ) ;
2010-03-16 17:37:38 +03:00
if ( pvl - > pv - > dev & & ! is_missing_pv ( pvl - > pv ) )
2008-09-19 19:44:03 +04:00
continue ;
if ( ! _remove_pv ( vg , pvl , 0 ) )
return_0 ;
}
2005-12-21 21:51:50 +03:00
/* FIXME Recovery. For now people must clean up by hand. */
2008-11-04 01:14:30 +03:00
if ( ! dm_list_empty ( & lvs_changed ) ) {
2005-12-21 21:51:50 +03:00
if ( ! vg_write ( vg ) ) {
log_error ( " Failed to write out a consistent VG for %s " ,
vg - > name ) ;
return 0 ;
}
2005-12-21 23:24:22 +03:00
if ( ! test_mode ( ) ) {
/* Suspend lvs_changed */
if ( ! suspend_lvs ( cmd , & lvs_changed ) ) {
2008-01-30 17:17:29 +03:00
stack ;
2005-12-21 23:24:22 +03:00
vg_revert ( vg ) ;
2008-01-30 17:17:29 +03:00
return 0 ;
2005-12-21 23:24:22 +03:00
}
2005-12-21 21:51:50 +03:00
}
if ( ! vg_commit ( vg ) ) {
log_error ( " Failed to commit consistent VG for %s " ,
vg - > name ) ;
vg_revert ( vg ) ;
return 0 ;
}
2005-12-21 23:24:22 +03:00
if ( ! test_mode ( ) ) {
if ( ! resume_lvs ( cmd , & lvs_changed ) ) {
log_error ( " Failed to resume LVs using error segments. " ) ;
return 0 ;
}
2005-12-21 21:51:50 +03:00
}
2008-01-17 16:13:54 +03:00
lvs_changed_altered :
2006-01-04 21:09:52 +03:00
/* Remove lost mirror images from mirrors */
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( lvl , & vg - > lvs ) {
2008-01-17 16:13:54 +03:00
mirrored_seg_altered :
2006-01-04 21:09:52 +03:00
mirrored_seg = first_seg ( lvl - > lv ) ;
if ( ! seg_is_mirrored ( mirrored_seg ) )
continue ;
2006-05-11 23:01:11 +04:00
2006-01-04 21:09:52 +03:00
mimages = mirrored_seg - > area_count ;
2006-05-11 23:01:11 +04:00
remove_log = 0 ;
2006-01-04 21:09:52 +03:00
for ( s = 0 ; s < mirrored_seg - > area_count ; s + + ) {
2008-11-04 01:14:30 +03:00
dm_list_iterate_items_safe ( lvl2 , lvlt , & lvs_changed ) {
2006-01-04 21:09:52 +03:00
if ( seg_type ( mirrored_seg , s ) ! = AREA_LV | |
lvl2 - > lv ! = seg_lv ( mirrored_seg , s ) )
continue ;
2008-11-04 01:14:30 +03:00
dm_list_del ( & lvl2 - > list ) ;
2008-09-18 23:56:50 +04:00
if ( ! shift_mirror_images ( mirrored_seg , s ) )
return_0 ;
2006-01-04 21:09:52 +03:00
mimages - - ; /* FIXME Assumes uniqueness */
}
}
2006-05-11 23:01:11 +04:00
if ( mirrored_seg - > log_lv ) {
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( seg , & mirrored_seg - > log_lv - > segments ) {
2006-05-11 23:01:11 +04:00
/* FIXME: The second test shouldn't be required */
if ( ( seg - > segtype = =
2006-07-04 23:52:47 +04:00
get_segtype_from_string ( vg - > cmd , " error " ) ) ) {
2006-05-11 23:01:11 +04:00
log_print ( " The log device for %s/%s has failed. " ,
vg - > name , mirrored_seg - > lv - > name ) ;
remove_log = 1 ;
break ;
}
2006-07-04 23:52:47 +04:00
if ( ! strcmp ( seg - > segtype - > name , " error " ) ) {
log_print ( " Log device for %s/%s has failed. " ,
vg - > name , mirrored_seg - > lv - > name ) ;
remove_log = 1 ;
break ;
}
2006-05-11 23:01:11 +04:00
}
}
2007-08-22 18:38:18 +04:00
if ( ( mimages ! = mirrored_seg - > area_count ) | | remove_log ) {
2006-05-11 23:01:11 +04:00
if ( ! reconfigure_mirror_images ( mirrored_seg , mimages ,
2008-01-30 16:19:47 +03:00
NULL , remove_log ) )
return_0 ;
2006-01-04 21:09:52 +03:00
if ( ! vg_write ( vg ) ) {
log_error ( " Failed to write out updated "
" VG for %s " , vg - > name ) ;
return 0 ;
}
if ( ! vg_commit ( vg ) ) {
log_error ( " Failed to commit updated VG "
" for %s " , vg - > name ) ;
vg_revert ( vg ) ;
return 0 ;
}
2008-01-17 16:13:54 +03:00
/* mirrored LV no longer has valid mimages.
* So add it to lvs_changed for removal .
* For this LV may be an area of other mirror ,
* restart the loop . */
if ( ! mimages ) {
if ( ! _remove_lv ( cmd , lvl - > lv ,
& list_unsafe , & lvs_changed ) )
return_0 ;
goto lvs_changed_altered ;
}
/* As a result of reconfigure_mirror_images(),
* first_seg ( lv ) may now be different seg .
* e . g . a temporary layer might be removed .
* So check the mirrored_seg again . */
goto mirrored_seg_altered ;
2006-01-04 21:09:52 +03:00
}
}
2005-12-21 21:51:50 +03:00
/* Deactivate error LVs */
2005-12-22 00:21:45 +03:00
if ( ! test_mode ( ) ) {
2008-11-04 01:14:30 +03:00
dm_list_iterate_items_safe ( lvl , lvlt , & lvs_changed ) {
2005-12-21 23:24:22 +03:00
log_verbose ( " Deactivating (if active) logical volume %s " ,
lvl - > lv - > name ) ;
if ( ! deactivate_lv ( cmd , lvl - > lv ) ) {
log_error ( " Failed to deactivate LV %s " ,
lvl - > lv - > name ) ;
2006-05-11 23:01:11 +04:00
/*
* We failed to deactivate .
* Probably because this was a mirror log .
* Don ' t try to lv_remove it .
* Continue work on others .
*/
2008-11-04 01:14:30 +03:00
dm_list_del ( & lvl - > list ) ;
2005-12-21 23:24:22 +03:00
}
2005-12-21 21:51:50 +03:00
}
}
/* Remove remaining LVs */
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( lvl , & lvs_changed ) {
2005-12-21 21:51:50 +03:00
log_verbose ( " Removing LV %s from VG %s " , lvl - > lv - > name ,
lvl - > lv - > vg - > name ) ;
2007-01-10 02:14:35 +03:00
/* Skip LVs already removed by mirror code */
if ( find_lv_in_vg ( vg , lvl - > lv - > name ) & &
2008-01-30 16:19:47 +03:00
! lv_remove ( lvl - > lv ) )
return_0 ;
2005-12-21 21:51:50 +03:00
}
}
2003-01-18 00:04:26 +03:00
return 1 ;
}
2002-11-18 17:04:08 +03:00
/* Or take pv_name instead? */
2003-01-18 00:04:26 +03:00
static int _vgreduce_single ( struct cmd_context * cmd , struct volume_group * vg ,
2006-05-10 01:23:51 +04:00
struct physical_volume * pv ,
2010-07-09 19:34:40 +04:00
void * handle __attribute__ ( ( unused ) ) )
2002-11-18 17:04:08 +03:00
{
struct pv_list * pvl ;
2009-04-10 14:01:38 +04:00
struct volume_group * orphan_vg = NULL ;
int r = ECMD_FAILED ;
2007-10-12 18:29:32 +04:00
const char * name = pv_dev_name ( pv ) ;
2002-11-18 17:04:08 +03:00
2007-06-16 02:16:55 +04:00
if ( pv_pe_alloc_count ( pv ) ) {
2002-11-18 17:04:08 +03:00
log_error ( " Physical volume \" %s \" still in use " , name ) ;
return ECMD_FAILED ;
}
if ( vg - > pv_count = = 1 ) {
log_error ( " Can't remove final physical volume \" %s \" from "
" volume group \" %s \" " , name , vg - > name ) ;
return ECMD_FAILED ;
}
2009-05-13 17:02:52 +04:00
if ( ! lock_vol ( cmd , VG_ORPHANS , LCK_VG_WRITE ) ) {
2008-04-08 16:49:21 +04:00
log_error ( " Can't get lock for orphan PVs " ) ;
return ECMD_FAILED ;
}
2002-11-18 17:04:08 +03:00
pvl = find_pv_in_vg ( vg , name ) ;
2009-04-10 14:01:38 +04:00
if ( ! archive ( vg ) )
2009-09-15 02:47:49 +04:00
goto_bad ;
2001-10-12 01:35:55 +04:00
2002-11-18 17:04:08 +03:00
log_verbose ( " Removing \" %s \" from volume group \" %s \" " , name , vg - > name ) ;
if ( pvl )
2010-04-13 21:26:20 +04:00
del_pvl_from_vgs ( vg , pvl ) ;
2002-11-18 17:04:08 +03:00
2008-02-06 18:47:28 +03:00
pv - > vg_name = vg - > fid - > fmt - > orphan_vg_name ;
2005-12-21 21:51:50 +03:00
pv - > status = ALLOCATABLE_PV ;
2005-05-03 21:28:23 +04:00
2007-06-16 02:16:55 +04:00
if ( ! dev_get_size ( pv_dev ( pv ) , & pv - > size ) ) {
2007-10-12 18:29:32 +04:00
log_error ( " %s: Couldn't get size. " , pv_dev_name ( pv ) ) ;
2009-04-10 14:01:38 +04:00
goto bad ;
2005-05-03 21:28:23 +04:00
}
2007-06-16 02:16:55 +04:00
vg - > free_count - = pv_pe_count ( pv ) - pv_pe_alloc_count ( pv ) ;
vg - > extent_count - = pv_pe_count ( pv ) ;
2002-11-18 17:04:08 +03:00
2009-07-01 21:01:46 +04:00
orphan_vg = vg_read_for_update ( cmd , vg - > fid - > fmt - > orphan_vg_name ,
2009-07-08 18:33:17 +04:00
NULL , 0 ) ;
2009-07-01 21:01:46 +04:00
if ( vg_read_error ( orphan_vg ) )
2009-04-10 14:01:38 +04:00
goto bad ;
2008-04-08 16:49:21 +04:00
if ( ! vg_split_mdas ( cmd , vg , orphan_vg ) | | ! vg - > pv_count ) {
log_error ( " Cannot remove final metadata area on \" %s \" from \" %s \" " ,
name , vg - > name ) ;
2009-04-10 14:01:38 +04:00
goto bad ;
2008-04-08 16:49:21 +04:00
}
2003-07-05 02:34:56 +04:00
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) ) {
2002-11-18 17:04:08 +03:00
log_error ( " Removal of physical volume \" %s \" from "
" \" %s \" failed " , name , vg - > name ) ;
2009-04-10 14:01:38 +04:00
goto bad ;
2002-11-18 17:04:08 +03:00
}
2003-03-24 21:08:53 +03:00
if ( ! pv_write ( cmd , pv , NULL , INT64_C ( - 1 ) ) ) {
2002-11-18 17:04:08 +03:00
log_error ( " Failed to clear metadata from physical "
" volume \" %s \" "
" after removal from \" %s \" " , name , vg - > name ) ;
2009-04-10 14:01:38 +04:00
goto bad ;
2002-11-18 17:04:08 +03:00
}
backup ( vg ) ;
log_print ( " Removed \" %s \" from volume group \" %s \" " , name , vg - > name ) ;
2009-04-10 14:01:38 +04:00
r = ECMD_PROCESSED ;
bad :
2009-05-21 07:04:52 +04:00
unlock_and_release_vg ( cmd , orphan_vg , VG_ORPHANS ) ;
2009-04-10 14:01:38 +04:00
return r ;
2002-11-18 17:04:08 +03:00
}
2003-01-18 00:04:26 +03:00
2002-02-11 23:50:53 +03:00
int vgreduce ( struct cmd_context * cmd , int argc , char * * argv )
2001-10-12 01:35:55 +04:00
{
struct volume_group * vg ;
char * vg_name ;
2009-04-10 14:01:38 +04:00
int ret = ECMD_FAILED ;
2008-09-19 10:42:00 +04:00
int fixed = 1 ;
int repairing = arg_count ( cmd , removemissing_ARG ) ;
2009-06-15 18:47:39 +04:00
int saved_ignore_suspended_devices = ignore_suspended_devices ( ) ;
2001-10-12 01:35:55 +04:00
2008-09-19 10:42:00 +04:00
if ( ! argc & & ! repairing ) {
2001-10-12 01:35:55 +04:00
log_error ( " Please give volume group name and "
" physical volume paths " ) ;
return EINVALID_CMD_LINE ;
}
2008-09-19 10:42:00 +04:00
if ( ! argc & & repairing ) {
2003-01-18 00:04:26 +03:00
log_error ( " Please give volume group name " ) ;
return EINVALID_CMD_LINE ;
}
2008-09-19 10:42:00 +04:00
if ( arg_count ( cmd , mirrorsonly_ARG ) & & ! repairing ) {
2005-12-22 00:21:45 +03:00
log_error ( " --mirrorsonly requires --removemissing " ) ;
return EINVALID_CMD_LINE ;
}
2008-09-19 10:42:00 +04:00
if ( argc = = 1 & & ! arg_count ( cmd , all_ARG ) & & ! repairing ) {
2001-10-12 01:35:55 +04:00
log_error ( " Please enter physical volume paths or option -a " ) ;
return EINVALID_CMD_LINE ;
}
2002-02-12 00:00:35 +03:00
if ( argc > 1 & & arg_count ( cmd , all_ARG ) ) {
2001-10-12 01:35:55 +04:00
log_error ( " Option -a and physical volume paths mutually "
" exclusive " ) ;
return EINVALID_CMD_LINE ;
}
2008-09-19 10:42:00 +04:00
if ( argc > 1 & & repairing ) {
2003-01-18 00:04:26 +03:00
log_error ( " Please only specify the volume group " ) ;
return EINVALID_CMD_LINE ;
}
2007-03-09 23:47:41 +03:00
vg_name = skip_dev_dir ( cmd , argv [ 0 ] , NULL ) ;
2001-10-12 01:35:55 +04:00
argv + + ;
argc - - ;
2002-01-30 18:04:48 +03:00
log_verbose ( " Finding volume group \" %s \" " , vg_name ) ;
2002-02-11 18:42:34 +03:00
2009-07-15 09:47:55 +04:00
if ( repairing ) {
2009-06-15 18:47:39 +04:00
init_ignore_suspended_devices ( 1 ) ;
2009-07-15 09:47:55 +04:00
cmd - > handles_missing_pvs = 1 ;
}
2009-06-15 18:47:39 +04:00
2009-07-01 21:01:46 +04:00
vg = vg_read_for_update ( cmd , vg_name , NULL , READ_ALLOW_EXPORTED ) ;
if ( vg_read_error ( vg ) = = FAILED_ALLOCATION | |
vg_read_error ( vg ) = = FAILED_NOTFOUND )
2009-09-15 02:47:49 +04:00
goto_out ;
2001-10-12 01:35:55 +04:00
2009-07-01 21:01:46 +04:00
/* FIXME We want to allow read-only VGs to be changed here? */
if ( vg_read_error ( vg ) & & vg_read_error ( vg ) ! = FAILED_READ_ONLY
& & ! arg_count ( cmd , removemissing_ARG ) )
2009-09-15 02:47:49 +04:00
goto_out ;
2006-09-02 05:18:17 +04:00
2008-09-19 10:42:00 +04:00
if ( repairing ) {
2009-07-01 21:01:46 +04:00
if ( ! vg_read_error ( vg ) & & ! vg_missing_pv_count ( vg ) ) {
2003-01-18 00:04:26 +03:00
log_error ( " Volume group \" %s \" is already consistent " ,
vg_name ) ;
2009-04-10 14:01:38 +04:00
ret = ECMD_PROCESSED ;
goto out ;
2003-01-18 00:04:26 +03:00
}
2002-01-29 20:23:33 +03:00
2009-04-10 14:01:38 +04:00
vg_release ( vg ) ;
2009-07-01 21:01:46 +04:00
log_verbose ( " Trying to open VG %s for recovery... " , vg_name ) ;
vg = vg_read_for_update ( cmd , vg_name , NULL ,
READ_ALLOW_INCONSISTENT
| READ_ALLOW_EXPORTED ) ;
if ( vg_read_error ( vg ) & & vg_read_error ( vg ) ! = FAILED_READ_ONLY
& & vg_read_error ( vg ) ! = FAILED_INCONSISTENT )
2009-09-15 02:47:49 +04:00
goto_out ;
2009-07-01 21:01:46 +04:00
2009-04-10 14:01:38 +04:00
if ( ! archive ( vg ) )
2009-09-15 02:47:49 +04:00
goto_out ;
2002-01-29 20:23:33 +03:00
2008-09-19 10:42:00 +04:00
if ( arg_count ( cmd , force_ARG ) ) {
2009-04-10 14:01:38 +04:00
if ( ! _make_vg_consistent ( cmd , vg ) )
2009-09-15 02:47:49 +04:00
goto_out ;
2008-09-19 10:42:00 +04:00
} else
fixed = _consolidate_vg ( cmd , vg ) ;
2003-01-18 00:04:26 +03:00
2003-07-05 02:34:56 +04:00
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) ) {
2003-01-18 00:04:26 +03:00
log_error ( " Failed to write out a consistent VG for %s " ,
vg_name ) ;
2009-04-10 14:01:38 +04:00
goto out ;
2003-01-18 00:04:26 +03:00
}
backup ( vg ) ;
2009-04-22 21:00:28 +04:00
if ( fixed ) {
2008-09-19 10:42:00 +04:00
log_print ( " Wrote out consistent volume group %s " ,
vg_name ) ;
2009-04-22 21:00:28 +04:00
ret = ECMD_PROCESSED ;
} else
ret = ECMD_FAILED ;
2003-01-18 00:04:26 +03:00
} else {
2009-04-10 14:01:38 +04:00
if ( ! vg_check_status ( vg , EXPORTED_VG | LVM_WRITE | RESIZEABLE_VG ) )
2009-09-15 02:47:49 +04:00
goto_out ;
2003-01-18 00:04:26 +03:00
/* FIXME: Pass private struct through to all these functions */
/* and update in batch here? */
2009-07-15 09:50:22 +04:00
ret = process_each_pv ( cmd , argc , argv , vg , READ_FOR_UPDATE , 0 , NULL ,
2003-01-18 00:04:26 +03:00
_vgreduce_single ) ;
}
2009-04-10 14:01:38 +04:00
out :
2009-06-15 18:47:39 +04:00
init_ignore_suspended_devices ( saved_ignore_suspended_devices ) ;
2009-05-21 07:04:52 +04:00
unlock_and_release_vg ( cmd , vg , vg_name ) ;
2002-02-11 18:42:34 +03:00
return ret ;
2001-10-12 01:35:55 +04:00
/******* FIXME
log_error ( " no empty physical volumes found in volume group \" %s \" " , vg_name ) ;
2002-01-21 19:05:23 +03:00
2001-10-12 01:35:55 +04:00
log_verbose
( " volume group \" %s \" will be reduced by %d physical volume%s " ,
vg_name , np , np > 1 ? " s " : " " ) ;
2002-01-30 18:04:48 +03:00
log_verbose ( " reducing volume group \" %s \" by physical volume \" %s \" " ,
vg_name , pv_names [ p ] ) ;
2001-10-12 01:35:55 +04:00
log_print
( " volume group \" %s \" %ssuccessfully reduced by physical volume%s: " ,
vg_name , error > 0 ? " NOT " : " " , p > 1 ? " s " : " " ) ;
log_print ( " %s " , pv_this [ p ] - > pv_name ) ;
* * * * * * * */
}