Changeset 2558


Ignore:
Timestamp:
Jan 29, 2010, 1:42:51 AM (10 years ago)
Author:
bruno
Message:

r3620@localhost: bruno | 2010-01-28 00:04:14 +0100
Large update of devel branch as sync point around mranalyze-lvm (in progress)

Location:
devel/mr
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • devel/mr/lib/MondoRescue/LVM.pm

    r2542 r2558  
    55# $Id$
    66#
    7 # Copyright B. Cornec 2008
     7# Copyright B. Cornec 2008-2010
    88# Provided under the GPL v2
    99
     
    2626
    2727our @ISA = qw(Exporter);
    28 our @EXPORT = qw(mr_lvm_check mr_lvm_analyze mr_lvm_prepare);
     28our @EXPORT = qw(mr_lvm_check mr_lvm_get_conf mr_lvm_read_conf mr_lvm_write_conf mr_lvm_edit_conf mr_lvm_apply_from_conf);
    2929
    3030=pod
     
    3232=head1 NAME
    3333
    34 MondoRescue::Mindi, part of the mondorescue.org
     34MondoRescue::LVM, part of the mondorescue.org
    3535
    3636=head1 DESCRIPTION
    3737
    38 This modules provides low level functions for the Mindi part of the Mondorescue project
     38This modules provides low level functions for LVM support in the Mondorescue project
    3939
    4040=head1 USAGE
     
    4646This function checks the usage of LVM and gets the version used
    4747It returns 2 parameters, the LVM version, and the lvm command to use if needed
    48 If LVM version is null then no LVM Handling should be done.
     48The LVM version could be undef, 0 (no LVM), 1 or 2 at the moment, or further not yet supported version
     49It potentially takes one parameter, the LVM version, already known, in which case it easily deduced the LVM command.
     50If LVM version is undefined then no LVM Handling should be done.
     51It has to run on on a system where LVM is activated to return useful results so typically on the system to backup
    4952
    5053=cut
    5154
    5255sub mr_lvm_check {
     56
     57my $lvmver = shift;
    5358
    5459# Get params from the conf file
     
    6065
    6166# That file is not mandatory anymore
    62 if (! -x $lvmproc) {
    63     pb_log(1,"$lvmproc doesn't exist\n");
    64 } else {
    65     # Check LVM volumes presence
    66     pb_log(2,"Checking with $lvmproc\n");
    67     open(LVM,$lvmproc) || mr_exit(-1,"Unable to open $lvmproc");
    68     while (<LVM>) {
    69         if (/0 VGs 0 PVs 0 LVs/) {
    70             pb_log(1,"No LVM volumes found in $lvmproc\n");
    71             return(0,undef);
     67if (not defined $lvmver) {
     68    if (! -x $lvmproc) {
     69        pb_log(1,"$lvmproc doesn't exist\n");
     70    } else {
     71        # Check LVM volumes presence
     72        pb_log(2,"Checking with $lvmproc\n");
     73        open(LVM,$lvmproc) || mr_exit(-1,"Unable to open $lvmproc");
     74        while (<LVM>) {
     75            if (/0 VGs 0 PVs 0 LVs/) {
     76                pb_log(1,"No LVM volumes found in $lvmproc\n");
     77                return(0,undef);
     78            }
    7279        }
     80        close(LVM);
    7381    }
    74     close(LVM);
    7582}
    7683
    7784# Check LVM version
    78 my $lvmver = 0;
    79 if (-x $lvmds) {
    80     pb_log(2,"Checking with $lvmds\n");
    81     open(LVM,"$lvmds --help 2>&1 |") || mr_exit(-1,"Unable to execute $lvmds");
    82     while (<LVM>) {
    83         if (/Logical Volume Manager/ || /LVM version:/) {
     85if (not defined $lvmver) {
     86    pb_log(2,"LVM version value is not known\n");
     87    if (-x $lvmds) {
     88        pb_log(2,"Checking with $lvmds\n");
     89        open(LVM,"$lvmds --help 2>&1 |") || mr_exit(-1,"Unable to execute $lvmds");
     90        while (<LVM>) {
     91            if (/Logical Volume Manager/ || /LVM version:/) {
    8492                $lvmver = $_;
    8593                chomp($lvmver);
    8694                $lvmver =~ s/:([0-9])\..*/$1/;
     95            }
    8796        }
     97        close(LVM);
     98        pb_log(2,"Found a LVM version of $lvmver with $lvmds --help\n") if (defined $lvmver);
    8899    }
    89     close(LVM);
    90     pb_log(2,"Found a LVM version of $lvmver with $lvmds --help\n");
    91 }
    92 
    93 if ($lvmver == 0) {
     100}
     101
     102if (not defined $lvmver) {
    94103    pb_log(2,"LVM version value is still not known\n");
    95104    if (-x $lvmcmd) {
     
    105114        }
    106115        close(LVM);
    107         pb_log(2,"Found a LVM version of $lvmver with $lvmcmd version\n");
     116        pb_log(2,"Found a LVM version of $lvmver with $lvmcmd version\n") if (defined $lvmver);
    108117    }
    109118}
    110119
    111 if ($lvmver == 0) {
     120if (not defined $lvmver) {
    112121    # Still not found
    113     mr_exit(-1,"Unable to determine LVM version.\nPlease report to the dev team with the result of the commands:\n$lvmds --help and $lvmcmd version\n");
     122    mr_log(0,"Unable to determine LVM version.\nIf you think this is wrong, please report to the dev team with the result of the commands:\n$lvmds --help and $lvmcmd version\n");
    114123} elsif ($lvmver == 1) {
    115124    $lvmcmd = "$lvmpath";
     
    127136=over 4
    128137
     138=item B<mr_lvm_get_conf>
     139
     140This function returns 1 parameters, the LVM structure or undef if no LVM
     141That LVM structure contains all the information related to the current LVM configuration
     142
     143=cut
     144
     145sub mr_lvm_get_conf {
     146
     147my $lvm = undef;
     148
     149my ($lvmver,$lvmcmd) = mr_lvm_check();
     150return(undef) if ((not defined $lvmver) || ($lvmver == 0));
     151
     152# Analyze the existing physical volumes
     153open(LVM,$lvmcmd."pvs --noheadings --nosuffix --units m --separator : -o pv_name,vg_name,pv_all,pv_fmt,pv_uuid,dev_size,pv_mda_free,pv_mda_size |") || mr_exit(-1,"Unable to execute ".$lvmcmd."pvs");
     154while (<LVM>) {
     155    s/^[\s]*//;
     156
     157    my ($pv_name,$vg_name,$pe_start,$pv_size,$pv_free,$pv_used,$pv_attr,$pv_pe_count,$pv_pe_alloc_count,$pv_tags,$pv_mda_count,$pv_uuid,$dev_size,$pv_mda_free,$pv_mda_size) = split(/:/);
     158
     159=pod
     160
     161The LVM hash is indexed by VGs, provided by the vg_name attribute of the pvs command
     162vg_name              - Name of the volume group linked to this PV
     163
     164=cut
     165
     166    $lvm->{$vg_name}->{'pvnum'}++;
     167
     168=pod
     169
     170The structure contains an array of PVs called pvs and starting at 1, containing the name of the PV as provided by the pv_name attribute of the pvs command
     171pv_name              - Name of the physical volume PV
     172
     173=cut
     174
     175    # Array of PVs for that VG
     176    $lvm->{$vg_name}->{'pvs'}->[$lvm->{$vg_name}->{'pvnum'}] = $pv_name;
     177
     178=pod
     179
     180All the PV fields from the pvs command are gathered under their PV name (substructure)
     181The following names are used:
     182
     183From pvs -o help
     184pe_start             - Offset to the start of data on the underlying device.
     185pv_size              - Size of PV in current units.
     186pv_free              - Total amount of unallocated space in current units.
     187pv_used              - Total amount of allocated space in current units.
     188pv_attr              - Various attributes - see man page.
     189pv_pe_count          - Total number of Physical Extents.
     190pv_pe_alloc_count    - Total number of allocated Physical Extents.
     191pv_tags              - Tags, if any.
     192pv_mda_count         - Number of metadata areas on this device.
     193pv_fmt               - Type of metadata.                                           
     194pv_uuid              - Unique identifier.                                           
     195dev_size             - Size of underlying device in current units.                 
     196pv_mda_free          - Free metadata area space on this device in current units.   
     197pv_mda_size          - Size of smallest metadata area on this device in current units.
     198
     199=cut
     200
     201    $lvm->{$vg_name}->{$pv_name}->{'pe_start'} = $pe_start;
     202    $lvm->{$vg_name}->{$pv_name}->{'pv_size'} = $pv_size;
     203    $lvm->{$vg_name}->{$pv_name}->{'pv_free'} = $pv_free;
     204    $lvm->{$vg_name}->{$pv_name}->{'pv_used'} = $pv_used;
     205    $lvm->{$vg_name}->{$pv_name}->{'pv_attr'} = $pv_attr;
     206    $lvm->{$vg_name}->{$pv_name}->{'pv_pe_count'} = $pv_pe_count;
     207    $lvm->{$vg_name}->{$pv_name}->{'pv_pe_alloc_count'} = $pv_pe_alloc_count;
     208    $lvm->{$vg_name}->{$pv_name}->{'pv_tags'} = $pv_tags;
     209    $lvm->{$vg_name}->{$pv_name}->{'pv_mda_count'} = $pv_mda_count;
     210    $lvm->{$vg_name}->{$pv_name}->{'pv_uuid'} = $pv_uuid;
     211    $lvm->{$vg_name}->{$pv_name}->{'dev_size'} = $dev_size;
     212    $lvm->{$vg_name}->{$pv_name}->{'pv_mda_free'} = $pv_mda_free;
     213    $lvm->{$vg_name}->{$pv_name}->{'pv_mda_size'} = $pv_mda_size;
     214}
     215close(LVM);
     216
     217# Analyze the existing volume groups
     218#open(LVM,$lvmcmd."vgdisplay -c |") || mr_exit(-1,"Unable to execute ".$lvmcmd."vgdisplay -c");
     219open(LVM,$lvmcmd."vgs --noheadings --nosuffix --units m --separator : | -o vg_all") || mr_exit(-1,"Unable to execute ".$lvmcmd."vgs");
     220while (<LVM>) {
     221
     222=pod
     223
     224All the VG fields from the vgs command are gathered under the VG name
     225The following names are used:
     226
     227From vgs -o help
     228vg_fmt               - Type of metadata.                                             
     229vg_uuid              - Unique identifier.                                             
     230vg_attr              - Various attributes - see man page.                             
     231vg_size              - Total size of VG in current units.                             
     232vg_free              - Total amount of free space in current units.                   
     233vg_sysid             - System ID indicating when and where it was created.           
     234vg_extent_size       - Size of Physical Extents in current units.                     
     235vg_extent_count      - Total number of Physical Extents.                             
     236vg_free_count        - Total number of unallocated Physical Extents.                 
     237max_lv               - Maximum number of LVs allowed in VG or 0 if unlimited.         
     238max_pv               - Maximum number of PVs allowed in VG or 0 if unlimited.         
     239pv_count             - Number of PVs.                                                 
     240lv_count             - Number of LVs.                                                 
     241snap_count           - Number of snapshots.                                           
     242vg_seqno             - Revision number of internal metadata.  Incremented whenever it changes.
     243vg_tags              - Tags, if any.                                                         
     244vg_mda_count         - Number of metadata areas in use by this VG.                           
     245vg_mda_free          - Free metadata area space for this VG in current units.                 
     246vg_mda_size          - Size of smallest metadata area for this VG in current units.
     247
     248=cut
     249    s/^[\s]*//;
     250    my ($vg_fmt,$vg_uuid,$vg_name,$vg_attr,$vg_size,$vg_free,$vg_sysid,$vg_extend_size,$vg_extend_count,$vg_free_count,$max_lv,$max_pv,$pv_count,$lv_count,$snap_count,$vg_seqno,$vg_tags,$vg_mda_count,$vg_mda_free,$vg_mda_size) = split(/:/);
     251    $lvm->{$vg_name}->{'vg_fmt'} = $vg_fmt;
     252    $lvm->{$vg_name}->{'vg_uuid'} = $vg_uuid;
     253    $lvm->{$vg_name}->{'vg_attr'} = $vg_attr;
     254    $lvm->{$vg_name}->{'vg_size'} = $vg_size;
     255    $lvm->{$vg_name}->{'vg_free'} = $vg_free;
     256    $lvm->{$vg_name}->{'vg_sysid'} = $vg_sysid;
     257    $lvm->{$vg_name}->{'vg_extend_size'} = $vg_extend_size;
     258    $lvm->{$vg_name}->{'vg_extend_count'} = $vg_extend_count;
     259    $lvm->{$vg_name}->{'vg_free_count'} = $vg_free_count;
     260    $lvm->{$vg_name}->{'max_lv'} = $max_lv;
     261    $lvm->{$vg_name}->{'max_pv'} = $max_pv;
     262    $lvm->{$vg_name}->{'pv_count'} = $pv_count;
     263    $lvm->{$vg_name}->{'lv_count'} = $lv_count;
     264    $lvm->{$vg_name}->{'snap_count'} = $snap_count;
     265    $lvm->{$vg_name}->{'vg_seqno'} = $vg_seqno;
     266    $lvm->{$vg_name}->{'vg_tags'} = $vg_tags;
     267    $lvm->{$vg_name}->{'vg_mda_count'} = $vg_mda_count;
     268    $lvm->{$vg_name}->{'vg_mda_free'} = $vg_mda_free;
     269    $lvm->{$vg_name}->{'vg_mda_size'} = $vg_mda_size;
     270}
     271close(LVM);
     272
     273# Analyze the existing logical volumes
     274#open(LVM,$lvmcmd."lvdisplay -c |") || mr_exit(-1,"Unable to execute ".$lvmcmd."lvdisplay -c");
     275open(LVM,$lvmcmd."lvs --noheadings --nosuffix --units m --separator : -o vg_name,lv_all|") || mr_exit(-1,"Unable to execute ".$lvmcmd."lvs");
     276while (<LVM>) {
     277    s/^[\s]*//;
     278
     279=pod
     280
     281The structure contains an array of LVs called lvs and starting at 1, containing the name of the PV as provided by the pv_name attribute of the pvs command
     282pv_name              - Name of the physical volume PV
     283
     284=cut
     285
     286    # Array of PVs for that VG
     287    $lvm->{$vg_name}->{'pvs'}->[$lvm->{$vg_name}->{'pvnum'}] = $pv_name;
     288
     289=pod
     290
     291All the PV fields from the pvs command are gathered under their PV name (substructure)
     292The following names are used:
     293
     294
     295    # From lvs -o help
     296
     297    #vg_name              - Name of the related volume group
     298    #lv_uuid              - Unique identifier.                           
     299    #lv_name              - Name.  LVs created for internal use are enclosed in brackets.
     300    #lv_attr              - Various attributes - see man page.                           
     301    #lv_major             - Persistent major number or -1 if not persistent.             
     302    #lv_minor             - Persistent minor number or -1 if not persistent.             
     303    #lv_read_ahead        - Read ahead setting in current units.                         
     304    #lv_kernel_major      - Currently assigned major number or -1 if LV is not active.   
     305    #lv_kernel_minor      - Currently assigned minor number or -1 if LV is not active.   
     306    #lv_kernel_read_ahead - Currently-in-use read ahead setting in current units.       
     307    #lv_size              - Size of LV in current units.                                 
     308    #seg_count            - Number of segments in LV.                                   
     309    #origin               - For snapshots, the origin device of this LV.                 
     310    #origin_size          - For snapshots, the size of the origin device of this LV.     
     311    #snap_percent         - For snapshots, the percentage full if LV is active.         
     312    #copy_percent         - For mirrors and pvmove, current percentage in-sync.         
     313    #move_pv              - For pvmove, Source PV of temporary LV created by pvmove.     
     314    #convert_lv           - For lvconvert, Name of temporary LV created by lvconvert.   
     315    #lv_tags              - Tags, if any.                                               
     316    #mirror_log           - For mirrors, the LV holding the synchronisation log.         
     317    #modules              - Kernel device-mapper modules required for this LV.
     318
     319=cut
     320
     321    my ($vg_name,$lv_uuid,$lv_name,$lv_attr,$lv_major,$lv_minor,$lv_read_ahead,$lv_kernel_major,$lv_kernel_minor,$lv_kernel_read_ahead,$lv_size,$seg_count,$origin,$origin_size,$snap_percent,$copy_percent,$move_pv,$convert_lv,$lv_tags,$mirror_log,$modules) = split(/:/);
     322    # The LVM hash is indexed by VGs
     323    $lvm->{$vg_name}->{'lvnum'}++;
     324    # That array will start at 1 then
     325    # Array of LVs for that VG
     326    $lvm->{$vg_name}->{'lvs'}->[$lvm->{$vg_name}->{'lvnum'}] = $lv_name;
     327    # All LV fields gathered under the LV name
     328    $lvm->{$vg_name}->{$lv_name}->{'lv_uuid'} = $lv_uuid;
     329    $lvm->{$vg_name}->{$lv_name}->{'lv_attr'} = $lv_attr;
     330    $lvm->{$vg_name}->{$lv_name}->{'lv_major'} = $lv_major;
     331    $lvm->{$vg_name}->{$lv_name}->{'lv_minor'} = $lv_minor;
     332    $lvm->{$vg_name}->{$lv_name}->{'lv_read_ahead'} = $lv_read_ahead;
     333    $lvm->{$vg_name}->{$lv_name}->{'lv_kernel_major'} = $lv_kernel_major;
     334    $lvm->{$vg_name}->{$lv_name}->{'lv_kernel_minor'} = $lv_kernel_minor;
     335    $lvm->{$vg_name}->{$lv_name}->{'lv_kernel_read_ahead'} = $lv_kernel_read_ahead;
     336    $lvm->{$vg_name}->{$lv_name}->{'lv_size'} = $lv_size;
     337    $lvm->{$vg_name}->{$lv_name}->{'origin'} = $origin;
     338    $lvm->{$vg_name}->{$lv_name}->{'origin_size'} = $origin_size;
     339    $lvm->{$vg_name}->{$lv_name}->{'snap_percent'} = $snap_percent;
     340    $lvm->{$vg_name}->{$lv_name}->{'copy_percent'} = $copy_percent;
     341    $lvm->{$vg_name}->{$lv_name}->{'move_pv'} = $move_pv;
     342    $lvm->{$vg_name}->{$lv_name}->{'convert_lv'} = $convert_lv;
     343    $lvm->{$vg_name}->{$lv_name}->{'lv_tags'} = $lv_tags;
     344    $lvm->{$vg_name}->{$lv_name}->{'mirror_log'} = $mirror_log;
     345    $lvm->{$vg_name}->{$lv_name}->{'modules'} = $modules;
     346}
     347close(LVM);
     348return($lvm);
     349}
     350
    129351=item B<mr_lvm_analyze>
    130352
     
    137359
    138360my $OUTPUT = shift;
    139 my $lvm;
    140361
    141362my ($lvmver,$lvmcmd) = mr_lvm_check();
    142 return(0) if ($lvmver == 0);
     363my $lvm = mr_lvm_get_conf();
     364return(undef) if ($lvmver == 0);
    143365
    144366print $OUTPUT "LVM:$lvmver\n";
     
    150372        s/^[\s]*//;
    151373        my ($pv,$vg,$foo,$foo2,$size,$foo3) = split(/:/);
    152         $lvm->{$vg}->{'pv'}[$lvm->{$vg}->{'pvnum'}] = $pv;
    153374        $lvm->{$vg}->{'pvnum'}++;
     375        # that array will start at 1 then
     376        $lvm->{$vg}->{'pv'}->[$lvm->{$vg}->{'pvnum'}] = $pv;
    154377        $lvm->{$vg}->{$pv}->{'size'} = $size;
    155378        print $OUTPUT "PV:$_";
     
    192415my $OUTPUT = shift;
    193416my $mrmult = shift;
    194 
    195 my ($lvmver,$lvmcmd) = mr_lvm_check();
     417my $lvmcmd;
     418my $lvmver;
    196419
    197420# Generate the startup scrit needed to restore LVM conf
     
    199422# Multiply by the multiplier given in input or 1 of none
    200423
    201 print $OUTPUT "# Desactivate Volume Groups\n";
    202 print $OUTPUT $lvmcmd."vgchange -an\n";
    203 print $OUTPUT "\n";
    204 
    205424my $firsttime = 0;
    206425while (<$INPUT>) {
    207     if (/^PV:/) {
    208         my ($tag,$pvname,$vgname,$pvsize,$ipvn,$pvstat,$pvna,$lvnum,$pesize,$petot,$pefree,$pelloc) = split(/:/);
     426    if (/^LVM:/) {
     427        my $tag;
     428        my $foo;
     429        ($tag,$lvmver) = split(/:/);
     430        ($foo,$lvmcmd) = mr_lvm_check($lvmver);
     431
     432    print $OUTPUT "# Desactivate Volume Groups\n";
     433    print $OUTPUT $lvmcmd."vgchange -an\n";
     434    print $OUTPUT "\n";
     435
     436    } elsif (/^PV:/) {
     437        # This is for pvdisplay -c
     438        #my ($tag,$pvname,$vgname,$pvsize,$ipvn,$pvstat,$pvna,$lvnum,$pesize,$petot,$pefree,$pelloc) = split(/:/);
     439        my ($tag,$pvname,$vgname,$lvmv,$more,$pesize,$pefree) = split(/:/);
    209440        print $OUTPUT "# Creating Physical Volumes $pvname\n";
    210         print $OUTPUT $lvmcmd."pvcreate -ff -y -s ".$pesize*$mrmult." $pvname\n";
     441        print $OUTPUT $lvmcmd."pvcreate -ff -y";
     442        print $OUTPUT " -s ".$pesize*$mrmult if (defined $pesize);
     443        print $OUTPUT " $pvname\n";
    211444        print $OUTPUT "\n";
    212445    } elsif (/^VG:/) {
    213         my ($tag,$vgname,$vgaccess,$vgstat,$vgnum,$lvmaxnum,$lvnum,$ocalvinvg,$lvmaxsize,$pvmaxnum,$cnumpv,$anumpv,$vgsize,$pesize,$penum,$pealloc,$pefree,$uuid) = split(/:/);
     446        # This if for vgdisplay -c
     447        #my ($tag,$vgname,$vgaccess,$vgstat,$vgnum,$lvmaxnum,$lvnum,$ocalvinvg,$lvmaxsize,$pvmaxnum,$cnumpv,$anumpv,$vgsize,$pesize,$penum,$pealloc,$pefree,$uuid) = split(/:/);
     448        my ($tag,$vgname,$pvnum,$lvnum,$attr,$vgsize,$vgfree) = split(/:/);
    214449        if ($lvmver < 2) {
    215450            print $OUTPUT "# Removing device first as LVM v1 doesn't do it\n";
    216451            print $OUTPUT "rm -Rf /dev/$vgname\n";
    217452        }
    218         $lvmaxnum = 255 if ($lvmaxnum > 256);
    219         $pvmaxnum = 255 if ($pvmaxnum > 256);
     453        #$lvmaxnum = 255 if (($lvmaxnum > 256) or (not defined $lvmaxnum));
     454        #$pvmaxnum = 255 if (($pvmaxnum > 256) or (not defined $pvmaxnum));
    220455        print $OUTPUT "# Create Volume Group $vgname\n";
    221456        # Pb sur pesize unite ?
    222         print $OUTPUT $lvmcmd."vgcreate $vgname -p $pvmaxnum -s $pesize -l $lvmaxnum\n";
     457        print $OUTPUT $lvmcmd."vgcreate $vgname ";
     458        #print $OUTPUT "-p $pvmaxnum -l $lvmaxnum";
     459        #print $OUTPUT " -s ".$pesize."\n" if (defined $pesize);
    223460        print $OUTPUT "\n";
     461
    224462    } elsif (/^LV:/) {
    225463        if ($firsttime == 0) {
     
    232470        my ($tag,$lvname,$vgname,$lvaccess,$lvstat,$lvnum,$oclv,$lvsize,$leinlv,$lealloc,$allocpol,$readahead,$major,$minor) = split(/:/);
    233471        print $OUTPUT "# Create Logical Volume $lvname\n";
    234         print $OUTPUT $lvmcmd."lvcreate -n $lvname -L ".$lvsize*$mrmult." -r $readahead $vgname\n";
     472        print $OUTPUT $lvmcmd."lvcreate -n $lvname -L ".$lvsize*$mrmult;
     473        print $OUTPUT " -r $readahead" if (defined $readahead);
     474        print $OUTPUT " $vgname\n";
    235475        #[ "$stripes" ]    && output="$output -i $stripes"
    236476        #[ "$stripesize" ] && output="$output -I $stripesize"
    237477    }
    238478}
     479
    239480print $OUTPUT "\n";
    240481print $OUTPUT "# Scanning again Volume Groups\n";
  • devel/mr/sbin/mranalyze-lvm

    r2541 r2558  
    140140}
    141141
    142 my $lvmver = mr_lvm_analyze($OUTPUT);
     142my $lvm = mr_lvm_analyze($OUTPUT);
    143143
    144 if ($lvmver == 0) {
    145     pb_log(1,"No LVM handling")
     144if (not defined $lvm) {
     145    pb_log(1,"No LVM handling\n") ;
    146146} else {
    147     pb_log(1,"LVM v$lvmver Structure Analyzed")
     147    pb_log(1,"LVM Structure :".Dumper($lvm)."\n");
    148148}
     149
     150open(LVM, "> /tmp/lvm.out") || mr_exit(-1, "Unable to write to /tmp/lvm.out");
     151$lvm = mr_lvm_analyze(\*LVM);
     152close(LVM);
     153open(LVM, "/tmp/lvm.out") || mr_exit(-1, "Unable to read to /tmp/lvm.out");
     154$lvm = mr_lvm_prepare(\*LVM,$OUTPUT,1);
     155close(LVM);
     156
    149157if (defined $opts{'o'}) {
    150158    close($OUTPUT);
Note: See TracChangeset for help on using the changeset viewer.