2001-10-02 21:09:05 +04:00
/*
* Copyright ( C ) 2001 Sistina Software
*
* LVM is free software ; you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation ; either version 2 , or ( at your option )
* any later version .
*
* LVM is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with LVM ; see the file COPYING . If not , write to
* the Free Software Foundation , 59 Temple Place - Suite 330 ,
* Boston , MA 02111 - 1307 , USA .
*
*/
# include "tools.h"
int pv_max_name_len = 0 ;
int vg_max_name_len = 0 ;
2002-11-18 17:04:08 +03:00
void pvscan_display_single ( struct cmd_context * cmd , struct physical_volume * pv ,
void * handle )
{
char uuid [ 64 ] ;
int vg_name_len = 0 ;
char * s1 , * s2 ;
char pv_tmp_name [ NAME_LEN ] = { 0 , } ;
char vg_tmp_name [ NAME_LEN ] = { 0 , } ;
char vg_name_this [ NAME_LEN ] = { 0 , } ;
/* short listing? */
if ( arg_count ( cmd , short_ARG ) > 0 ) {
log_print ( " %s " , dev_name ( pv - > dev ) ) ;
return ;
}
if ( arg_count ( cmd , verbose_ARG ) > 1 ) {
/* FIXME As per pv_display! Drop through for now. */
/* pv_show(pv); */
/* FIXME - Moved to Volume Group structure */
/* log_print("System Id %s", pv->vg->system_id); */
/* log_print(" "); */
/* return; */
}
memset ( pv_tmp_name , 0 , sizeof ( pv_tmp_name ) ) ;
vg_name_len = strlen ( pv - > vg_name ) + 1 ;
if ( arg_count ( cmd , uuid_ARG ) ) {
if ( ! id_write_format ( & pv - > id , uuid , sizeof ( uuid ) ) ) {
stack ;
return ;
}
sprintf ( pv_tmp_name , " %-*s with UUID %s " ,
pv_max_name_len - 2 , dev_name ( pv - > dev ) , uuid ) ;
} else {
sprintf ( pv_tmp_name , " %s " , dev_name ( pv - > dev ) ) ;
}
if ( ! * pv - > vg_name ) {
log_print ( " PV %-*s %-*s %s [%s] " ,
pv_max_name_len , pv_tmp_name ,
vg_max_name_len , " " ,
pv - > fmt ? pv - > fmt - > name : " " ,
( s1 = display_size ( pv - > size / 2 , SIZE_SHORT ) ) ) ;
dbg_free ( s1 ) ;
return ;
}
if ( pv - > status & EXPORTED_VG ) {
strncpy ( vg_name_this , pv - > vg_name , vg_name_len ) ;
log_print ( " PV %-*s is in exported VG %s "
" [%s / %s free] " ,
pv_max_name_len , pv_tmp_name ,
vg_name_this , ( s1 =
display_size ( pv - > pe_count *
pv - > pe_size / 2 ,
SIZE_SHORT ) ) ,
( s2 = display_size ( ( pv - > pe_count - pv - > pe_alloc_count )
* pv - > pe_size / 2 , SIZE_SHORT ) ) ) ;
dbg_free ( s1 ) ;
dbg_free ( s2 ) ;
return ;
}
sprintf ( vg_tmp_name , " %s " , pv - > vg_name ) ;
log_print
( " PV %-*s VG %-*s %s [%s / %s free] " , pv_max_name_len ,
pv_tmp_name , vg_max_name_len , vg_tmp_name ,
pv - > fmt ? pv - > fmt - > name : " " ,
( s1 = display_size ( pv - > pe_count * pv - > pe_size / 2 , SIZE_SHORT ) ) ,
( s2 =
display_size ( ( pv - > pe_count - pv - > pe_alloc_count ) * pv - > pe_size /
2 , SIZE_SHORT ) ) ) ;
dbg_free ( s1 ) ;
dbg_free ( s2 ) ;
return ;
}
2002-02-11 23:50:53 +03:00
int pvscan ( struct cmd_context * cmd , int argc , char * * argv )
2001-10-02 21:09:05 +04:00
{
int new_pvs_found = 0 ;
int pvs_found = 0 ;
char * s1 , * s2 , * s3 ;
2001-10-31 15:47:01 +03:00
struct list * pvs ;
struct list * pvh ;
2001-10-16 22:07:54 +04:00
struct pv_list * pvl ;
2001-10-02 21:09:05 +04:00
struct physical_volume * pv ;
2001-10-05 02:53:37 +04:00
uint64_t size_total = 0 ;
uint64_t size_new = 0 ;
2001-10-02 21:09:05 +04:00
int len = 0 ;
pv_max_name_len = 0 ;
vg_max_name_len = 0 ;
2002-02-12 00:00:35 +03:00
if ( arg_count ( cmd , novolumegroup_ARG ) & & arg_count ( cmd , exported_ARG ) ) {
2001-10-16 22:07:54 +04:00
log_error ( " Options -e and -n are incompatible " ) ;
2001-10-05 02:53:37 +04:00
return EINVALID_CMD_LINE ;
2001-10-02 21:09:05 +04:00
}
2002-02-12 00:00:35 +03:00
if ( arg_count ( cmd , exported_ARG ) | | arg_count ( cmd , novolumegroup_ARG ) )
2001-10-02 21:09:05 +04:00
log_print ( " WARNING: only considering physical volumes %s " ,
2002-02-12 00:00:35 +03:00
arg_count ( cmd , exported_ARG ) ?
2001-10-02 21:09:05 +04:00
" of exported volume group(s) " : " in no volume group " ) ;
2001-10-24 21:53:50 +04:00
log_verbose ( " Wiping cache of LVM-capable devices " ) ;
2002-02-11 23:50:53 +03:00
persistent_filter_wipe ( cmd - > filter ) ;
2001-10-02 21:09:05 +04:00
2002-11-18 17:04:08 +03:00
log_verbose ( " Wiping internal cache " ) ;
cache_destroy ( ) ;
2001-10-24 21:53:50 +04:00
log_verbose ( " Walking through all physical volumes " ) ;
2002-04-24 22:20:51 +04:00
if ( ! ( pvs = get_pvs ( cmd ) ) )
2001-10-05 02:53:37 +04:00
return ECMD_FAILED ;
2001-10-02 21:09:05 +04:00
/* eliminate exported/new if required */
2001-10-31 15:47:01 +03:00
list_iterate ( pvh , pvs ) {
pvl = list_item ( pvh , struct pv_list ) ;
2002-01-21 19:05:23 +03:00
pv = pvl - > pv ;
2001-10-02 21:09:05 +04:00
2002-04-24 22:20:51 +04:00
if ( ( arg_count ( cmd , exported_ARG )
2002-02-12 00:00:35 +03:00
& & ! ( pv - > status & EXPORTED_VG ) )
| | ( arg_count ( cmd , novolumegroup_ARG ) & & ( * pv - > vg_name ) ) ) {
2001-10-31 15:47:01 +03:00
list_del ( & pvl - > list ) ;
2001-10-02 21:09:05 +04:00
continue ;
}
/* Also check for MD use? */
/*******
if ( MAJOR ( pv_create_kdev_t ( pv [ p ] - > pv_name ) ) ! = MD_MAJOR ) {
log_print
( " WARNING: physical volume \" %s \" belongs to a meta device " ,
pv [ p ] - > pv_name ) ;
}
if ( MAJOR ( pv [ p ] - > pv_dev ) ! = MD_MAJOR )
continue ;
* * * * * * * */
pvs_found + + ;
2001-10-06 01:39:30 +04:00
2001-10-16 22:07:54 +04:00
if ( ! * pv - > vg_name ) {
2001-10-02 21:09:05 +04:00
new_pvs_found + + ;
2001-10-16 22:07:54 +04:00
size_new + = pv - > size ;
size_total + = pv - > size ;
2001-10-31 15:47:01 +03:00
} else
2002-04-24 22:20:51 +04:00
size_total + = ( pv - > pe_count - pv - > pe_alloc_count )
2002-02-12 00:00:35 +03:00
* pv - > pe_size ;
2001-10-02 21:09:05 +04:00
}
/* find maximum pv name length */
pv_max_name_len = vg_max_name_len = 0 ;
2001-10-31 15:47:01 +03:00
list_iterate ( pvh , pvs ) {
2002-01-21 19:05:23 +03:00
pv = list_item ( pvh , struct pv_list ) - > pv ;
2001-10-25 18:04:18 +04:00
len = strlen ( dev_name ( pv - > dev ) ) ;
2001-10-02 21:09:05 +04:00
if ( pv_max_name_len < len )
pv_max_name_len = len ;
len = strlen ( pv - > vg_name ) ;
if ( vg_max_name_len < len )
vg_max_name_len = len ;
}
pv_max_name_len + = 2 ;
vg_max_name_len + = 2 ;
2001-10-31 15:47:01 +03:00
list_iterate ( pvh , pvs )
2002-11-18 17:04:08 +03:00
pvscan_display_single ( cmd , list_item ( pvh , struct pv_list ) - > pv ,
NULL ) ;
2001-10-02 21:09:05 +04:00
if ( ! pvs_found ) {
log_print ( " No matching physical volumes found " ) ;
return 0 ;
}
2001-10-16 22:07:54 +04:00
log_print ( " Total: %d [%s] / in use: %d [%s] / in no VG: %d [%s] " ,
2001-10-02 21:09:05 +04:00
pvs_found ,
( s1 = display_size ( size_total / 2 , SIZE_SHORT ) ) ,
pvs_found - new_pvs_found ,
( s2 =
display_size ( ( size_total - size_new ) / 2 , SIZE_SHORT ) ) ,
2001-10-06 01:39:30 +04:00
new_pvs_found , ( s3 = display_size ( size_new / 2 , SIZE_SHORT ) ) ) ;
2001-10-02 21:09:05 +04:00
dbg_free ( s1 ) ;
dbg_free ( s2 ) ;
dbg_free ( s3 ) ;
return 0 ;
}