2004-05-05 21:56:20 +04:00
/*
2008-01-30 17:00:02 +03:00
* Copyright ( C ) 2003 - 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 .
2004-05-05 21:56:20 +04:00
*
* This file is part of LVM2 .
*
* 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 .
2004-05-05 21:56:20 +04:00
*
2007-08-21 00:55:30 +04:00
* You should have received a copy of the GNU Lesser General Public License
2004-05-05 21:56:20 +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
*/
# include "tools.h"
# include "polldaemon.h"
# include <signal.h>
# include <sys/wait.h>
2006-05-10 01:23:51 +04:00
static void _sigchld_handler ( int sig __attribute ( ( unused ) ) )
2004-05-05 21:56:20 +04:00
{
while ( wait4 ( - 1 , NULL , WNOHANG | WUNTRACED , NULL ) > 0 ) ;
}
static int _become_daemon ( struct cmd_context * cmd )
{
pid_t pid ;
struct sigaction act = {
{ _sigchld_handler } ,
. sa_flags = SA_NOCLDSTOP ,
} ;
log_verbose ( " Forking background process " ) ;
sigaction ( SIGCHLD , & act , NULL ) ;
if ( ( pid = fork ( ) ) = = - 1 ) {
log_error ( " fork failed: %s " , strerror ( errno ) ) ;
return 1 ;
}
/* Parent */
if ( pid > 0 )
return 0 ;
/* Child */
if ( setsid ( ) = = - 1 )
log_error ( " Background process failed to setsid: %s " ,
strerror ( errno ) ) ;
init_verbose ( VERBOSE_BASE_LEVEL ) ;
close ( STDIN_FILENO ) ;
close ( STDOUT_FILENO ) ;
close ( STDERR_FILENO ) ;
strncpy ( * cmd - > argv , " (lvm2copyd) " , strlen ( * cmd - > argv ) ) ;
reset_locking ( ) ;
2009-07-01 21:05:12 +04:00
lvmcache_init ( ) ;
2004-05-05 21:56:20 +04:00
dev_close_all ( ) ;
return 1 ;
}
2009-09-30 21:43:51 +04:00
progress_t poll_mirror_progress ( struct cmd_context * cmd ,
struct logical_volume * lv , const char * name ,
struct daemon_parms * parms )
{
float segment_percent = 0.0 , overall_percent = 0.0 ;
2009-10-01 05:04:27 +04:00
percent_range_t percent_range , overall_percent_range ;
2009-09-30 21:43:51 +04:00
uint32_t event_nr = 0 ;
if ( ! lv_mirror_percent ( cmd , lv , ! parms - > interval , & segment_percent ,
2009-10-01 04:35:29 +04:00
& percent_range , & event_nr ) | |
( percent_range = = PERCENT_INVALID ) ) {
2009-09-30 21:43:51 +04:00
log_error ( " ABORTING: Mirror percentage check failed. " ) ;
return PROGRESS_CHECK_FAILED ;
}
2009-10-01 05:04:27 +04:00
overall_percent = copy_percent ( lv , & overall_percent_range ) ;
2009-09-30 21:43:51 +04:00
if ( parms - > progress_display )
log_print ( " %s: %s: %.1f%% " , name , parms - > progress_title ,
overall_percent ) ;
else
log_verbose ( " %s: %s: %.1f%% " , name , parms - > progress_title ,
overall_percent ) ;
2009-10-01 04:35:29 +04:00
if ( percent_range ! = PERCENT_100 )
2009-09-30 21:43:51 +04:00
return PROGRESS_UNFINISHED ;
2009-10-01 05:04:27 +04:00
if ( overall_percent_range = = PERCENT_100 )
2009-09-30 21:43:51 +04:00
return PROGRESS_FINISHED_ALL ;
return PROGRESS_FINISHED_SEGMENT ;
}
2009-09-29 23:35:26 +04:00
static int _check_lv_status ( struct cmd_context * cmd ,
struct volume_group * vg ,
struct logical_volume * lv ,
const char * name , struct daemon_parms * parms ,
int * finished )
2004-05-05 21:56:20 +04:00
{
2008-11-04 01:14:30 +03:00
struct dm_list * lvs_changed ;
2009-09-30 21:43:51 +04:00
progress_t progress ;
2004-05-05 21:56:20 +04:00
/* By default, caller should not retry */
* finished = 1 ;
if ( parms - > aborting ) {
2009-09-29 23:35:26 +04:00
if ( ! ( lvs_changed = lvs_using_lv ( cmd , vg , lv ) ) ) {
2004-05-05 21:56:20 +04:00
log_error ( " Failed to generate list of copied LVs: "
" can't abort. " ) ;
return 0 ;
}
2009-09-29 23:35:26 +04:00
parms - > poll_fns - > finish_copy ( cmd , vg , lv , lvs_changed ) ;
2004-05-05 21:56:20 +04:00
return 0 ;
}
2009-09-30 22:15:06 +04:00
progress = parms - > poll_fns - > poll_progress ( cmd , lv , name , parms ) ;
2009-09-30 21:43:51 +04:00
if ( progress = = PROGRESS_CHECK_FAILED )
return_0 ;
2004-05-05 21:56:20 +04:00
2009-09-30 21:43:51 +04:00
if ( progress = = PROGRESS_UNFINISHED ) {
2004-05-05 21:56:20 +04:00
/* The only case the caller *should* try again later */
* finished = 0 ;
return 1 ;
}
2009-09-29 23:35:26 +04:00
if ( ! ( lvs_changed = lvs_using_lv ( cmd , vg , lv ) ) ) {
2004-05-05 21:56:20 +04:00
log_error ( " ABORTING: Failed to generate list of copied LVs " ) ;
return 0 ;
}
/* Finished? Or progress to next segment? */
2009-09-30 21:43:51 +04:00
if ( progress = = PROGRESS_FINISHED_ALL ) {
2009-09-29 23:35:26 +04:00
if ( ! parms - > poll_fns - > finish_copy ( cmd , vg , lv , lvs_changed ) )
2004-05-05 21:56:20 +04:00
return 0 ;
} else {
2009-09-29 23:35:26 +04:00
if ( ! parms - > poll_fns - > update_metadata ( cmd , vg , lv , lvs_changed ,
0 ) ) {
2004-05-05 21:56:20 +04:00
log_error ( " ABORTING: Segment progression failed. " ) ;
2009-09-29 23:35:26 +04:00
parms - > poll_fns - > finish_copy ( cmd , vg , lv , lvs_changed ) ;
2004-05-05 21:56:20 +04:00
return 0 ;
}
* finished = 0 ; /* Another segment */
}
return 1 ;
}
2009-09-29 23:35:26 +04:00
static int _wait_for_single_lv ( struct cmd_context * cmd , const char * name , const char * uuid ,
2004-05-05 21:56:20 +04:00
struct daemon_parms * parms )
{
struct volume_group * vg ;
2009-09-29 23:35:26 +04:00
struct logical_volume * lv ;
2004-05-05 21:56:20 +04:00
int finished = 0 ;
2009-09-29 23:35:26 +04:00
/* Poll for completion */
2004-05-05 21:56:20 +04:00
while ( ! finished ) {
/* FIXME Also needed in vg/lvchange -ay? */
/* FIXME Use alarm for regular intervals instead */
2005-03-22 01:40:35 +03:00
if ( parms - > interval & & ! parms - > aborting ) {
2004-05-05 21:56:20 +04:00
sleep ( parms - > interval ) ;
2005-03-22 01:40:35 +03:00
/* Devices might have changed while we slept */
init_full_scan_done ( 0 ) ;
}
2004-05-05 21:56:20 +04:00
/* Locks the (possibly renamed) VG again */
2009-07-01 20:59:37 +04:00
vg = parms - > poll_fns - > get_copy_vg ( cmd , name , uuid ) ;
if ( vg_read_error ( vg ) ) {
2009-07-07 05:18:35 +04:00
vg_release ( vg ) ;
2004-05-05 21:56:20 +04:00
log_error ( " ABORTING: Can't reread VG for %s " , name ) ;
/* What more could we do here? */
return 0 ;
}
2009-09-29 23:35:26 +04:00
if ( ! ( lv = parms - > poll_fns - > get_copy_lv ( cmd , vg , name , uuid ,
parms - > lv_type ) ) ) {
2004-05-05 21:56:20 +04:00
log_error ( " ABORTING: Can't find mirror LV in %s for %s " ,
vg - > name , name ) ;
2009-05-21 07:04:52 +04:00
unlock_and_release_vg ( cmd , vg , vg - > name ) ;
2004-05-05 21:56:20 +04:00
return 0 ;
}
2009-09-29 23:35:26 +04:00
if ( ! _check_lv_status ( cmd , vg , lv , name , parms , & finished ) ) {
2009-05-21 07:04:52 +04:00
unlock_and_release_vg ( cmd , vg , vg - > name ) ;
2004-05-05 21:56:20 +04:00
return 0 ;
}
2009-05-21 07:04:52 +04:00
unlock_and_release_vg ( cmd , vg , vg - > name ) ;
2004-05-05 21:56:20 +04:00
}
return 1 ;
}
static int _poll_vg ( struct cmd_context * cmd , const char * vgname ,
2009-07-01 21:00:50 +04:00
struct volume_group * vg , void * handle )
2004-05-05 21:56:20 +04:00
{
struct daemon_parms * parms = ( struct daemon_parms * ) handle ;
struct lv_list * lvl ;
2009-09-29 23:35:26 +04:00
struct logical_volume * lv ;
2004-05-05 21:56:20 +04:00
const char * name ;
int finished ;
2008-11-04 01:14:30 +03:00
dm_list_iterate_items ( lvl , & vg - > lvs ) {
2009-09-29 23:35:26 +04:00
lv = lvl - > lv ;
if ( ! ( lv - > status & parms - > lv_type ) )
2004-05-05 21:56:20 +04:00
continue ;
2009-09-29 23:35:26 +04:00
if ( ! ( name = parms - > poll_fns - > get_copy_name_from_lv ( lv ) ) )
2004-05-05 21:56:20 +04:00
continue ;
2008-01-30 17:00:02 +03:00
/* FIXME Need to do the activation from _set_up_pvmove here
2004-05-05 21:56:20 +04:00
* if it ' s not running and we ' re not aborting */
2009-09-29 23:35:26 +04:00
if ( _check_lv_status ( cmd , vg , lv , name , parms , & finished ) & &
! finished )
2004-05-05 21:56:20 +04:00
parms - > outstanding_count + + ;
}
return ECMD_PROCESSED ;
}
static void _poll_for_all_vgs ( struct cmd_context * cmd ,
struct daemon_parms * parms )
{
while ( 1 ) {
parms - > outstanding_count = 0 ;
2009-07-01 21:00:50 +04:00
process_each_vg ( cmd , 0 , NULL , READ_FOR_UPDATE , parms , _poll_vg ) ;
2004-05-05 21:56:20 +04:00
if ( ! parms - > outstanding_count )
break ;
sleep ( parms - > interval ) ;
}
}
2009-06-01 18:43:27 +04:00
int poll_daemon ( struct cmd_context * cmd , const char * name , const char * uuid ,
unsigned background ,
2007-12-22 15:13:29 +03:00
uint32_t lv_type , struct poll_functions * poll_fns ,
const char * progress_title )
2004-05-05 21:56:20 +04:00
{
struct daemon_parms parms ;
parms . aborting = arg_count ( cmd , abort_ARG ) ? 1 : 0 ;
parms . background = background ;
parms . interval = arg_uint_value ( cmd , interval_ARG , DEFAULT_INTERVAL ) ;
parms . progress_display = 1 ;
2007-12-22 15:13:29 +03:00
parms . progress_title = progress_title ;
2004-05-05 21:56:20 +04:00
parms . lv_type = lv_type ;
parms . poll_fns = poll_fns ;
if ( parms . interval & & ! parms . aborting )
log_verbose ( " Checking progress every %u seconds " ,
parms . interval ) ;
if ( ! parms . interval ) {
parms . progress_display = 0 ;
/* FIXME Disabled multiple-copy wait_event */
if ( ! name )
parms . interval = DEFAULT_INTERVAL ;
}
if ( parms . background ) {
if ( ! _become_daemon ( cmd ) )
return ECMD_PROCESSED ; /* Parent */
parms . progress_display = 0 ;
/* FIXME Use wait_event (i.e. interval = 0) and */
/* fork one daemon per copy? */
}
2009-09-29 23:35:26 +04:00
/*
* Process one specific task or all incomplete tasks ?
*/
2004-05-05 21:56:20 +04:00
if ( name ) {
2009-09-29 23:35:26 +04:00
if ( ! _wait_for_single_lv ( cmd , name , uuid , & parms ) ) {
2009-09-15 02:47:49 +04:00
stack ;
2004-05-05 21:56:20 +04:00
return ECMD_FAILED ;
2009-09-15 02:47:49 +04:00
}
2004-05-05 21:56:20 +04:00
} else
_poll_for_all_vgs ( cmd , & parms ) ;
return ECMD_PROCESSED ;
}