2004-05-05 01:25:57 +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 01:25:57 +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 01:25:57 +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 01:25:57 +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 "lib.h"
# include "toolcontext.h"
# include "metadata.h"
2004-09-16 22:40:56 +04:00
# include "segtype.h"
2004-05-05 01:25:57 +04:00
# include "display.h"
# include "text_export.h"
# include "text_import.h"
# include "config.h"
# include "defaults.h"
# include "lvm-string.h"
# include "targets.h"
2004-05-05 22:11:43 +04:00
# include "activate.h"
2006-10-03 21:55:20 +04:00
# include "str_list.h"
2005-12-21 22:45:16 +03:00
2010-05-24 21:46:47 +04:00
# include <sys/utsname.h>
2004-05-05 01:25:57 +04:00
enum {
MIRR_DISABLED ,
MIRR_RUNNING ,
MIRR_COMPLETED
} ;
struct mirror_state {
2005-06-01 20:51:55 +04:00
uint32_t default_region_size ;
2004-05-05 01:25:57 +04:00
} ;
2006-04-19 19:33:07 +04:00
static const char * _mirrored_name ( const struct lv_segment * seg )
2004-05-05 01:25:57 +04:00
{
return seg - > segtype - > name ;
}
2006-04-19 19:33:07 +04:00
static void _mirrored_display ( const struct lv_segment * seg )
2004-05-05 01:25:57 +04:00
{
2005-06-01 20:51:55 +04:00
const char * size ;
2005-10-26 20:12:36 +04:00
uint32_t s ;
2005-06-01 20:51:55 +04:00
2004-05-05 01:25:57 +04:00
log_print ( " Mirrors \t \t %u " , seg - > area_count ) ;
log_print ( " Mirror size \t \t %u " , seg - > area_len ) ;
2005-06-01 20:51:55 +04:00
if ( seg - > log_lv )
log_print ( " Mirror log volume \t %s " , seg - > log_lv - > name ) ;
if ( seg - > region_size ) {
size = display_size ( seg - > lv - > vg - > cmd ,
2006-05-10 01:23:51 +04:00
( uint64_t ) seg - > region_size ) ;
2005-06-01 20:51:55 +04:00
log_print ( " Mirror region size \t %s " , size ) ;
}
2004-05-05 01:25:57 +04:00
log_print ( " Mirror original: " ) ;
display_stripe ( seg , 0 , " " ) ;
2005-10-26 20:12:36 +04:00
log_print ( " Mirror destinations: " ) ;
for ( s = 1 ; s < seg - > area_count ; s + + )
display_stripe ( seg , s , " " ) ;
2004-05-05 01:25:57 +04:00
log_print ( " " ) ;
}
2011-08-30 18:55:15 +04:00
static int _mirrored_text_import_area_count ( const struct dm_config_node * sn , uint32_t * area_count )
2004-05-05 01:25:57 +04:00
{
2011-08-30 18:55:15 +04:00
if ( ! dm_config_get_uint32 ( sn , " mirror_count " , area_count ) ) {
2004-05-05 01:25:57 +04:00
log_error ( " Couldn't read 'mirror_count' for "
2011-08-30 18:55:15 +04:00
" segment '%s'. " , dm_config_parent_name ( sn ) ) ;
2004-05-05 01:25:57 +04:00
return 0 ;
}
return 1 ;
}
2011-08-30 18:55:15 +04:00
static int _mirrored_text_import ( struct lv_segment * seg , const struct dm_config_node * sn ,
2005-10-17 03:03:59 +04:00
struct dm_hash_table * pv_hash )
2004-05-05 01:25:57 +04:00
{
2011-08-31 19:19:19 +04:00
const struct dm_config_value * cv ;
2010-12-20 16:12:55 +03:00
const char * logname = NULL ;
2004-05-05 01:25:57 +04:00
2011-08-31 19:19:19 +04:00
if ( dm_config_has_node ( sn , " extents_moved " ) ) {
2011-08-30 18:55:15 +04:00
if ( dm_config_get_uint32 ( sn , " extents_moved " ,
2004-05-05 21:56:20 +04:00
& seg - > extents_copied ) )
2004-05-05 01:25:57 +04:00
seg - > status | = PVMOVE ;
else {
log_error ( " Couldn't read 'extents_moved' for "
2009-07-09 15:29:00 +04:00
" segment %s of logical volume %s. " ,
2011-08-30 18:55:15 +04:00
dm_config_parent_name ( sn ) , seg - > lv - > name ) ;
2004-05-05 01:25:57 +04:00
return 0 ;
}
}
2011-08-31 19:19:19 +04:00
if ( dm_config_has_node ( sn , " region_size " ) ) {
2011-08-30 18:55:15 +04:00
if ( ! dm_config_get_uint32 ( sn , " region_size " ,
2005-06-01 20:51:55 +04:00
& seg - > region_size ) ) {
log_error ( " Couldn't read 'region_size' for "
2009-07-09 15:29:00 +04:00
" segment %s of logical volume %s. " ,
2011-08-30 18:55:15 +04:00
dm_config_parent_name ( sn ) , seg - > lv - > name ) ;
2005-06-01 20:51:55 +04:00
return 0 ;
}
}
2011-08-31 19:19:19 +04:00
if ( dm_config_get_str ( sn , " mirror_log " , & logname ) ) {
2005-06-01 20:51:55 +04:00
if ( ! ( seg - > log_lv = find_lv ( seg - > lv - > vg , logname ) ) ) {
2009-07-09 15:29:00 +04:00
log_error ( " Unrecognised mirror log in "
" segment %s of logical volume %s. " ,
2011-08-30 18:55:15 +04:00
dm_config_parent_name ( sn ) , seg - > lv - > name ) ;
2005-06-01 20:51:55 +04:00
return 0 ;
}
seg - > log_lv - > status | = MIRROR_LOG ;
2008-01-30 17:00:02 +03:00
}
2005-06-01 20:51:55 +04:00
if ( logname & & ! seg - > region_size ) {
2009-07-09 15:29:00 +04:00
log_error ( " Missing region size for mirror log for "
" segment %s of logical volume %s. " ,
2011-08-30 18:55:15 +04:00
dm_config_parent_name ( sn ) , seg - > lv - > name ) ;
2005-06-01 20:51:55 +04:00
return 0 ;
}
2011-08-31 19:19:19 +04:00
if ( ! dm_config_get_list ( sn , " mirrors " , & cv ) ) {
2009-07-09 15:29:00 +04:00
log_error ( " Couldn't find mirrors array for "
" segment %s of logical volume %s. " ,
2011-08-30 18:55:15 +04:00
dm_config_parent_name ( sn ) , seg - > lv - > name ) ;
2004-05-05 01:25:57 +04:00
return 0 ;
}
2011-08-31 19:19:19 +04:00
return text_import_areas ( seg , sn , cv , pv_hash , MIRROR_IMAGE ) ;
2004-05-05 01:25:57 +04:00
}
2006-04-19 19:33:07 +04:00
static int _mirrored_text_export ( const struct lv_segment * seg , struct formatter * f )
2004-05-05 01:25:57 +04:00
{
outf ( f , " mirror_count = %u " , seg - > area_count ) ;
if ( seg - > status & PVMOVE )
2010-01-07 17:46:51 +03:00
outsize ( f , ( uint64_t ) seg - > extents_copied * seg - > lv - > vg - > extent_size ,
" extents_moved = % " PRIu32 , seg - > extents_copied ) ;
2005-06-01 20:51:55 +04:00
if ( seg - > log_lv )
outf ( f , " mirror_log = \" %s \" " , seg - > log_lv - > name ) ;
if ( seg - > region_size )
outf ( f , " region_size = % " PRIu32 , seg - > region_size ) ;
2004-05-05 01:25:57 +04:00
return out_areas ( f , seg , " mirror " ) ;
}
# ifdef DEVMAPPER_SUPPORT
2011-02-18 17:29:39 +03:00
static int _block_on_error_available = 0 ;
static unsigned _mirror_attributes = 0 ;
2006-04-19 19:33:07 +04:00
static struct mirror_state * _mirrored_init_target ( struct dm_pool * mem ,
2006-05-16 20:48:31 +04:00
struct cmd_context * cmd )
2004-05-05 01:25:57 +04:00
{
struct mirror_state * mirr_state ;
2005-10-17 03:03:59 +04:00
if ( ! ( mirr_state = dm_pool_alloc ( mem , sizeof ( * mirr_state ) ) ) ) {
2004-05-05 01:25:57 +04:00
log_error ( " struct mirr_state allocation failed " ) ;
return NULL ;
}
2005-06-01 20:51:55 +04:00
mirr_state - > default_region_size = 2 *
2006-05-16 20:48:31 +04:00
find_config_tree_int ( cmd ,
2004-05-05 01:25:57 +04:00
" activation/mirror_region_size " ,
DEFAULT_MIRROR_REGION_SIZE ) ;
return mirr_state ;
}
2009-10-01 04:35:29 +04:00
static int _mirrored_target_percent ( void * * target_state ,
2010-11-30 14:53:31 +03:00
percent_t * percent ,
2009-10-01 04:35:29 +04:00
struct dm_pool * mem ,
struct cmd_context * cmd ,
struct lv_segment * seg , char * params ,
uint64_t * total_numerator ,
uint64_t * total_denominator )
2004-05-05 01:25:57 +04:00
{
uint64_t numerator , denominator ;
2005-09-02 20:59:46 +04:00
unsigned mirror_count , m ;
int used ;
char * pos = params ;
2004-05-05 01:25:57 +04:00
if ( ! * target_state )
2006-05-16 20:48:31 +04:00
* target_state = _mirrored_init_target ( mem , cmd ) ;
2004-05-05 01:25:57 +04:00
2005-09-02 20:59:46 +04:00
/* Status line: <#mirrors> (maj:min)+ <synced>/<total_regions> */
2004-05-05 01:25:57 +04:00
log_debug ( " Mirror status: %s " , params ) ;
2005-09-02 20:59:46 +04:00
2005-10-17 03:03:59 +04:00
if ( sscanf ( pos , " %u %n " , & mirror_count , & used ) ! = 1 ) {
2005-09-02 20:59:46 +04:00
log_error ( " Failure parsing mirror status mirror count: %s " ,
params ) ;
2004-05-05 01:25:57 +04:00
return 0 ;
}
2005-09-02 20:59:46 +04:00
pos + = used ;
for ( m = 0 ; m < mirror_count ; m + + ) {
if ( sscanf ( pos , " %*x:%*x %n " , & used ) ! = 0 ) {
log_error ( " Failure parsing mirror status devices: %s " ,
params ) ;
return 0 ;
}
pos + = used ;
}
if ( sscanf ( pos , " % " PRIu64 " /% " PRIu64 " %n " , & numerator , & denominator ,
& used ) ! = 2 ) {
log_error ( " Failure parsing mirror status fraction: %s " , params ) ;
return 0 ;
}
pos + = used ;
2004-05-05 01:25:57 +04:00
* total_numerator + = numerator ;
* total_denominator + = denominator ;
2004-05-05 21:56:20 +04:00
if ( seg )
2004-08-18 02:09:02 +04:00
seg - > extents_copied = seg - > area_len * numerator / denominator ;
2004-05-05 01:25:57 +04:00
2010-11-30 14:53:31 +03:00
* percent = make_percent ( numerator , denominator ) ;
2009-10-01 04:35:29 +04:00
2004-05-05 01:25:57 +04:00
return 1 ;
}
2004-05-05 22:11:43 +04:00
2010-05-24 19:32:20 +04:00
static int _mirrored_transient_status ( struct lv_segment * seg , char * params )
{
2012-02-24 02:30:20 +04:00
unsigned i , j ;
2010-05-24 19:32:20 +04:00
struct logical_volume * lv = seg - > lv ;
struct lvinfo info ;
char * p = NULL ;
char * * args , * * log_args ;
struct logical_volume * * images ;
struct logical_volume * log ;
2012-02-24 02:30:20 +04:00
unsigned num_devs , log_argc ;
2010-05-24 19:32:20 +04:00
int failed = 0 ;
char * status ;
2010-08-04 19:55:03 +04:00
log_very_verbose ( " Mirrored transient status: \" %s \" " , params ) ;
2010-05-24 19:32:20 +04:00
/* number of devices */
if ( ! dm_split_words ( params , 1 , 0 , & p ) )
return_0 ;
2012-02-24 02:30:20 +04:00
if ( ! ( num_devs = ( unsigned ) atoi ( p ) ) )
2010-05-24 19:32:20 +04:00
return_0 ;
p + = strlen ( p ) + 1 ;
2012-02-24 02:30:20 +04:00
if ( num_devs > DEFAULT_MIRROR_MAX_IMAGES ) {
2010-05-24 19:32:20 +04:00
log_error ( " Unexpectedly many (%d) mirror images in %s. " ,
num_devs , lv - > name ) ;
2012-02-24 02:24:47 +04:00
return 0 ;
2010-05-24 19:32:20 +04:00
}
args = alloca ( ( num_devs + 5 ) * sizeof ( char * ) ) ;
images = alloca ( num_devs * sizeof ( struct logical_volume * ) ) ;
2012-02-24 02:30:20 +04:00
/* FIXME: dm_split_words() should return unsigned */
if ( ( unsigned ) dm_split_words ( p , num_devs + 4 , 0 , args ) < num_devs + 4 )
2010-05-24 19:32:20 +04:00
return_0 ;
2012-02-24 02:30:20 +04:00
log_argc = ( unsigned ) atoi ( args [ 3 + num_devs ] ) ;
2010-05-24 19:32:20 +04:00
2012-02-24 02:30:20 +04:00
if ( log_argc > 16 ) {
2010-05-24 19:32:20 +04:00
log_error ( " Unexpectedly many (%d) log arguments in %s. " ,
log_argc , lv - > name ) ;
2012-02-24 02:24:47 +04:00
return 0 ;
2010-05-24 19:32:20 +04:00
}
2012-02-08 15:29:13 +04:00
log_args = alloca ( log_argc * sizeof ( char * ) ) ;
2010-05-24 19:32:20 +04:00
2012-02-24 02:30:20 +04:00
if ( ( unsigned ) dm_split_words ( args [ 3 + num_devs ] + strlen ( args [ 3 + num_devs ] ) + 1 ,
log_argc , 0 , log_args ) < log_argc )
2010-05-24 19:32:20 +04:00
return_0 ;
if ( num_devs ! = seg - > area_count ) {
log_error ( " Active mirror has a wrong number of mirror images! " ) ;
log_error ( " Metadata says %d, kernel says %d. " , seg - > area_count , num_devs ) ;
2012-02-24 02:24:47 +04:00
return 0 ;
2010-05-24 19:32:20 +04:00
}
if ( ! strcmp ( log_args [ 0 ] , " disk " ) ) {
char buf [ 32 ] ;
log = first_seg ( lv ) - > log_lv ;
2010-12-01 16:01:36 +03:00
if ( ! lv_info ( lv - > vg - > cmd , log , 0 , & info , 0 , 0 ) ) {
log_error ( " Check for existence of mirror log %s failed. " ,
log - > name ) ;
return 0 ;
}
2010-05-24 19:32:20 +04:00
log_debug ( " Found mirror log at %d:%d " , info . major , info . minor ) ;
sprintf ( buf , " %d:%d " , info . major , info . minor ) ;
if ( strcmp ( buf , log_args [ 1 ] ) ) {
log_error ( " Mirror log mismatch. Metadata says %s, kernel says %s. " ,
buf , log_args [ 1 ] ) ;
2012-02-24 02:24:47 +04:00
return 0 ;
2010-05-24 19:32:20 +04:00
}
log_very_verbose ( " Status of log (%s): %s " , buf , log_args [ 2 ] ) ;
if ( log_args [ 2 ] [ 0 ] ! = ' A ' ) {
log - > status | = PARTIAL_LV ;
+ + failed ;
}
}
for ( i = 0 ; i < num_devs ; + + i )
images [ i ] = NULL ;
for ( i = 0 ; i < seg - > area_count ; + + i ) {
char buf [ 32 ] ;
2010-12-01 16:01:36 +03:00
if ( ! lv_info ( lv - > vg - > cmd , seg_lv ( seg , i ) , 0 , & info , 0 , 0 ) ) {
log_error ( " Check for existence of mirror image %s failed. " ,
seg_lv ( seg , i ) - > name ) ;
return 0 ;
}
log_debug ( " Found mirror image at %d:%d " , info . major , info . minor ) ;
2010-05-24 19:32:20 +04:00
sprintf ( buf , " %d:%d " , info . major , info . minor ) ;
for ( j = 0 ; j < num_devs ; + + j ) {
if ( ! strcmp ( buf , args [ j ] ) ) {
log_debug ( " Match: metadata image %d matches kernel image %d " , i , j ) ;
images [ j ] = seg_lv ( seg , i ) ;
}
}
}
status = args [ 2 + num_devs ] ;
for ( i = 0 ; i < num_devs ; + + i ) {
if ( ! images [ i ] ) {
log_error ( " Failed to find image %d (%s). " , i , args [ i ] ) ;
2012-02-24 02:24:47 +04:00
return 0 ;
2010-05-24 19:32:20 +04:00
}
log_very_verbose ( " Status of image %d: %c " , i , status [ i ] ) ;
if ( status [ i ] ! = ' A ' ) {
images [ i ] - > status | = PARTIAL_LV ;
+ + failed ;
}
}
/* update PARTIAL_LV flags across the VG */
if ( failed )
2011-05-07 17:32:05 +04:00
vg_mark_partial_lvs ( lv - > vg , 0 ) ;
2010-05-24 19:32:20 +04:00
return 1 ;
}
2010-04-14 17:01:38 +04:00
static int _add_log ( struct dm_pool * mem , struct lv_segment * seg ,
2011-06-17 18:14:19 +04:00
const struct lv_activate_opts * laopts ,
2005-11-09 16:08:41 +03:00
struct dm_tree_node * node , uint32_t area_count , uint32_t region_size )
2005-11-09 01:52:26 +03:00
{
unsigned clustered = 0 ;
char * log_dlid = NULL ;
2005-12-13 18:57:32 +03:00
uint32_t log_flags = 0 ;
2005-11-09 01:52:26 +03:00
/*
2008-01-30 17:00:02 +03:00
* Use clustered mirror log for non - exclusive activation
2005-11-09 01:52:26 +03:00
* in clustered VG .
*/
2011-06-17 18:17:16 +04:00
if ( ! laopts - > exclusive & & vg_is_clustered ( seg - > lv - > vg ) )
2005-11-09 01:52:26 +03:00
clustered = 1 ;
2006-05-11 23:47:53 +04:00
if ( seg - > log_lv ) {
/* If disk log, use its UUID */
2010-04-14 17:01:38 +04:00
if ( ! ( log_dlid = build_dm_uuid ( mem , seg - > log_lv - > lvid . s , NULL ) ) ) {
2006-05-11 23:47:53 +04:00
log_error ( " Failed to build uuid for log LV %s. " ,
seg - > log_lv - > name ) ;
return 0 ;
}
} else {
/* If core log, use mirror's UUID and set DM_CORELOG flag */
2010-04-14 17:01:38 +04:00
if ( ! ( log_dlid = build_dm_uuid ( mem , seg - > lv - > lvid . s , NULL ) ) ) {
2006-05-11 23:47:53 +04:00
log_error ( " Failed to build uuid for mirror LV %s. " ,
seg - > lv - > name ) ;
return 0 ;
}
log_flags | = DM_CORELOG ;
2005-11-09 01:52:26 +03:00
}
2006-05-11 22:39:24 +04:00
if ( mirror_in_sync ( ) & & ! ( seg - > status & PVMOVE ) )
log_flags | = DM_NOSYNC ;
2005-12-20 00:01:39 +03:00
if ( _block_on_error_available & & ! ( seg - > status & PVMOVE ) )
2005-12-13 18:57:32 +03:00
log_flags | = DM_BLOCK_ON_ERROR ;
2005-12-20 00:01:39 +03:00
return dm_tree_node_add_mirror_target_log ( node , region_size , clustered , log_dlid , area_count , log_flags ) ;
2005-11-09 01:52:26 +03:00
}
2006-04-19 19:33:07 +04:00
static int _mirrored_add_target_line ( struct dev_manager * dm , struct dm_pool * mem ,
2011-06-17 18:14:19 +04:00
struct cmd_context * cmd , void * * target_state ,
struct lv_segment * seg ,
const struct lv_activate_opts * laopts ,
struct dm_tree_node * node , uint64_t len ,
uint32_t * pvmove_mirror_count )
2005-11-09 01:52:26 +03:00
{
struct mirror_state * mirr_state ;
uint32_t area_count = seg - > area_count ;
2006-05-10 01:23:51 +04:00
unsigned start_area = 0u ;
2005-11-09 01:52:26 +03:00
int mirror_status = MIRR_RUNNING ;
2009-11-18 19:48:10 +03:00
uint32_t region_size ;
2005-11-09 01:52:26 +03:00
int r ;
2012-02-13 15:07:55 +04:00
if ( ! * target_state & &
! ( * target_state = _mirrored_init_target ( mem , cmd ) ) )
return_0 ;
2005-11-09 01:52:26 +03:00
mirr_state = * target_state ;
2008-01-17 20:17:09 +03:00
/*
* Mirror segment could have only 1 area temporarily
* if the segment is under conversion .
*/
2008-01-16 22:18:51 +03:00
if ( seg - > area_count = = 1 )
mirror_status = MIRR_DISABLED ;
2005-11-09 01:52:26 +03:00
/*
* For pvmove , only have one mirror segment RUNNING at once .
* Segments before this are COMPLETED and use 2 nd area .
* Segments after this are DISABLED and use 1 st area .
*/
if ( seg - > status & PVMOVE ) {
if ( seg - > extents_copied = = seg - > area_len ) {
mirror_status = MIRR_COMPLETED ;
start_area = 1 ;
} else if ( ( * pvmove_mirror_count ) + + ) {
mirror_status = MIRR_DISABLED ;
area_count = 1 ;
}
/* else MIRR_RUNNING */
}
if ( mirror_status ! = MIRR_RUNNING ) {
2011-11-29 00:37:51 +04:00
if ( ! add_linear_area_to_dtree ( node , len , seg - > lv - > vg - > extent_size ,
cmd - > use_linear_target ,
seg - > lv - > vg - > name , seg - > lv - > name ) )
2005-11-09 01:52:26 +03:00
return_0 ;
goto done ;
}
if ( ! ( seg - > status & PVMOVE ) ) {
if ( ! seg - > region_size ) {
log_error ( " Missing region size for mirror segment. " ) ;
return 0 ;
}
region_size = seg - > region_size ;
2009-11-18 19:48:10 +03:00
} else
region_size = adjusted_mirror_region_size ( seg - > lv - > vg - > extent_size ,
seg - > area_len ,
mirr_state - > default_region_size ) ;
2005-11-09 01:52:26 +03:00
2005-11-09 16:08:41 +03:00
if ( ! dm_tree_node_add_mirror_target ( node , len ) )
2005-11-09 01:52:26 +03:00
return_0 ;
2011-06-17 18:14:19 +04:00
if ( ( r = _add_log ( mem , seg , laopts , node , area_count , region_size ) ) < = 0 ) {
2005-11-09 01:52:26 +03:00
stack ;
return r ;
}
done :
2005-11-10 17:45:39 +03:00
return add_areas_line ( dm , seg , node , start_area , area_count ) ;
2005-11-09 01:52:26 +03:00
}
2009-02-28 23:04:24 +03:00
static int _mirrored_target_present ( struct cmd_context * cmd ,
const struct lv_segment * seg ,
2008-04-07 14:23:47 +04:00
unsigned * attributes )
2004-05-05 22:11:43 +04:00
{
2006-04-19 19:33:07 +04:00
static int _mirrored_checked = 0 ;
static int _mirrored_present = 0 ;
2005-12-20 00:01:39 +03:00
uint32_t maj , min , patchlevel ;
2006-01-04 21:09:52 +03:00
unsigned maj2 , min2 , patchlevel2 ;
2008-01-30 17:00:02 +03:00
char vsn [ 80 ] ;
2010-05-24 21:46:47 +04:00
struct utsname uts ;
2010-05-25 03:11:34 +04:00
unsigned kmaj , kmin , krel ;
2004-05-05 22:11:43 +04:00
2006-04-19 19:33:07 +04:00
if ( ! _mirrored_checked ) {
2009-02-28 23:04:24 +03:00
_mirrored_present = target_present ( cmd , " mirror " , 1 ) ;
2004-05-05 22:11:43 +04:00
2005-12-20 00:01:39 +03:00
/*
2009-08-13 23:36:04 +04:00
* block_on_error available as " block_on_error " log
* argument with mirror target > = 1.1 and < = 1.11
2005-12-20 00:01:39 +03:00
* or with 1.0 in RHEL4U3 driver > = 4.5
2009-08-13 23:36:04 +04:00
*
* block_on_error available as " handle_errors " mirror
* argument with mirror target > = 1.12 .
*
* libdm - deptree . c is smart enough to handle the differences
* between block_on_error and handle_errors for all
* mirror target versions > = 1.1
2005-12-20 00:01:39 +03:00
*/
2005-12-20 01:36:04 +03:00
/* FIXME Move this into libdevmapper */
2005-12-20 00:01:39 +03:00
if ( target_version ( " mirror " , & maj , & min , & patchlevel ) & &
2008-01-30 17:00:02 +03:00
maj = = 1 & &
2009-08-13 23:36:04 +04:00
( ( min > = 1 ) | |
2005-12-20 00:01:39 +03:00
( min = = 0 & & driver_version ( vsn , sizeof ( vsn ) ) & &
2006-01-04 21:09:52 +03:00
sscanf ( vsn , " %u.%u.%u " , & maj2 , & min2 , & patchlevel2 ) = = 3 & &
maj2 = = 4 & & min2 = = 5 & & patchlevel2 = = 0 ) ) ) /* RHEL4U3 */
2005-12-20 00:01:39 +03:00
_block_on_error_available = 1 ;
}
2008-04-07 14:23:47 +04:00
/*
* Check only for modules if atttributes requested and no previous check .
2008-04-10 22:53:36 +04:00
* FIXME : Fails incorrectly if cmirror was built into kernel .
2008-04-07 14:23:47 +04:00
*/
if ( attributes ) {
2010-05-24 21:46:47 +04:00
if ( ! _mirror_attributes ) {
/*
* The dm - log - userspace module was added to the
* 2.6 .31 kernel .
*/
2010-05-25 03:11:34 +04:00
if ( ! uname ( & uts ) & &
( sscanf ( uts . release , " %u.%u.%u " , & kmaj , & kmin , & krel ) = = 3 ) & &
KERNEL_VERSION ( kmaj , kmin , krel ) < KERNEL_VERSION ( 2 , 6 , 31 ) ) {
2010-05-24 21:46:47 +04:00
if ( module_present ( cmd , " log-clustered " ) )
_mirror_attributes | = MIRROR_LOG_CLUSTERED ;
} else if ( module_present ( cmd , " log-userspace " ) )
_mirror_attributes | = MIRROR_LOG_CLUSTERED ;
2010-07-21 17:40:21 +04:00
2010-08-17 02:54:35 +04:00
if ( ! ( _mirror_attributes & MIRROR_LOG_CLUSTERED ) )
log_verbose ( " Cluster mirror log module is not available " ) ;
2010-07-21 17:40:21 +04:00
2010-08-17 02:54:35 +04:00
/*
* The cluster mirror log daemon must be running ,
* otherwise , the kernel module will fail to make
* contact .
*/
2010-07-21 19:21:24 +04:00
# ifdef CMIRRORD_PIDFILE
2010-08-17 02:54:35 +04:00
if ( ! dm_daemon_is_running ( CMIRRORD_PIDFILE ) ) {
log_verbose ( " Cluster mirror log daemon is not running " ) ;
_mirror_attributes & = ~ MIRROR_LOG_CLUSTERED ;
}
2010-07-21 19:21:24 +04:00
# else
log_verbose ( " Cluster mirror log daemon not included in build " ) ;
_mirror_attributes & = ~ MIRROR_LOG_CLUSTERED ;
# endif
2010-05-24 21:46:47 +04:00
}
2008-04-07 14:23:47 +04:00
* attributes = _mirror_attributes ;
}
2006-04-19 19:33:07 +04:00
_mirrored_checked = 1 ;
2004-05-05 22:11:43 +04:00
2006-04-19 19:33:07 +04:00
return _mirrored_present ;
2004-05-05 22:11:43 +04:00
}
2005-12-02 23:35:07 +03:00
# ifdef DMEVENTD
2010-08-17 02:54:35 +04:00
static const char * _get_mirror_dso_path ( struct cmd_context * cmd )
2005-12-02 23:35:07 +03:00
{
2010-08-17 02:54:35 +04:00
return get_monitor_dso_path ( cmd , find_config_tree_str ( cmd , " dmeventd/mirror_library " ,
DEFAULT_DMEVENTD_MIRROR_LIB ) ) ;
2005-12-02 23:35:07 +03:00
}
2010-08-17 05:16:41 +04:00
/* FIXME Cache this */
2010-08-17 02:54:35 +04:00
static int _target_registered ( struct lv_segment * seg , int * pending )
2007-01-17 18:00:57 +03:00
{
2010-08-17 02:54:35 +04:00
return target_registered_with_dmeventd ( seg - > lv - > vg - > cmd , _get_mirror_dso_path ( seg - > lv - > vg - > cmd ) ,
2010-08-17 05:16:41 +04:00
seg - > lv , pending ) ;
2007-01-12 23:38:30 +03:00
}
2005-12-02 23:35:07 +03:00
/* FIXME This gets run while suspended and performs banned operations. */
2010-08-17 02:54:35 +04:00
static int _target_set_events ( struct lv_segment * seg , int evmask , int set )
2005-12-02 23:35:07 +03:00
{
2010-08-17 02:54:35 +04:00
return target_register_events ( seg - > lv - > vg - > cmd , _get_mirror_dso_path ( seg - > lv - > vg - > cmd ) ,
2010-08-17 05:16:41 +04:00
seg - > lv , evmask , set , 0 ) ;
2005-12-02 23:35:07 +03:00
}
2007-01-24 19:51:24 +03:00
static int _target_monitor_events ( struct lv_segment * seg , int events )
2005-12-02 23:35:07 +03:00
{
2007-01-24 19:51:24 +03:00
return _target_set_events ( seg , events , 1 ) ;
2007-01-17 18:00:57 +03:00
}
2005-12-02 23:35:07 +03:00
2007-01-24 19:51:24 +03:00
static int _target_unmonitor_events ( struct lv_segment * seg , int events )
2007-01-17 18:00:57 +03:00
{
2007-01-24 19:51:24 +03:00
return _target_set_events ( seg , events , 0 ) ;
2005-12-02 23:35:07 +03:00
}
# endif /* DMEVENTD */
# endif /* DEVMAPPER_SUPPORT */
2004-05-05 01:25:57 +04:00
2006-10-03 21:55:20 +04:00
static int _mirrored_modules_needed ( struct dm_pool * mem ,
const struct lv_segment * seg ,
2008-11-04 01:14:30 +03:00
struct dm_list * modules )
2006-10-03 21:55:20 +04:00
{
if ( seg - > log_lv & &
! list_segment_modules ( mem , first_seg ( seg - > log_lv ) , modules ) )
return_0 ;
2008-04-10 21:09:32 +04:00
if ( vg_is_clustered ( seg - > lv - > vg ) & &
2006-10-03 21:55:20 +04:00
! str_list_add ( mem , modules , " clog " ) ) {
log_error ( " cluster log string list allocation failed " ) ;
return 0 ;
}
if ( ! str_list_add ( mem , modules , " mirror " ) ) {
log_error ( " mirror string list allocation failed " ) ;
return 0 ;
}
return 1 ;
}
2010-12-20 16:32:49 +03:00
static void _mirrored_destroy ( struct segment_type * segtype )
2004-05-05 01:25:57 +04:00
{
2010-12-20 16:32:49 +03:00
dm_free ( segtype ) ;
2004-05-05 01:25:57 +04:00
}
static struct segtype_handler _mirrored_ops = {
2006-05-10 01:23:51 +04:00
. name = _mirrored_name ,
. display = _mirrored_display ,
. text_import_area_count = _mirrored_text_import_area_count ,
. text_import = _mirrored_text_import ,
. text_export = _mirrored_text_export ,
2004-05-05 01:25:57 +04:00
# ifdef DEVMAPPER_SUPPORT
2006-05-10 01:23:51 +04:00
. add_target_line = _mirrored_add_target_line ,
. target_percent = _mirrored_target_percent ,
. target_present = _mirrored_target_present ,
2010-05-24 19:32:20 +04:00
. check_transient_status = _mirrored_transient_status ,
2011-04-29 04:21:13 +04:00
# ifdef DMEVENTD
2010-08-17 02:54:35 +04:00
. target_monitored = _target_registered ,
2007-01-20 01:21:45 +03:00
. target_monitor_events = _target_monitor_events ,
. target_unmonitor_events = _target_unmonitor_events ,
2011-04-29 04:21:13 +04:00
# endif /* DMEVENTD */
2004-05-05 01:25:57 +04:00
# endif
2006-10-03 21:55:20 +04:00
. modules_needed = _mirrored_modules_needed ,
2006-05-10 01:23:51 +04:00
. destroy = _mirrored_destroy ,
2004-05-05 01:25:57 +04:00
} ;
# ifdef MIRRORED_INTERNAL
struct segment_type * init_mirrored_segtype ( struct cmd_context * cmd )
# else /* Shared */
struct segment_type * init_segtype ( struct cmd_context * cmd ) ;
struct segment_type * init_segtype ( struct cmd_context * cmd )
# endif
{
2011-03-26 00:59:42 +03:00
struct segment_type * segtype = dm_zalloc ( sizeof ( * segtype ) ) ;
2004-05-05 01:25:57 +04:00
2008-01-30 16:19:47 +03:00
if ( ! segtype )
return_NULL ;
2004-05-05 01:25:57 +04:00
segtype - > cmd = cmd ;
segtype - > ops = & _mirrored_ops ;
segtype - > name = " mirror " ;
segtype - > private = NULL ;
2010-08-17 02:54:35 +04:00
segtype - > flags = SEG_AREAS_MIRRORED ;
2011-02-18 17:29:39 +03:00
# ifdef DEVMAPPER_SUPPORT
2011-04-29 04:21:13 +04:00
# ifdef DMEVENTD
2010-08-17 02:54:35 +04:00
if ( _get_mirror_dso_path ( cmd ) )
segtype - > flags | = SEG_MONITORED ;
2011-04-29 04:21:13 +04:00
# endif /* DMEVENTD */
2010-08-17 02:54:35 +04:00
# endif
2004-05-05 01:25:57 +04:00
2004-09-14 21:37:51 +04:00
log_very_verbose ( " Initialised segtype: %s " , segtype - > name ) ;
2004-05-05 01:25:57 +04:00
return segtype ;
}