2002-05-31 23:30:51 +04:00
/*
2004-03-30 23:35:44 +04: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 .
2002-05-31 23:30:51 +04:00
*
2004-03-30 23:35:44 +04:00
* This file is part of LVM2 .
2002-05-31 23:30:51 +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 .
2002-05-31 23:30:51 +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
2002-05-31 23:30:51 +04:00
*/
# include "tools.h"
static int _move_pv ( struct volume_group * vg_from , struct volume_group * vg_to ,
char * pv_name )
{
struct pv_list * pvl ;
struct physical_volume * pv ;
if ( ! ( pvl = find_pv_in_vg ( vg_from , pv_name ) ) ) {
log_error ( " Physical volume %s not in volume group %s " ,
pv_name , vg_from - > name ) ;
return 0 ;
}
list_del ( & pvl - > list ) ;
list_add ( & vg_to - > pvs , & pvl - > list ) ;
vg_from - > pv_count - - ;
vg_to - > pv_count + + ;
pv = list_item ( pvl , struct pv_list ) - > pv ;
2007-06-16 02:16:55 +04:00
vg_from - > extent_count - = pv_pe_count ( pv ) ;
vg_to - > extent_count + = pv_pe_count ( pv ) ;
2002-05-31 23:30:51 +04:00
2007-06-16 02:16:55 +04:00
vg_from - > free_count - = pv_pe_count ( pv ) - pv_pe_alloc_count ( pv ) ;
vg_to - > free_count + = pv_pe_count ( pv ) - pv_pe_alloc_count ( pv ) ;
2002-05-31 23:30:51 +04:00
return 1 ;
}
2005-04-07 16:39:44 +04:00
/* FIXME Why not (lv->vg == vg) ? */
static int _lv_is_in_vg ( struct volume_group * vg , struct logical_volume * lv )
{
struct lv_list * lvl ;
list_iterate_items ( lvl , & vg - > lvs )
if ( lv = = lvl - > lv )
return 1 ;
return 0 ;
}
2002-05-31 23:30:51 +04:00
static int _move_lvs ( struct volume_group * vg_from , struct volume_group * vg_to )
{
2003-10-16 00:02:46 +04:00
struct list * lvh , * lvht ;
2002-05-31 23:30:51 +04:00
struct logical_volume * lv ;
2002-11-18 17:04:08 +03:00
struct lv_segment * seg ;
2002-05-31 23:30:51 +04:00
struct physical_volume * pv ;
struct volume_group * vg_with ;
2006-05-10 01:23:51 +04:00
unsigned s ;
2002-05-31 23:30:51 +04:00
list_iterate_safe ( lvh , lvht , & vg_from - > lvs ) {
lv = list_item ( lvh , struct lv_list ) - > lv ;
2005-04-07 16:39:44 +04:00
if ( ( lv - > status & SNAPSHOT ) )
continue ;
2007-01-30 02:01:18 +03:00
if ( ( lv - > status & MIRRORED ) )
continue ;
2002-05-31 23:30:51 +04:00
/* Ensure all the PVs used by this LV remain in the same */
/* VG as each other */
vg_with = NULL ;
2003-10-16 00:02:46 +04:00
list_iterate_items ( seg , & lv - > segments ) {
2003-04-25 02:23:24 +04:00
for ( s = 0 ; s < seg - > area_count ; s + + ) {
/* FIXME Check AREA_LV too */
2005-06-01 20:51:55 +04:00
if ( seg_type ( seg , s ) ! = AREA_PV )
2003-04-25 02:23:24 +04:00
continue ;
2005-06-01 20:51:55 +04:00
pv = seg_pv ( seg , s ) ;
2002-05-31 23:30:51 +04:00
if ( vg_with ) {
2003-01-18 00:04:26 +03:00
if ( ! pv_is_in_vg ( vg_with , pv ) ) {
2007-01-10 00:12:41 +03:00
log_error ( " Can't split Logical "
" Volume %s between "
" two Volume Groups " ,
2002-05-31 23:30:51 +04:00
lv - > name ) ;
return 0 ;
}
continue ;
}
2003-01-18 00:04:26 +03:00
if ( pv_is_in_vg ( vg_from , pv ) ) {
2002-05-31 23:30:51 +04:00
vg_with = vg_from ;
continue ;
}
2003-01-18 00:04:26 +03:00
if ( pv_is_in_vg ( vg_to , pv ) ) {
2002-05-31 23:30:51 +04:00
vg_with = vg_to ;
continue ;
}
log_error ( " Physical Volume %s not found " ,
2007-10-12 18:29:32 +04:00
pv_dev_name ( pv ) ) ;
2002-05-31 23:30:51 +04:00
return 0 ;
}
2005-04-07 16:39:44 +04:00
}
2002-05-31 23:30:51 +04:00
if ( vg_with = = vg_from )
continue ;
/* Move this LV */
list_del ( lvh ) ;
list_add ( & vg_to - > lvs , lvh ) ;
vg_from - > lv_count - - ;
vg_to - > lv_count + + ;
}
2003-04-25 02:23:24 +04:00
/* FIXME Ensure no LVs contain segs pointing at LVs in the other VG */
2002-05-31 23:30:51 +04:00
return 1 ;
}
2005-04-07 16:39:44 +04:00
static int _move_snapshots ( struct volume_group * vg_from ,
struct volume_group * vg_to )
2002-05-31 23:30:51 +04:00
{
2005-04-07 16:39:44 +04:00
struct list * lvh , * lvht ;
struct logical_volume * lv ;
struct lv_segment * seg ;
int cow_from = 0 ;
int origin_from = 0 ;
2002-05-31 23:30:51 +04:00
2005-04-07 16:39:44 +04:00
list_iterate_safe ( lvh , lvht , & vg_from - > lvs ) {
lv = list_item ( lvh , struct lv_list ) - > lv ;
2002-05-31 23:30:51 +04:00
2005-04-07 16:39:44 +04:00
if ( ! ( lv - > status & SNAPSHOT ) )
continue ;
2002-05-31 23:30:51 +04:00
2005-04-07 16:39:44 +04:00
list_iterate_items ( seg , & lv - > segments ) {
cow_from = _lv_is_in_vg ( vg_from , seg - > cow ) ;
origin_from = _lv_is_in_vg ( vg_from , seg - > origin ) ;
2007-05-15 17:01:41 +04:00
if ( cow_from & & origin_from )
continue ;
if ( ( ! cow_from & & origin_from ) | |
( cow_from & & ! origin_from ) ) {
log_error ( " Can't split snapshot %s between "
" two Volume Groups " , seg - > cow - > name ) ;
return 0 ;
}
2005-04-07 16:39:44 +04:00
}
/* Move this snapshot */
list_del ( lvh ) ;
list_add ( & vg_to - > lvs , lvh ) ;
2002-05-31 23:30:51 +04:00
vg_from - > snapshot_count - - ;
vg_to - > snapshot_count + + ;
}
return 1 ;
}
2007-01-30 02:01:18 +03:00
static int _move_mirrors ( struct volume_group * vg_from ,
struct volume_group * vg_to )
{
struct list * lvh , * lvht ;
struct logical_volume * lv ;
struct lv_segment * seg ;
2007-08-22 18:38:18 +04:00
unsigned s , seg_in , log_in ;
2007-01-30 02:01:18 +03:00
list_iterate_safe ( lvh , lvht , & vg_from - > lvs ) {
lv = list_item ( lvh , struct lv_list ) - > lv ;
if ( ! ( lv - > status & MIRRORED ) )
continue ;
seg = first_seg ( lv ) ;
seg_in = 0 ;
2007-08-22 18:38:18 +04:00
for ( s = 0 ; s < seg - > area_count ; s + + )
if ( _lv_is_in_vg ( vg_to , seg_lv ( seg , s ) ) )
2007-01-30 02:01:18 +03:00
seg_in + + ;
log_in = ( ! seg - > log_lv | | _lv_is_in_vg ( vg_to , seg - > log_lv ) ) ;
if ( ( seg_in & & seg_in < seg - > area_count ) | |
( seg_in & & seg - > log_lv & & ! log_in ) | |
( ! seg_in & & seg - > log_lv & & log_in ) ) {
2007-05-15 17:01:41 +04:00
log_error ( " Can't split mirror %s between "
" two Volume Groups " , lv - > name ) ;
2007-01-30 02:01:18 +03:00
return 0 ;
}
if ( seg_in = = seg - > area_count & & log_in ) {
list_del ( lvh ) ;
list_add ( & vg_to - > lvs , lvh ) ;
vg_from - > lv_count - - ;
vg_to - > lv_count + + ;
}
}
return 1 ;
}
2002-05-31 23:30:51 +04:00
int vgsplit ( struct cmd_context * cmd , int argc , char * * argv )
{
char * vg_name_from , * vg_name_to ;
struct volume_group * vg_to , * vg_from ;
int opt ;
int active ;
if ( argc < 3 ) {
log_error ( " Existing VG, new VG and physical volumes required. " ) ;
return EINVALID_CMD_LINE ;
}
2007-03-10 00:25:33 +03:00
vg_name_from = skip_dev_dir ( cmd , argv [ 0 ] , NULL ) ;
vg_name_to = skip_dev_dir ( cmd , argv [ 1 ] , NULL ) ;
2002-05-31 23:30:51 +04:00
argc - = 2 ;
argv + = 2 ;
if ( ! strcmp ( vg_name_to , vg_name_from ) ) {
log_error ( " Duplicate volume group name \" %s \" " , vg_name_from ) ;
return ECMD_FAILED ;
}
log_verbose ( " Checking for volume group \" %s \" " , vg_name_from ) ;
2007-11-15 05:20:03 +03:00
if ( ! ( vg_from = vg_lock_and_read ( cmd , vg_name_from , NULL , LCK_VG_WRITE ,
2007-07-23 21:27:55 +04:00
CLUSTERED | EXPORTED_VG |
2007-07-24 01:03:42 +04:00
RESIZEABLE_VG | LVM_WRITE ,
CORRECT_INCONSISTENT | FAIL_INCONSISTENT ) ) )
2007-07-23 21:27:55 +04:00
return ECMD_FAILED ;
2002-05-31 23:30:51 +04:00
2007-11-15 05:53:49 +03:00
log_verbose ( " Checking for new volume group \" %s \" " , vg_name_to ) ;
if ( ( vg_to = vg_lock_and_read ( cmd , vg_name_to , NULL ,
LCK_VG_WRITE | LCK_NONBLOCK ,
0 , 0 ) ) ) {
log_error ( " Volume group \" %s \" already exists " , vg_name_to ) ;
2007-11-02 23:40:05 +03:00
unlock_vg ( cmd , vg_name_from ) ;
return ECMD_FAILED ;
}
2002-05-31 23:30:51 +04:00
if ( ( active = lvs_in_vg_activated ( vg_from ) ) ) {
/* FIXME Remove this restriction */
log_error ( " Logical volumes in \" %s \" must be inactive " ,
vg_name_from ) ;
goto error ;
}
2007-03-23 15:43:17 +03:00
/* Set metadata format of original VG */
/* FIXME: need some common logic */
cmd - > fmt = vg_from - > fid - > fmt ;
2002-05-31 23:30:51 +04:00
/* Create new VG structure */
if ( ! ( vg_to = vg_create ( cmd , vg_name_to , vg_from - > extent_size ,
2004-05-19 02:12:53 +04:00
vg_from - > max_pv , vg_from - > max_lv ,
vg_from - > alloc , 0 , NULL ) ) )
2002-05-31 23:30:51 +04:00
goto error ;
2006-10-13 17:22:44 +04:00
if ( vg_from - > status & CLUSTERED )
vg_to - > status | = CLUSTERED ;
2002-05-31 23:30:51 +04:00
/* Archive vg_from before changing it */
if ( ! archive ( vg_from ) )
goto error ;
/* Move PVs across to new structure */
for ( opt = 0 ; opt < argc ; opt + + ) {
if ( ! _move_pv ( vg_from , vg_to , argv [ opt ] ) )
goto error ;
}
/* Move required LVs across, checking consistency */
if ( ! ( _move_lvs ( vg_from , vg_to ) ) )
goto error ;
/* Move required snapshots across */
if ( ! ( _move_snapshots ( vg_from , vg_to ) ) )
goto error ;
2007-01-30 02:01:18 +03:00
/* Move required mirrors across */
if ( ! ( _move_mirrors ( vg_from , vg_to ) ) )
goto error ;
2007-03-23 15:43:17 +03:00
/* Split metadata areas and check if both vgs have at least one area */
2007-06-28 21:59:34 +04:00
if ( ! ( vg_split_mdas ( cmd , vg_from , vg_to ) ) & & vg_from - > pv_count ) {
2007-03-23 15:43:17 +03:00
log_error ( " Cannot split: Nowhere to store metadata for new Volume Group " ) ;
goto error ;
}
/* Set proper name for all PVs in new VG */
if ( ! vg_rename ( cmd , vg_to , vg_name_to ) )
goto error ;
2002-11-18 17:04:08 +03:00
2002-05-31 23:30:51 +04:00
/* store it on disks */
log_verbose ( " Writing out updated volume groups " ) ;
/* Write out new VG as EXPORTED */
vg_to - > status | = EXPORTED_VG ;
if ( ! archive ( vg_to ) )
goto error ;
2003-07-05 02:34:56 +04:00
if ( ! vg_write ( vg_to ) | | ! vg_commit ( vg_to ) )
2002-05-31 23:30:51 +04:00
goto error ;
backup ( vg_to ) ;
/* Write out updated old VG */
2007-06-28 21:59:34 +04:00
if ( vg_from - > pv_count ) {
if ( ! vg_write ( vg_from ) | | ! vg_commit ( vg_from ) )
goto error ;
2002-05-31 23:30:51 +04:00
2007-06-28 21:59:34 +04:00
backup ( vg_from ) ;
}
2002-05-31 23:30:51 +04:00
/* Remove EXPORTED flag from new VG */
2007-11-15 05:53:49 +03:00
if ( ! ( vg_to = vg_lock_and_read ( cmd , vg_name_to , NULL , LCK_NONE , 0 ,
CORRECT_INCONSISTENT | FAIL_INCONSISTENT ) ) ) {
2002-11-18 17:04:08 +03:00
log_error ( " Volume group \" %s \" became inconsistent: please "
" fix manually " , vg_name_to ) ;
goto error ;
}
2002-05-31 23:30:51 +04:00
vg_to - > status & = ~ EXPORTED_VG ;
2003-09-15 19:03:54 +04:00
if ( ! vg_write ( vg_to ) | | ! vg_commit ( vg_to ) )
2002-05-31 23:30:51 +04:00
goto error ;
backup ( vg_to ) ;
unlock_vg ( cmd , vg_name_from ) ;
unlock_vg ( cmd , vg_name_to ) ;
log_print ( " Volume group \" %s \" successfully split from \" %s \" " ,
vg_to - > name , vg_from - > name ) ;
2003-10-22 02:06:07 +04:00
return ECMD_PROCESSED ;
2002-05-31 23:30:51 +04:00
error :
unlock_vg ( cmd , vg_name_from ) ;
unlock_vg ( cmd , vg_name_to ) ;
return ECMD_FAILED ;
}