2001-10-03 21:03:25 +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-03 21:03:25 +04:00
*
2004-03-30 23:35:44 +04:00
* This file is part of LVM2 .
2001-10-03 21:03:25 +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-03 21:03:25 +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-03 21:03:25 +04:00
*/
# include "tools.h"
2002-11-18 17:04:08 +03:00
/* FIXME Locking. PVs in VG. */
2001-10-03 21:03:25 +04:00
2002-12-20 02:25:55 +03:00
static int _pvchange_single ( struct cmd_context * cmd , struct physical_volume * pv ,
void * handle )
2001-10-03 21:03:25 +04:00
{
2001-10-17 19:29:31 +04:00
struct volume_group * vg = NULL ;
2002-01-21 17:28:12 +03:00
struct pv_list * pvl ;
2002-11-18 17:04:08 +03:00
struct list mdas ;
uint64_t sector ;
2005-05-24 21:38:26 +04:00
uint32_t orig_pe_alloc_count ;
2001-10-03 21:03:25 +04:00
2001-10-25 18:04:18 +04:00
const char * pv_name = dev_name ( pv - > dev ) ;
2004-03-08 20:19:15 +03:00
const char * tag = NULL ;
2005-05-24 21:38:26 +04:00
const char * orig_vg_name ;
char uuid [ 64 ] ;
2001-10-03 21:03:25 +04:00
2002-11-18 17:04:08 +03:00
int consistent = 1 ;
2004-01-13 21:42:05 +03:00
int allocatable = 0 ;
2004-03-08 20:19:15 +03:00
int tagarg = 0 ;
2004-12-21 19:12:02 +03:00
list_init ( & mdas ) ;
2004-03-08 20:19:15 +03:00
if ( arg_count ( cmd , addtag_ARG ) )
tagarg = addtag_ARG ;
else if ( arg_count ( cmd , deltag_ARG ) )
tagarg = deltag_ARG ;
2004-01-13 21:42:05 +03:00
if ( arg_count ( cmd , allocatable_ARG ) )
allocatable = ! strcmp ( arg_str_value ( cmd , allocatable_ARG , " n " ) ,
" y " ) ;
2004-03-08 20:19:15 +03:00
else if ( tagarg & & ! ( tag = arg_str_value ( cmd , tagarg , NULL ) ) ) {
log_error ( " Failed to get tag " ) ;
return 0 ;
}
2001-10-03 21:03:25 +04:00
2002-01-29 20:23:33 +03:00
/* If in a VG, must change using volume group. */
2001-10-17 19:29:31 +04:00
if ( * pv - > vg_name ) {
2002-02-12 00:00:35 +03:00
log_verbose ( " Finding volume group of physical volume \" %s \" " ,
2001-10-17 19:29:31 +04:00
pv_name ) ;
2002-02-11 18:42:34 +03:00
2002-02-27 15:26:41 +03:00
if ( ! lock_vol ( cmd , pv - > vg_name , LCK_VG_WRITE ) ) {
2002-02-11 18:42:34 +03:00
log_error ( " Can't get lock for %s " , pv - > vg_name ) ;
2004-01-13 21:42:05 +03:00
return 0 ;
2002-02-11 18:42:34 +03:00
}
2002-11-18 17:04:08 +03:00
if ( ! ( vg = vg_read ( cmd , pv - > vg_name , & consistent ) ) ) {
2002-03-11 18:08:39 +03:00
unlock_vg ( cmd , pv - > vg_name ) ;
2002-01-30 18:04:48 +03:00
log_error ( " Unable to find volume group of \" %s \" " ,
2002-02-12 00:00:35 +03:00
pv_name ) ;
2001-10-17 19:29:31 +04:00
return 0 ;
}
2002-01-29 20:23:33 +03:00
2002-02-12 00:00:35 +03:00
if ( vg - > status & EXPORTED_VG ) {
2002-03-11 18:08:39 +03:00
unlock_vg ( cmd , pv - > vg_name ) ;
2002-02-12 00:00:35 +03:00
log_error ( " Volume group \" %s \" is exported " , vg - > name ) ;
2004-01-13 21:42:05 +03:00
return 0 ;
2002-02-12 00:00:35 +03:00
}
2002-01-29 20:23:33 +03:00
2002-02-12 00:00:35 +03:00
if ( ! ( vg - > status & LVM_WRITE ) ) {
2002-03-11 18:08:39 +03:00
unlock_vg ( cmd , pv - > vg_name ) ;
2002-01-30 18:04:48 +03:00
log_error ( " Volume group \" %s \" is read-only " , vg - > name ) ;
2004-01-13 21:42:05 +03:00
return 0 ;
2002-01-29 20:23:33 +03:00
}
2002-01-21 17:28:12 +03:00
if ( ! ( pvl = find_pv_in_vg ( vg , pv_name ) ) ) {
2002-03-11 18:08:39 +03:00
unlock_vg ( cmd , pv - > vg_name ) ;
2002-02-12 00:00:35 +03:00
log_error
( " Unable to find \" %s \" in volume group \" %s \" " ,
pv_name , vg - > name ) ;
2001-10-17 19:29:31 +04:00
return 0 ;
}
2004-03-08 20:19:15 +03:00
if ( tagarg & & ! ( vg - > fid - > fmt - > features & FMT_TAGS ) ) {
unlock_vg ( cmd , pv - > vg_name ) ;
log_error ( " Volume group containing %s does not "
" support tags " , pv_name ) ;
return 0 ;
}
2004-01-13 21:42:05 +03:00
if ( arg_count ( cmd , uuid_ARG ) & & lvs_in_vg_activated ( vg ) ) {
unlock_vg ( cmd , pv - > vg_name ) ;
log_error ( " Volume group containing %s has active "
" logical volumes " , pv_name ) ;
return 0 ;
}
2002-01-21 19:05:23 +03:00
pv = pvl - > pv ;
2002-01-09 16:17:14 +03:00
if ( ! archive ( vg ) )
return 0 ;
2002-11-18 17:04:08 +03:00
} else {
2004-03-08 20:19:15 +03:00
if ( tagarg ) {
log_error ( " Can't change tag on Physical Volume %s not "
" in volume group " , pv_name ) ;
return 0 ;
}
2002-11-18 17:04:08 +03:00
if ( ! lock_vol ( cmd , ORPHAN , LCK_VG_WRITE ) ) {
log_error ( " Can't get lock for orphans " ) ;
2004-01-13 21:42:05 +03:00
return 0 ;
2002-11-18 17:04:08 +03:00
}
2004-06-19 23:27:00 +04:00
if ( ! ( pv = pv_read ( cmd , pv_name , & mdas , & sector , 1 ) ) ) {
2002-11-18 17:04:08 +03:00
unlock_vg ( cmd , ORPHAN ) ;
log_error ( " Unable to read PV \" %s \" " , pv_name ) ;
return 0 ;
}
2001-10-17 19:29:31 +04:00
}
2001-10-03 21:03:25 +04:00
2004-01-13 21:42:05 +03:00
if ( arg_count ( cmd , allocatable_ARG ) ) {
if ( ! * pv - > vg_name & &
! ( pv - > fmt - > features & FMT_ORPHAN_ALLOCATABLE ) ) {
log_error ( " Allocatability not supported by orphan "
" %s format PV %s " , pv - > fmt - > name , pv_name ) ;
2002-11-18 17:04:08 +03:00
unlock_vg ( cmd , ORPHAN ) ;
2004-01-13 21:42:05 +03:00
return 0 ;
}
2001-10-03 21:03:25 +04:00
2004-01-13 21:42:05 +03:00
/* change allocatability for a PV */
if ( allocatable & & ( pv - > status & ALLOCATABLE_PV ) ) {
log_error ( " Physical volume \" %s \" is already "
" allocatable " , pv_name ) ;
if ( * pv - > vg_name )
unlock_vg ( cmd , pv - > vg_name ) ;
else
unlock_vg ( cmd , ORPHAN ) ;
return 1 ;
}
2001-10-03 21:03:25 +04:00
2004-01-13 21:42:05 +03:00
if ( ! allocatable & & ! ( pv - > status & ALLOCATABLE_PV ) ) {
log_error ( " Physical volume \" %s \" is already "
" unallocatable " , pv_name ) ;
if ( * pv - > vg_name )
unlock_vg ( cmd , pv - > vg_name ) ;
else
unlock_vg ( cmd , ORPHAN ) ;
return 1 ;
}
if ( allocatable ) {
log_verbose ( " Setting physical volume \" %s \" "
" allocatable " , pv_name ) ;
pv - > status | = ALLOCATABLE_PV ;
} else {
log_verbose ( " Setting physical volume \" %s \" NOT "
" allocatable " , pv_name ) ;
pv - > status & = ~ ALLOCATABLE_PV ;
}
2004-03-08 20:19:15 +03:00
} else if ( tagarg ) {
/* tag or deltag */
if ( ( tagarg = = addtag_ARG ) ) {
if ( ! str_list_add ( cmd - > mem , & pv - > tags , tag ) ) {
log_error ( " Failed to add tag %s to physical "
" volume %s " , tag , pv_name ) ;
return 0 ;
}
} else {
if ( ! str_list_del ( & pv - > tags , tag ) ) {
log_error ( " Failed to remove tag %s from "
" physical volume " " %s " , tag , pv_name ) ;
return 0 ;
}
}
2001-10-17 19:29:31 +04:00
} else {
2004-01-13 21:42:05 +03:00
/* --uuid: Change PV ID randomly */
2005-01-20 21:11:53 +03:00
if ( ! id_create ( & pv - > id ) ) {
log_error ( " Failed to generate new random UUID for %s. " ,
pv_name ) ;
return 0 ;
}
2005-05-24 21:38:26 +04:00
if ( ! id_write_format ( & pv - > id , uuid , sizeof ( uuid ) ) ) {
stack ;
return 0 ;
}
log_verbose ( " Changing uuid of %s to %s. " , pv_name , uuid ) ;
if ( * pv - > vg_name ) {
orig_vg_name = pv - > vg_name ;
orig_pe_alloc_count = pv - > pe_alloc_count ;
pv - > vg_name = ORPHAN ;
pv - > pe_alloc_count = 0 ;
if ( ! ( pv_write ( cmd , pv , NULL , INT64_C ( - 1 ) ) ) ) {
log_error ( " pv_write with new uuid failed "
" for %s. " , pv_name ) ;
return 0 ;
}
pv - > vg_name = orig_vg_name ;
pv - > pe_alloc_count = orig_pe_alloc_count ;
}
2001-10-03 21:03:25 +04:00
}
2002-01-30 18:04:48 +03:00
log_verbose ( " Updating physical volume \" %s \" " , pv_name ) ;
2001-10-17 19:29:31 +04:00
if ( * pv - > vg_name ) {
2003-07-05 02:34:56 +04:00
if ( ! vg_write ( vg ) | | ! vg_commit ( vg ) ) {
2002-03-11 18:08:39 +03:00
unlock_vg ( cmd , pv - > vg_name ) ;
2002-01-30 18:04:48 +03:00
log_error ( " Failed to store physical volume \" %s \" in "
" volume group \" %s \" " , pv_name , vg - > name ) ;
2001-10-17 19:29:31 +04:00
return 0 ;
2001-10-03 21:03:25 +04:00
}
2002-01-07 14:12:11 +03:00
backup ( vg ) ;
2002-03-11 18:08:39 +03:00
unlock_vg ( cmd , pv - > vg_name ) ;
2001-10-17 19:29:31 +04:00
} else {
2003-11-06 20:06:06 +03:00
if ( ! ( pv_write ( cmd , pv , NULL , INT64_C ( - 1 ) ) ) ) {
2002-11-18 17:04:08 +03:00
unlock_vg ( cmd , ORPHAN ) ;
2002-02-12 00:00:35 +03:00
log_error ( " Failed to store physical volume \" %s \" " ,
2001-10-17 19:29:31 +04:00
pv_name ) ;
return 0 ;
2001-10-03 21:03:25 +04:00
}
2002-11-18 17:04:08 +03:00
unlock_vg ( cmd , ORPHAN ) ;
2001-10-03 21:03:25 +04:00
}
2001-10-17 19:29:31 +04:00
2002-01-30 18:04:48 +03:00
log_print ( " Physical volume \" %s \" changed " , pv_name ) ;
2001-10-17 19:29:31 +04:00
return 1 ;
2001-10-03 21:03:25 +04:00
}
2002-11-18 17:04:08 +03:00
int pvchange ( struct cmd_context * cmd , int argc , char * * argv )
{
int opt = 0 ;
int done = 0 ;
int total = 0 ;
struct physical_volume * pv ;
char * pv_name ;
2003-10-16 00:02:46 +04:00
struct pv_list * pvl ;
struct list * pvslist ;
2002-11-18 17:04:08 +03:00
struct list mdas ;
list_init ( & mdas ) ;
2004-03-08 20:19:15 +03:00
if ( arg_count ( cmd , allocatable_ARG ) + arg_count ( cmd , addtag_ARG ) +
arg_count ( cmd , deltag_ARG ) + arg_count ( cmd , uuid_ARG ) ! = 1 ) {
log_error ( " Please give exactly one option of -x, -uuid, "
" --addtag or --deltag " ) ;
2002-11-18 17:04:08 +03:00
return EINVALID_CMD_LINE ;
}
if ( ! ( arg_count ( cmd , all_ARG ) ) & & ! argc ) {
log_error ( " Please give a physical volume path " ) ;
return EINVALID_CMD_LINE ;
}
if ( arg_count ( cmd , all_ARG ) & & argc ) {
log_error ( " Option a and PhysicalVolumePath are exclusive " ) ;
return EINVALID_CMD_LINE ;
}
if ( argc ) {
log_verbose ( " Using physical volume(s) on command line " ) ;
for ( ; opt < argc ; opt + + ) {
pv_name = argv [ opt ] ;
/* FIXME Read VG instead - pv_read will fail */
2004-06-19 23:27:00 +04:00
if ( ! ( pv = pv_read ( cmd , pv_name , & mdas , NULL , 1 ) ) ) {
log_error ( " Failed to read physical volume %s " ,
pv_name ) ;
2002-11-18 17:04:08 +03:00
continue ;
}
total + + ;
2002-12-20 02:25:55 +03:00
done + = _pvchange_single ( cmd , pv , NULL ) ;
2002-11-18 17:04:08 +03:00
}
} else {
log_verbose ( " Scanning for physical volume names " ) ;
2002-12-20 02:25:55 +03:00
if ( ! ( pvslist = get_pvs ( cmd ) ) ) {
2002-11-18 17:04:08 +03:00
return ECMD_FAILED ;
}
2003-10-16 00:02:46 +04:00
list_iterate_items ( pvl , pvslist ) {
2002-11-18 17:04:08 +03:00
total + + ;
2003-10-16 00:02:46 +04:00
done + = _pvchange_single ( cmd , pvl - > pv , NULL ) ;
2002-11-18 17:04:08 +03:00
}
}
log_print ( " %d physical volume%s changed / %d physical volume%s "
" not changed " ,
2004-01-13 21:42:05 +03:00
done , done = = 1 ? " " : " s " ,
total - done , ( total - done ) = = 1 ? " " : " s " ) ;
2002-11-18 17:04:08 +03:00
2003-10-22 02:06:07 +04:00
return ( total = = done ) ? ECMD_PROCESSED : ECMD_FAILED ;
2002-11-18 17:04:08 +03:00
}