2001-09-25 16:49:28 +04:00
/*
2001-12-20 14:52:54 +03:00
* Copyright ( C ) 2001 Sistina Software ( UK ) Limited .
2001-09-25 16:49:28 +04:00
*
2001-12-20 14:52:54 +03:00
* This file is released under the GPL .
2001-09-25 16:49:28 +04:00
*/
2001-10-06 01:39:30 +04:00
# include "tools.h"
2001-09-25 16:49:28 +04:00
2002-01-01 00:27:39 +03:00
# include <sys/stat.h>
2002-02-11 23:50:53 +03:00
int process_each_lv_in_vg ( struct cmd_context * cmd , struct volume_group * vg ,
2002-11-18 17:04:08 +03:00
void * handle ,
2002-02-12 00:00:35 +03:00
int ( * process_single ) ( struct cmd_context * cmd ,
2002-11-18 17:04:08 +03:00
struct logical_volume * lv ,
void * handle ) )
2001-11-19 18:20:50 +03:00
{
int ret_max = 0 ;
int ret = 0 ;
struct list * lvh ;
struct logical_volume * lv ;
if ( vg - > status & EXPORTED_VG ) {
2002-01-30 18:04:48 +03:00
log_error ( " Volume group \" %s \" is exported " , vg - > name ) ;
2001-11-19 18:20:50 +03:00
return ECMD_FAILED ;
}
2002-01-29 20:23:33 +03:00
2001-11-19 18:20:50 +03:00
list_iterate ( lvh , & vg - > lvs ) {
2002-01-21 19:49:32 +03:00
lv = list_item ( lvh , struct lv_list ) - > lv ;
2002-11-18 17:04:08 +03:00
ret = process_single ( cmd , lv , handle ) ;
2001-11-19 18:20:50 +03:00
if ( ret > ret_max )
ret_max = ret ;
}
return ret_max ;
}
2002-11-18 17:04:08 +03:00
struct volume_group * recover_vg ( struct cmd_context * cmd , const char * vgname ,
int lock_type )
{
int consistent = 1 ;
lock_type & = ~ LCK_TYPE_MASK ;
lock_type | = LCK_WRITE ;
if ( ! lock_vol ( cmd , vgname , lock_type ) ) {
log_error ( " Can't lock %s for metadata recovery: skipping " ,
vgname ) ;
return NULL ;
}
return vg_read ( cmd , vgname , & consistent ) ;
}
2002-02-11 23:50:53 +03:00
int process_each_lv ( struct cmd_context * cmd , int argc , char * * argv ,
2002-11-18 17:04:08 +03:00
int lock_type , void * handle ,
2002-02-12 00:00:35 +03:00
int ( * process_single ) ( struct cmd_context * cmd ,
2002-11-18 17:04:08 +03:00
struct logical_volume * lv ,
void * handle ) )
2001-11-14 21:38:07 +03:00
{
int opt = 0 ;
int ret_max = 0 ;
int ret = 0 ;
int vg_count = 0 ;
2002-11-18 17:04:08 +03:00
int consistent ;
2001-11-14 21:38:07 +03:00
2002-11-18 17:04:08 +03:00
struct list * slh , * vgnames ;
2001-11-14 21:38:07 +03:00
struct volume_group * vg ;
struct logical_volume * lv ;
2002-01-21 17:28:12 +03:00
struct lv_list * lvl ;
2001-11-14 21:38:07 +03:00
2002-11-18 17:04:08 +03:00
char * vgname ;
2001-11-14 21:38:07 +03:00
if ( argc ) {
log_verbose ( " Using logical volume(s) on command line " ) ;
for ( ; opt < argc ; opt + + ) {
char * lv_name = argv [ opt ] ;
2002-11-18 17:04:08 +03:00
int vgname_provided = 1 ;
/* Do we have a vgname or lvname? */
vgname = lv_name ;
if ( ! strncmp ( vgname , cmd - > dev_dir ,
strlen ( cmd - > dev_dir ) ) )
vgname + = strlen ( cmd - > dev_dir ) ;
if ( strchr ( vgname , ' / ' ) ) {
/* Must be an LV */
vgname_provided = 0 ;
if ( ! ( vgname = extract_vgname ( cmd , lv_name ) ) ) {
if ( ret_max < ECMD_FAILED )
ret_max = ECMD_FAILED ;
continue ;
}
2001-11-14 21:38:07 +03:00
}
2002-11-18 17:04:08 +03:00
log_verbose ( " Finding volume group \" %s \" " , vgname ) ;
if ( ! lock_vol ( cmd , vgname , lock_type ) ) {
log_error ( " Can't lock %s: skipping " , vgname ) ;
2002-04-24 22:20:51 +04:00
continue ;
}
2002-11-18 17:04:08 +03:00
if ( lock_type & LCK_WRITE )
consistent = 1 ;
else
consistent = 0 ;
if ( ! ( vg = vg_read ( cmd , vgname , & consistent ) ) | |
! consistent ) {
unlock_vg ( cmd , vgname ) ;
if ( ! vg )
log_error ( " Volume group \" %s \" "
" not found " , vgname ) ;
else
log_error ( " Volume group \" %s \" "
" inconsistent " , vgname ) ;
if ( ! vg | | ! ( vg =
recover_vg ( cmd , vgname ,
lock_type ) ) ) {
unlock_vg ( cmd , vgname ) ;
if ( ret_max < ECMD_FAILED )
ret_max = ECMD_FAILED ;
continue ;
}
2001-11-14 21:38:07 +03:00
}
2002-01-29 20:23:33 +03:00
if ( vg - > status & EXPORTED_VG ) {
2002-01-30 18:04:48 +03:00
log_error ( " Volume group \" %s \" is exported " ,
2002-01-29 20:23:33 +03:00
vg - > name ) ;
2002-11-18 17:04:08 +03:00
unlock_vg ( cmd , vgname ) ;
2002-01-29 20:23:33 +03:00
return ECMD_FAILED ;
}
2002-11-18 17:04:08 +03:00
if ( vgname_provided ) {
if ( ( ret =
process_each_lv_in_vg ( cmd , vg , handle ,
process_single ) ) >
ret_max )
ret_max = ret ;
unlock_vg ( cmd , vgname ) ;
continue ;
}
2002-01-21 17:28:12 +03:00
if ( ! ( lvl = find_lv_in_vg ( vg , lv_name ) ) ) {
2002-01-30 18:04:48 +03:00
log_error ( " Can't find logical volume \" %s \" "
" in volume group \" %s \" " ,
2002-11-18 17:04:08 +03:00
lv_name , vgname ) ;
2001-11-14 21:38:07 +03:00
if ( ret_max < ECMD_FAILED )
ret_max = ECMD_FAILED ;
2002-11-18 17:04:08 +03:00
unlock_vg ( cmd , vgname ) ;
2001-11-14 21:38:07 +03:00
continue ;
}
2002-01-21 19:49:32 +03:00
lv = lvl - > lv ;
2001-11-14 21:38:07 +03:00
2002-11-18 17:04:08 +03:00
if ( ( ret = process_single ( cmd , lv , handle ) ) > ret_max )
2001-11-14 21:38:07 +03:00
ret_max = ret ;
2002-11-18 17:04:08 +03:00
unlock_vg ( cmd , vgname ) ;
2001-11-14 21:38:07 +03:00
}
} else {
2002-01-16 17:43:27 +03:00
log_verbose ( " Finding all logical volumes " ) ;
2002-11-18 17:04:08 +03:00
if ( ! ( vgnames = get_vgs ( cmd , 0 ) ) ) {
2001-11-14 21:38:07 +03:00
log_error ( " No volume groups found " ) ;
return ECMD_FAILED ;
}
2002-11-18 17:04:08 +03:00
list_iterate ( slh , vgnames ) {
vgname = list_item ( slh , struct str_list ) - > str ;
if ( ! vgname | | ! * vgname )
continue ; /* FIXME Unnecessary? */
if ( ! lock_vol ( cmd , vgname , lock_type ) ) {
log_error ( " Can't lock %s: skipping " , vgname ) ;
2002-04-24 22:20:51 +04:00
continue ;
}
2002-11-18 17:04:08 +03:00
if ( lock_type & LCK_WRITE )
consistent = 1 ;
else
consistent = 0 ;
if ( ! ( vg = vg_read ( cmd , vgname , & consistent ) ) | |
! consistent ) {
unlock_vg ( cmd , vgname ) ;
if ( ! vg )
log_error ( " Volume group \" %s \" "
" not found " , vgname ) ;
else
log_error ( " Volume group \" %s \" "
" inconsistent " , vgname ) ;
if ( ! vg | | ! ( vg =
recover_vg ( cmd , vgname ,
lock_type ) ) ) {
unlock_vg ( cmd , vgname ) ;
if ( ret_max < ECMD_FAILED )
ret_max = ECMD_FAILED ;
continue ;
}
2001-11-14 21:38:07 +03:00
}
2002-11-18 17:04:08 +03:00
ret = process_each_lv_in_vg ( cmd , vg , handle ,
process_single ) ;
unlock_vg ( cmd , vgname ) ;
2001-11-19 18:20:50 +03:00
if ( ret > ret_max )
ret_max = ret ;
2001-11-14 21:38:07 +03:00
vg_count + + ;
}
}
return ret_max ;
}
2002-02-12 00:00:35 +03:00
int process_each_vg ( struct cmd_context * cmd , int argc , char * * argv ,
2002-11-18 17:04:08 +03:00
int lock_type , int consistent , void * handle ,
2002-02-12 00:00:35 +03:00
int ( * process_single ) ( struct cmd_context * cmd ,
2002-11-18 17:04:08 +03:00
const char * vg_name ,
struct volume_group * vg ,
int consistent , void * handle ) )
2001-10-06 01:39:30 +04:00
{
int opt = 0 ;
int ret_max = 0 ;
int ret = 0 ;
2002-11-18 17:04:08 +03:00
struct list * slh , * vgnames ;
struct volume_group * vg ;
2001-10-06 01:39:30 +04:00
2002-02-11 18:42:34 +03:00
char * vg_name ;
2002-04-24 22:20:51 +04:00
char * dev_dir = cmd - > dev_dir ;
2002-02-11 18:42:34 +03:00
2001-10-06 01:39:30 +04:00
if ( argc ) {
log_verbose ( " Using volume group(s) on command line " ) ;
2002-02-11 18:42:34 +03:00
for ( ; opt < argc ; opt + + ) {
vg_name = argv [ opt ] ;
2002-04-24 22:20:51 +04:00
if ( ! strncmp ( vg_name , dev_dir , strlen ( dev_dir ) ) )
vg_name + = strlen ( dev_dir ) ;
if ( strchr ( vg_name , ' / ' ) ) {
log_error ( " Invalid volume group name: %s " ,
vg_name ) ;
continue ;
}
2002-03-15 19:07:38 +03:00
if ( ! lock_vol ( cmd , vg_name , lock_type ) ) {
2002-02-11 18:42:34 +03:00
log_error ( " Can't lock %s: skipping " , vg_name ) ;
continue ;
}
2002-11-18 17:04:08 +03:00
log_verbose ( " Finding volume group \" %s \" " , vg_name ) ;
vg = vg_read ( cmd , vg_name , & consistent ) ;
if ( ( ret = process_single ( cmd , vg_name , vg , consistent ,
handle ) )
> ret_max )
2001-10-06 01:39:30 +04:00
ret_max = ret ;
2002-03-11 18:08:39 +03:00
unlock_vg ( cmd , vg_name ) ;
2002-02-11 18:42:34 +03:00
}
2001-10-06 01:39:30 +04:00
} else {
2002-01-16 17:43:27 +03:00
log_verbose ( " Finding all volume groups " ) ;
2002-11-18 17:04:08 +03:00
if ( ! ( vgnames = get_vgs ( cmd , 0 ) ) | | list_empty ( vgnames ) ) {
2001-10-06 01:39:30 +04:00
log_error ( " No volume groups found " ) ;
return ECMD_FAILED ;
}
2002-11-18 17:04:08 +03:00
list_iterate ( slh , vgnames ) {
vg_name = list_item ( slh , struct str_list ) - > str ;
if ( ! vg_name | | ! * vg_name )
continue ; /* FIXME Unnecessary? */
2002-03-15 19:07:38 +03:00
if ( ! lock_vol ( cmd , vg_name , lock_type ) ) {
2002-02-11 18:42:34 +03:00
log_error ( " Can't lock %s: skipping " , vg_name ) ;
continue ;
}
2002-11-18 17:04:08 +03:00
log_verbose ( " Finding volume group \" %s \" " , vg_name ) ;
vg = vg_read ( cmd , vg_name , & consistent ) ;
ret = process_single ( cmd , vg_name , vg , consistent ,
handle ) ;
2001-10-06 01:39:30 +04:00
if ( ret > ret_max )
ret_max = ret ;
2002-03-11 18:08:39 +03:00
unlock_vg ( cmd , vg_name ) ;
2001-10-06 01:39:30 +04:00
}
}
return ret_max ;
}
2001-10-08 22:44:22 +04:00
2002-02-11 23:50:53 +03:00
int process_each_pv_in_vg ( struct cmd_context * cmd , struct volume_group * vg ,
2002-11-18 17:04:08 +03:00
void * handle ,
2002-02-12 00:00:35 +03:00
int ( * process_single ) ( struct cmd_context * cmd ,
struct volume_group * vg ,
2002-11-18 17:04:08 +03:00
struct physical_volume * pv ,
void * handle ) )
2001-11-19 18:20:50 +03:00
{
int ret_max = 0 ;
int ret = 0 ;
struct list * pvh ;
2002-01-21 19:05:23 +03:00
struct physical_volume * pv ;
2001-11-19 18:20:50 +03:00
2002-01-21 19:05:23 +03:00
list_iterate ( pvh , & vg - > pvs ) {
pv = list_item ( pvh , struct pv_list ) - > pv ;
2001-11-19 18:20:50 +03:00
2002-11-18 17:04:08 +03:00
if ( ( ret = process_single ( cmd , vg , pv , handle ) ) > ret_max )
2002-01-21 19:05:23 +03:00
ret_max = ret ;
}
return ret_max ;
2001-11-19 18:20:50 +03:00
}
2002-02-12 00:00:35 +03:00
int process_each_pv ( struct cmd_context * cmd , int argc , char * * argv ,
2002-11-18 17:04:08 +03:00
struct volume_group * vg , void * handle ,
2002-02-12 00:00:35 +03:00
int ( * process_single ) ( struct cmd_context * cmd ,
struct volume_group * vg ,
2002-11-18 17:04:08 +03:00
struct physical_volume * pv ,
void * handle ) )
2001-10-12 01:35:55 +04:00
{
int opt = 0 ;
int ret_max = 0 ;
int ret = 0 ;
2002-01-21 17:28:12 +03:00
struct pv_list * pvl ;
2001-10-12 01:35:55 +04:00
if ( argc ) {
log_verbose ( " Using physical volume(s) on command line " ) ;
for ( ; opt < argc ; opt + + ) {
2002-01-21 17:28:12 +03:00
if ( ! ( pvl = find_pv_in_vg ( vg , argv [ opt ] ) ) ) {
2002-01-30 18:04:48 +03:00
log_error ( " Physical Volume \" %s \" not found in "
" Volume Group \" %s \" " , argv [ opt ] ,
2001-10-12 01:35:55 +04:00
vg - > name ) ;
continue ;
}
2002-11-18 17:04:08 +03:00
ret = process_single ( cmd , vg , pvl - > pv , handle ) ;
2001-10-12 01:35:55 +04:00
if ( ret > ret_max )
ret_max = ret ;
}
} else {
log_verbose ( " Using all physical volume(s) in volume group " ) ;
2002-11-18 17:04:08 +03:00
process_each_pv_in_vg ( cmd , vg , handle , process_single ) ;
2001-10-12 01:35:55 +04:00
}
return ret_max ;
}
2002-04-24 22:20:51 +04:00
char * extract_vgname ( struct cmd_context * cmd , char * lv_name )
2001-11-14 21:38:07 +03:00
{
2001-10-29 16:52:23 +03:00
char * vg_name = lv_name ;
2001-11-06 22:02:26 +03:00
char * st ;
2002-04-24 22:20:51 +04:00
char * dev_dir = cmd - > dev_dir ;
2001-10-29 16:52:23 +03:00
/* Path supplied? */
2001-11-06 22:02:26 +03:00
if ( vg_name & & strchr ( vg_name , ' / ' ) ) {
2001-11-15 20:27:45 +03:00
/* Strip dev_dir (optional) */
2001-11-12 18:10:01 +03:00
if ( ! strncmp ( vg_name , dev_dir , strlen ( dev_dir ) ) )
vg_name + = strlen ( dev_dir ) ;
2001-10-29 16:52:23 +03:00
/* Require exactly one slash */
2001-10-29 21:23:35 +03:00
/* FIXME But allow for consecutive slashes */
2001-10-29 16:52:23 +03:00
if ( ! ( st = strchr ( vg_name , ' / ' ) ) | | ( strchr ( st + 1 , ' / ' ) ) ) {
2002-01-30 18:04:48 +03:00
log_error ( " \" %s \" : Invalid path for Logical Volume " ,
2001-11-14 21:38:07 +03:00
lv_name ) ;
2001-10-29 16:52:23 +03:00
return 0 ;
}
2002-04-24 22:20:51 +04:00
vg_name = pool_strdup ( cmd - > mem , vg_name ) ;
2001-10-29 16:52:23 +03:00
if ( ! vg_name ) {
log_error ( " Allocation of vg_name failed " ) ;
return 0 ;
}
* strchr ( vg_name , ' / ' ) = ' \0 ' ;
return vg_name ;
}
2001-11-06 22:02:26 +03:00
2002-04-24 22:20:51 +04:00
if ( ! ( vg_name = default_vgname ( cmd ) ) ) {
2001-11-06 22:02:26 +03:00
if ( lv_name )
2002-01-30 18:04:48 +03:00
log_error ( " Path required for Logical Volume \" %s \" " ,
2001-11-14 21:38:07 +03:00
lv_name ) ;
2001-11-06 22:02:26 +03:00
return 0 ;
}
2001-11-14 21:38:07 +03:00
2001-11-06 22:02:26 +03:00
return vg_name ;
}
2002-04-24 22:20:51 +04:00
char * default_vgname ( struct cmd_context * cmd )
2001-11-06 22:02:26 +03:00
{
char * vg_path ;
2002-04-24 22:20:51 +04:00
char * dev_dir = cmd - > dev_dir ;
2001-11-06 22:02:26 +03:00
2001-10-29 16:52:23 +03:00
/* Take default VG from environment? */
2001-11-14 21:38:07 +03:00
vg_path = getenv ( " LVM_VG_NAME " ) ;
2001-11-06 22:02:26 +03:00
if ( ! vg_path )
2001-10-29 16:52:23 +03:00
return 0 ;
2001-11-15 20:27:45 +03:00
/* Strip dev_dir (optional) */
2001-11-12 18:10:01 +03:00
if ( ! strncmp ( vg_path , dev_dir , strlen ( dev_dir ) ) )
vg_path + = strlen ( dev_dir ) ;
2001-10-29 16:52:23 +03:00
if ( strchr ( vg_path , ' / ' ) ) {
2002-01-30 18:04:48 +03:00
log_error ( " Environment Volume Group in LVM_VG_NAME invalid: "
" \" %s \" " , vg_path ) ;
2001-10-29 16:52:23 +03:00
return 0 ;
}
2002-04-24 22:20:51 +04:00
return pool_strdup ( cmd - > mem , vg_path ) ;
2001-10-29 16:52:23 +03:00
}
2002-01-21 19:05:23 +03:00
struct list * create_pv_list ( struct pool * mem ,
2002-01-29 20:23:33 +03:00
struct volume_group * vg , int argc , char * * argv )
2002-01-21 19:05:23 +03:00
{
struct list * r ;
struct pv_list * pvl , * new_pvl ;
int i ;
/* Build up list of PVs */
if ( ! ( r = pool_alloc ( mem , sizeof ( * r ) ) ) ) {
log_error ( " Allocation of list failed " ) ;
return NULL ;
}
list_init ( r ) ;
for ( i = 0 ; i < argc ; i + + ) {
if ( ! ( pvl = find_pv_in_vg ( vg , argv [ i ] ) ) ) {
2002-01-30 18:04:48 +03:00
log_err ( " Physical Volume \" %s \" not found in "
" Volume Group \" %s \" " , argv [ i ] , vg - > name ) ;
2002-01-21 19:05:23 +03:00
return NULL ;
}
2002-04-24 22:20:51 +04:00
if ( pvl - > pv - > pe_count = = pvl - > pv - > pe_alloc_count ) {
2002-01-30 18:04:48 +03:00
log_err ( " No free extents on physical volume \" %s \" " ,
2002-01-21 19:05:23 +03:00
argv [ i ] ) ;
continue ;
}
if ( ! ( new_pvl = pool_alloc ( mem , sizeof ( * new_pvl ) ) ) ) {
log_err ( " Unable to allocate physical volume list. " ) ;
return NULL ;
}
memcpy ( new_pvl , pvl , sizeof ( * new_pvl ) ) ;
list_add ( r , & new_pvl - > list ) ;
}
2002-01-29 20:23:33 +03:00
return list_empty ( r ) ? NULL : r ;
2002-01-21 19:05:23 +03:00
}