2003-05-06 16:22:24 +04:00
/*
2004-03-30 23:35:44 +04:00
* Copyright ( C ) 2003 - 2004 Sistina Software , Inc . All rights reserved .
* Copyright ( C ) 2004 Red Hat , Inc . All rights reserved .
2003-05-06 16:22:24 +04:00
*
2004-03-30 23:35:44 +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
* of the GNU General Public License v .2 .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software Foundation ,
* Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
2003-05-06 16:22:24 +04:00
*/
# include "lib.h"
# include "metadata.h"
# include "toolcontext.h"
2004-09-16 22:40:56 +04:00
# include "segtype.h"
2004-05-05 01:25:57 +04:00
# include "display.h"
2004-05-25 00:51:56 +04:00
# include "activate.h"
2005-04-22 19:43:02 +04:00
# include "lv_alloc.h"
2005-06-03 18:49:51 +04:00
# include "lvm-string.h"
2005-08-12 23:23:08 +04:00
/*
* Ensure region size is compatible with volume size .
*/
uint32_t adjusted_mirror_region_size ( uint32_t extent_size , uint32_t extents ,
uint32_t region_size )
{
uint32_t region_max ;
region_max = ( 1 < < ( ffs ( extents ) - 1 ) ) * extent_size ;
if ( region_max < region_size ) {
region_size = region_max ;
log_print ( " Using reduced mirror region size of % " PRIu32
" sectors " , region_max ) ;
return region_max ;
}
return region_size ;
}
2005-06-06 21:12:08 +04:00
/*
* Reduce mirrored_seg to num_mirrors images .
*/
int remove_mirror_images ( struct lv_segment * mirrored_seg , uint32_t num_mirrors )
{
uint32_t m ;
for ( m = num_mirrors ; m < mirrored_seg - > area_count ; m + + ) {
if ( ! lv_remove ( seg_lv ( mirrored_seg , m ) ) ) {
stack ;
return 0 ;
}
}
mirrored_seg - > area_count = num_mirrors ;
return 1 ;
}
int remove_all_mirror_images ( struct logical_volume * lv )
{
struct lv_segment * first_seg , * seg ;
struct logical_volume * lv1 ;
list_iterate_items ( first_seg , & lv - > segments )
break ;
if ( ! remove_mirror_images ( first_seg , 1 ) ) {
stack ;
return 0 ;
}
if ( ! lv_remove ( first_seg - > log_lv ) ) {
stack ;
return 0 ;
}
lv1 = seg_lv ( first_seg , 0 ) ;
lv - > segments = lv1 - > segments ;
lv - > segments . n - > p = & lv - > segments ;
lv - > segments . p - > n = & lv - > segments ;
list_init ( & lv1 - > segments ) ;
lv1 - > le_count = 0 ;
lv1 - > size = 0 ;
if ( ! lv_remove ( lv1 ) ) {
stack ;
return 0 ;
}
lv - > status & = ~ MIRRORED ;
list_iterate_items ( seg , & lv - > segments )
seg - > lv = lv ;
return 1 ;
}
/*
* Add mirror images to an existing mirror
*/
2005-06-06 22:16:33 +04:00
/* FIXME
2005-06-06 21:12:08 +04:00
int add_mirror_images ( struct alloc_handle * ah ,
uint32_t first_area ,
uint32_t num_areas ,
struct logical_volume * lv )
{
}
2005-06-06 22:16:33 +04:00
*/
2005-06-06 21:12:08 +04:00
2005-06-03 18:49:51 +04:00
int create_mirror_layers ( struct alloc_handle * ah ,
uint32_t first_area ,
uint32_t num_mirrors ,
struct logical_volume * lv ,
struct segment_type * segtype ,
uint32_t status ,
uint32_t region_size ,
struct logical_volume * log_lv )
{
uint32_t m ;
struct logical_volume * * img_lvs ;
char * img_name ;
size_t len ;
if ( ! ( img_lvs = alloca ( sizeof ( * img_lvs ) * num_mirrors ) ) ) {
log_error ( " img_lvs allocation failed. "
" Remove new LV and retry. " ) ;
return 0 ;
}
len = strlen ( lv - > name ) + 32 ;
if ( ! ( img_name = alloca ( len ) ) ) {
log_error ( " img_name allocation failed. "
" Remove new LV and retry. " ) ;
return 0 ;
}
if ( lvm_snprintf ( img_name , len , " %s_mimage_%%d " , lv - > name ) < 0 ) {
log_error ( " img_name allocation failed. "
" Remove new LV and retry. " ) ;
return 0 ;
}
for ( m = 0 ; m < num_mirrors ; m + + ) {
if ( ! ( img_lvs [ m ] = lv_create_empty ( lv - > vg - > fid , img_name ,
NULL , LVM_READ | LVM_WRITE ,
ALLOC_INHERIT , 0 , lv - > vg ) ) ) { \
log_error ( " Aborting. Failed to create submirror LV. "
" Remove new LV and retry. " ) ;
return 0 ;
}
if ( ! lv_add_segment ( ah , m , 1 , img_lvs [ m ] ,
get_segtype_from_string ( lv - > vg - > cmd ,
" striped " ) ,
0 , NULL , 0 , 0 , 0 , NULL ) ) {
log_error ( " Aborting. Failed to add submirror segment "
" to %s. Remove new LV and retry. " ,
img_lvs [ m ] - > name ) ;
return 0 ;
}
}
if ( ! lv_add_mirror_segment ( ah , lv , img_lvs , num_mirrors , segtype ,
0 , region_size , log_lv ) ) {
log_error ( " Aborting. Failed to add mirror segment. "
" Remove new LV and retry. " ) ;
return 0 ;
}
return 1 ;
}
2003-05-06 16:22:24 +04:00
/*
* Replace any LV segments on given PV with temporary mirror .
* Returns list of LVs changed .
*/
int insert_pvmove_mirrors ( struct cmd_context * cmd ,
struct logical_volume * lv_mirr ,
2004-08-18 02:09:02 +04:00
struct list * source_pvl ,
2003-05-06 16:22:24 +04:00
struct logical_volume * lv ,
struct list * allocatable_pvs ,
2005-05-09 20:59:01 +04:00
alloc_policy_t alloc ,
2003-05-06 16:22:24 +04:00
struct list * lvs_changed )
{
struct lv_segment * seg ;
struct lv_list * lvl ;
2004-08-18 02:09:02 +04:00
struct pv_list * pvl ;
2005-06-14 21:54:48 +04:00
struct physical_volume * pv ;
uint32_t pe ;
2003-05-06 16:22:24 +04:00
int lv_used = 0 ;
uint32_t s , start_le , extent_count = 0u ;
2004-05-05 01:25:57 +04:00
struct segment_type * segtype ;
2004-08-18 02:09:02 +04:00
struct pe_range * per ;
uint32_t pe_start , pe_end , per_end , stripe_multiplier ;
/* Only 1 PV may feature in source_pvl */
pvl = list_item ( source_pvl - > n , struct pv_list ) ;
2004-05-05 01:25:57 +04:00
if ( ! ( segtype = get_segtype_from_string ( lv - > vg - > cmd , " mirror " ) ) ) {
stack ;
return 0 ;
}
2003-05-06 16:22:24 +04:00
2004-05-25 00:51:56 +04:00
if ( activation ( ) & & segtype - > ops - > target_present & &
! segtype - > ops - > target_present ( ) ) {
log_error ( " %s: Required device-mapper target(s) not "
" detected in your kernel " , segtype - > name ) ;
return 0 ;
}
2004-08-18 02:09:02 +04:00
/* Split LV segments to match PE ranges */
2005-06-01 20:51:55 +04:00
list_iterate_items ( seg , & lv - > segments ) {
2003-05-06 16:22:24 +04:00
for ( s = 0 ; s < seg - > area_count ; s + + ) {
2005-06-01 20:51:55 +04:00
if ( seg_type ( seg , s ) ! = AREA_PV | |
seg_dev ( seg , s ) ! = pvl - > pv - > dev )
2003-05-06 16:22:24 +04:00
continue ;
2004-08-18 02:09:02 +04:00
/* Do these PEs need moving? */
list_iterate_items ( per , pvl - > pe_ranges ) {
2005-06-01 20:51:55 +04:00
pe_start = seg_pe ( seg , s ) ;
2004-08-18 02:09:02 +04:00
pe_end = pe_start + seg - > area_len - 1 ;
per_end = per - > start + per - > count - 1 ;
/* No overlap? */
if ( ( pe_end < per - > start ) | |
( pe_start > per_end ) )
continue ;
2005-05-09 20:59:01 +04:00
if ( seg_is_striped ( seg ) )
2004-08-18 02:09:02 +04:00
stripe_multiplier = seg - > area_count ;
else
stripe_multiplier = 1 ;
if ( ( per - > start ! = pe_start & &
per - > start > pe_start ) & &
! lv_split_segment ( lv , seg - > le +
( per - > start - pe_start ) *
stripe_multiplier ) ) {
stack ;
2003-05-06 16:22:24 +04:00
return 0 ;
}
2004-08-18 02:09:02 +04:00
if ( ( per_end ! = pe_end & &
per_end < pe_end ) & &
! lv_split_segment ( lv , seg - > le +
( per_end - pe_start + 1 ) *
stripe_multiplier ) ) {
stack ;
return 0 ;
}
2003-05-06 16:22:24 +04:00
}
2004-08-18 02:09:02 +04:00
}
}
2003-05-06 16:22:24 +04:00
2004-08-18 02:09:02 +04:00
/* Work through all segments on the supplied PV */
2005-06-01 20:51:55 +04:00
list_iterate_items ( seg , & lv - > segments ) {
2004-08-18 02:09:02 +04:00
for ( s = 0 ; s < seg - > area_count ; s + + ) {
2005-06-01 20:51:55 +04:00
if ( seg_type ( seg , s ) ! = AREA_PV | |
seg_dev ( seg , s ) ! = pvl - > pv - > dev )
2004-08-18 02:09:02 +04:00
continue ;
2005-06-01 20:51:55 +04:00
pe_start = seg_pe ( seg , s ) ;
2004-08-18 02:09:02 +04:00
/* Do these PEs need moving? */
list_iterate_items ( per , pvl - > pe_ranges ) {
per_end = per - > start + per - > count - 1 ;
2003-05-06 16:22:24 +04:00
2004-08-18 02:09:02 +04:00
if ( ( pe_start < per - > start ) | |
( pe_start > per_end ) )
continue ;
log_debug ( " Matched PE range %u-%u against "
" %s %u len %u " , per - > start , per_end ,
2005-06-01 20:51:55 +04:00
dev_name ( seg_dev ( seg , s ) ) ,
seg_pe ( seg , s ) ,
2005-05-03 21:28:23 +04:00
seg - > area_len ) ;
2004-08-18 02:09:02 +04:00
/* First time, add LV to list of LVs affected */
if ( ! lv_used ) {
if ( ! ( lvl = pool_alloc ( cmd - > mem , sizeof ( * lvl ) ) ) ) {
log_error ( " lv_list alloc failed " ) ;
return 0 ;
}
lvl - > lv = lv ;
list_add ( lvs_changed , & lvl - > list ) ;
lv_used = 1 ;
}
2005-06-14 21:54:48 +04:00
pv = seg_pv ( seg , s ) ;
pe = seg_pe ( seg , s ) ;
2004-08-18 02:09:02 +04:00
log_very_verbose ( " Moving %s:%u-%u of %s/%s " ,
dev_name ( pvl - > pv - > dev ) ,
2005-06-14 21:54:48 +04:00
pe , pe + seg - > area_len - 1 ,
2004-08-18 02:09:02 +04:00
lv - > vg - > name , lv - > name ) ;
start_le = lv_mirr - > le_count ;
2005-06-14 21:54:48 +04:00
/* FIXME Clean this up */
release_lv_segment_area ( seg , s , seg - > area_len ) ;
2005-05-09 20:59:01 +04:00
if ( ! lv_extend ( lv_mirr , segtype , 1 ,
2004-08-18 02:09:02 +04:00
seg - > area_len , 0u , seg - > area_len ,
2005-06-14 21:54:48 +04:00
pv , pe ,
2004-08-18 02:09:02 +04:00
PVMOVE , allocatable_pvs ,
2005-05-09 20:59:01 +04:00
alloc ) ) {
2004-09-14 17:56:18 +04:00
log_error ( " Unable to allocate "
" temporary LV for pvmove. " ) ;
2004-08-18 02:09:02 +04:00
return 0 ;
}
2005-06-03 18:49:51 +04:00
set_lv_segment_area_lv ( seg , s , lv_mirr , start_le , 0 ) ;
2004-08-18 02:09:02 +04:00
extent_count + = seg - > area_len ;
lv - > status | = LOCKED ;
break ;
}
2003-05-06 16:22:24 +04:00
}
}
log_verbose ( " Moving %u extents of logical volume %s/%s " , extent_count ,
lv - > vg - > name , lv - > name ) ;
return 1 ;
}
2004-05-05 22:35:04 +04:00
/* Remove a temporary mirror */
2003-05-06 16:22:24 +04:00
int remove_pvmove_mirrors ( struct volume_group * vg ,
struct logical_volume * lv_mirr )
{
2005-06-01 20:51:55 +04:00
struct lv_list * lvl ;
2003-05-06 16:22:24 +04:00
struct logical_volume * lv1 ;
struct lv_segment * seg , * mir_seg ;
uint32_t s , c ;
2004-05-05 22:35:04 +04:00
/* Loop through all LVs except the temporary mirror */
2005-06-01 20:51:55 +04:00
list_iterate_items ( lvl , & vg - > lvs ) {
lv1 = lvl - > lv ;
2003-05-06 16:22:24 +04:00
if ( lv1 = = lv_mirr )
continue ;
2004-05-05 22:35:04 +04:00
/* Find all segments that point at the temporary mirror */
2005-06-01 20:51:55 +04:00
list_iterate_items ( seg , & lv1 - > segments ) {
2003-05-06 16:22:24 +04:00
for ( s = 0 ; s < seg - > area_count ; s + + ) {
2005-06-01 20:51:55 +04:00
if ( seg_type ( seg , s ) ! = AREA_LV | |
seg_lv ( seg , s ) ! = lv_mirr )
2003-05-06 16:22:24 +04:00
continue ;
2004-05-05 22:35:04 +04:00
/* Find the mirror segment pointed at */
2003-05-06 16:22:24 +04:00
if ( ! ( mir_seg = find_seg_by_le ( lv_mirr ,
2005-06-01 20:51:55 +04:00
seg_le ( seg , s ) ) ) ) {
2004-05-05 22:35:04 +04:00
/* FIXME Error message */
2003-05-06 16:22:24 +04:00
log_error ( " No segment found with LE " ) ;
return 0 ;
}
2004-05-05 22:35:04 +04:00
/* Check the segment params are compatible */
/* FIXME Improve error mesg & remove restrcn */
2005-05-09 20:59:01 +04:00
if ( ! seg_is_mirrored ( mir_seg ) | |
2003-05-06 16:22:24 +04:00
! ( mir_seg - > status & PVMOVE ) | |
2005-06-01 20:51:55 +04:00
mir_seg - > le ! = seg_le ( seg , s ) | |
2003-05-06 16:22:24 +04:00
mir_seg - > area_count ! = 2 | |
mir_seg - > area_len ! = seg - > area_len ) {
log_error ( " Incompatible segments " ) ;
return 0 ;
}
2004-05-05 22:35:04 +04:00
/* Replace original segment with newly-mirrored
* area ( or original if reverting )
*/
if ( mir_seg - > extents_copied = =
mir_seg - > area_len )
2003-05-06 16:22:24 +04:00
c = 1 ;
else
c = 0 ;
2005-06-14 21:54:48 +04:00
if ( ! move_lv_segment_area ( seg , s , mir_seg , c ) ) {
2005-05-03 21:28:23 +04:00
stack ;
return 0 ;
}
2003-05-06 16:22:24 +04:00
2005-06-14 21:54:48 +04:00
release_lv_segment_area ( mir_seg , ! c , mir_seg - > area_len ) ;
/* Replace mirror with error segment */
2004-05-05 01:25:57 +04:00
if ( !
( mir_seg - > segtype =
get_segtype_from_string ( vg - > cmd ,
2005-06-14 21:54:48 +04:00
" error " ) ) ) {
log_error ( " Missing error segtype " ) ;
2004-05-05 01:25:57 +04:00
return 0 ;
}
2005-06-14 21:54:48 +04:00
mir_seg - > area_count = 0 ;
2003-05-06 16:22:24 +04:00
2004-05-05 22:35:04 +04:00
/* FIXME Assumes only one pvmove at a time! */
2003-05-06 16:22:24 +04:00
lv1 - > status & = ~ LOCKED ;
}
}
2004-08-18 02:09:02 +04:00
if ( ! lv_merge_segments ( lv1 ) )
stack ;
2003-05-06 16:22:24 +04:00
}
2005-06-14 21:54:48 +04:00
if ( ! lv_empty ( lv_mirr ) ) {
stack ;
return 0 ;
}
2004-08-18 02:09:02 +04:00
2003-05-06 16:22:24 +04:00
return 1 ;
}
2004-05-05 21:56:20 +04:00
const char * get_pvmove_pvname_from_lv_mirr ( struct logical_volume * lv_mirr )
2003-05-06 16:22:24 +04:00
{
struct lv_segment * seg ;
2005-06-01 20:51:55 +04:00
list_iterate_items ( seg , & lv_mirr - > segments ) {
2005-05-09 20:59:01 +04:00
if ( ! seg_is_mirrored ( seg ) )
2003-05-06 16:22:24 +04:00
continue ;
2005-06-14 21:54:48 +04:00
if ( seg_type ( seg , 0 ) ! = AREA_PV )
2003-05-06 16:22:24 +04:00
continue ;
2005-06-01 20:51:55 +04:00
return dev_name ( seg_dev ( seg , 0 ) ) ;
2003-05-06 16:22:24 +04:00
}
return NULL ;
}
2004-05-05 21:56:20 +04:00
const char * get_pvmove_pvname_from_lv ( struct logical_volume * lv )
2003-05-06 16:22:24 +04:00
{
struct lv_segment * seg ;
uint32_t s ;
2005-06-01 20:51:55 +04:00
list_iterate_items ( seg , & lv - > segments ) {
2003-05-06 16:22:24 +04:00
for ( s = 0 ; s < seg - > area_count ; s + + ) {
2005-06-01 20:51:55 +04:00
if ( seg_type ( seg , s ) ! = AREA_LV )
2003-05-06 16:22:24 +04:00
continue ;
2005-06-01 20:51:55 +04:00
return get_pvmove_pvname_from_lv_mirr ( seg_lv ( seg , s ) ) ;
2003-05-06 16:22:24 +04:00
}
}
return NULL ;
}
struct logical_volume * find_pvmove_lv ( struct volume_group * vg ,
2004-05-05 21:56:20 +04:00
struct device * dev ,
uint32_t lv_type )
2003-05-06 16:22:24 +04:00
{
2005-06-01 20:51:55 +04:00
struct lv_list * lvl ;
2003-05-06 16:22:24 +04:00
struct logical_volume * lv ;
struct lv_segment * seg ;
/* Loop through all LVs */
2005-06-01 20:51:55 +04:00
list_iterate_items ( lvl , & vg - > lvs ) {
lv = lvl - > lv ;
2003-05-06 16:22:24 +04:00
2004-05-05 21:56:20 +04:00
if ( ! ( lv - > status & lv_type ) )
2003-05-06 16:22:24 +04:00
continue ;
2004-05-05 22:35:04 +04:00
/* Check segment origins point to pvname */
2005-06-01 20:51:55 +04:00
list_iterate_items ( seg , & lv - > segments ) {
2005-06-14 21:54:48 +04:00
if ( seg_type ( seg , 0 ) ! = AREA_PV )
2003-05-06 16:22:24 +04:00
continue ;
2005-06-01 20:51:55 +04:00
if ( seg_dev ( seg , 0 ) ! = dev )
2003-05-06 16:22:24 +04:00
continue ;
return lv ;
}
}
return NULL ;
}
2004-05-05 21:56:20 +04:00
struct logical_volume * find_pvmove_lv_from_pvname ( struct cmd_context * cmd ,
struct volume_group * vg ,
const char * name ,
uint32_t lv_type )
{
struct physical_volume * pv ;
if ( ! ( pv = find_pv_by_name ( cmd , name ) ) ) {
stack ;
return NULL ;
}
return find_pvmove_lv ( vg , pv - > dev , lv_type ) ;
}
2003-05-06 16:22:24 +04:00
struct list * lvs_using_lv ( struct cmd_context * cmd , struct volume_group * vg ,
struct logical_volume * lv )
{
2005-06-01 20:51:55 +04:00
struct list * lvs ;
2003-05-06 16:22:24 +04:00
struct logical_volume * lv1 ;
2005-06-01 20:51:55 +04:00
struct lv_list * lvl , * lvl1 ;
2003-05-06 16:22:24 +04:00
struct lv_segment * seg ;
uint32_t s ;
if ( ! ( lvs = pool_alloc ( cmd - > mem , sizeof ( * lvs ) ) ) ) {
log_error ( " lvs list alloc failed " ) ;
return NULL ;
}
list_init ( lvs ) ;
/* Loop through all LVs except the one supplied */
2005-06-01 20:51:55 +04:00
list_iterate_items ( lvl1 , & vg - > lvs ) {
lv1 = lvl1 - > lv ;
2003-05-06 16:22:24 +04:00
if ( lv1 = = lv )
continue ;
2004-05-05 22:35:04 +04:00
/* Find whether any segment points at the supplied LV */
2005-06-01 20:51:55 +04:00
list_iterate_items ( seg , & lv1 - > segments ) {
2003-05-06 16:22:24 +04:00
for ( s = 0 ; s < seg - > area_count ; s + + ) {
2005-06-01 20:51:55 +04:00
if ( seg_type ( seg , s ) ! = AREA_LV | |
seg_lv ( seg , s ) ! = lv )
2003-05-06 16:22:24 +04:00
continue ;
if ( ! ( lvl = pool_alloc ( cmd - > mem , sizeof ( * lvl ) ) ) ) {
log_error ( " lv_list alloc failed " ) ;
return NULL ;
}
lvl - > lv = lv1 ;
list_add ( lvs , & lvl - > list ) ;
goto next_lv ;
}
}
next_lv :
2003-07-05 02:34:56 +04:00
;
2003-05-06 16:22:24 +04:00
}
return lvs ;
}
2004-05-05 21:56:20 +04:00
float copy_percent ( struct logical_volume * lv_mirr )
2003-05-06 16:22:24 +04:00
{
uint32_t numerator = 0u , denominator = 0u ;
struct lv_segment * seg ;
2005-06-01 20:51:55 +04:00
list_iterate_items ( seg , & lv_mirr - > segments ) {
2003-05-06 16:22:24 +04:00
denominator + = seg - > area_len ;
2004-05-05 21:56:20 +04:00
2005-05-09 20:59:01 +04:00
if ( seg_is_mirrored ( seg ) )
2004-05-05 21:56:20 +04:00
numerator + = seg - > extents_copied ;
else
numerator + = seg - > area_len ;
2003-05-06 16:22:24 +04:00
}
return denominator ? ( float ) numerator * 100 / denominator : 100.0 ;
}