Changeset 2558 for devel

Timestamp:

01/29/10 01:42:51 (6 months 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)

Files:

• devel/mr/lib/MondoRescue/LVM.pm (modified) (12 diffs)
• devel/mr/sbin/mranalyze-lvm (modified) (1 diff)

devel/mr/lib/MondoRescue/LVM.pm

@@ -5 +5 @@
-# $Id$
-#
-
+-2010
-# Provided under the GPL v2
-
@@ -26 +26 @@
-
-our @ISA = qw(Exporter);
-analyze mr_lvm_prepare
+get_conf mr_lvm_read_conf mr_lvm_write_conf mr_lvm_edit_conf mr_lvm_apply_from_conf
-
-=pod
@@ -32 +32 @@
-=head1 NAME
-
-Mindi
+LVM
-
-=head1 DESCRIPTION
-
-the Mindi part of
+LVM support in
-
-=head1 USAGE
@@ -46 +46 @@
-This function checks the usage of LVM and gets the version used
-It returns 2 parameters, the LVM version, and the lvm command to use if needed
-
+
+
+
+
-
-=cut
-
-sub mr_lvm_check {
+
+my $lvmver = shift;
-
-# Get params from the conf file
@@ -60 +65 @@
-
-# That file is not mandatory anymore
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-        }
+        close(LVM);
-    }
-    close(LVM);
-}
-
-# Check LVM version
-
-
-
-
-
-
+
+
+
+
+
+
+
-                $lvmver = $_;
-                chomp($lvmver);
-                $lvmver =~ s/:([0-9])\..*/$1/;
+            }
-        }
+        close(LVM);
+        pb_log(2,"Found a LVM version of $lvmver with $lvmds --help\n") if (defined $lvmver);
-    }
-
-
-
-
-
+
+
+
-    pb_log(2,"LVM version value is still not known\n");
-    if (-x $lvmcmd) {
@@ -105 +114 @@
-        }
-        close(LVM);
-
+ if (defined $lvmver)
-    }
-}
-
-$lvmver == 0
+not defined $lvmver
-    # Still not found
-exit(-1,"Unable to determine LVM version.\nP
+log(0,"Unable to determine LVM version.\nIf you think this is wrong, p
-} elsif ($lvmver == 1) {
-    $lvmcmd = "$lvmpath";
@@ -127 +136 @@
-=over 4
-
+=item B<mr_lvm_get_conf>
+
+This function returns 1 parameters, the LVM structure or undef if no LVM
+That LVM structure contains all the information related to the current LVM configuration
+
+=cut
+
+sub mr_lvm_get_conf {
+
+my $lvm = undef;
+
+my ($lvmver,$lvmcmd) = mr_lvm_check();
+return(undef) if ((not defined $lvmver) || ($lvmver == 0));
+
+# Analyze the existing physical volumes
+open(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");
+while (<LVM>) {
+    s/^[\s]*//;
+
+    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(/:/);
+
+=pod 
+
+The LVM hash is indexed by VGs, provided by the vg_name attribute of the pvs command
+vg_name              - Name of the volume group linked to this PV
+
+=cut
+
+    $lvm->{$vg_name}->{'pvnum'}++;
+
+=pod
+
+The 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
+pv_name              - Name of the physical volume PV
+
+=cut
+
+    # Array of PVs for that VG
+    $lvm->{$vg_name}->{'pvs'}->[$lvm->{$vg_name}->{'pvnum'}] = $pv_name;
+
+=pod
+
+All the PV fields from the pvs command are gathered under their PV name (substructure)
+The following names are used:
+
+From pvs -o help
+pe_start             - Offset to the start of data on the underlying device.
+pv_size              - Size of PV in current units.
+pv_free              - Total amount of unallocated space in current units.
+pv_used              - Total amount of allocated space in current units.
+pv_attr              - Various attributes - see man page.
+pv_pe_count          - Total number of Physical Extents.
+pv_pe_alloc_count    - Total number of allocated Physical Extents.
+pv_tags              - Tags, if any.
+pv_mda_count         - Number of metadata areas on this device.
+pv_fmt               - Type of metadata.                                            
+pv_uuid              - Unique identifier.                                           
+dev_size             - Size of underlying device in current units.                  
+pv_mda_free          - Free metadata area space on this device in current units.    
+pv_mda_size          - Size of smallest metadata area on this device in current units.
+
+=cut
+
+    $lvm->{$vg_name}->{$pv_name}->{'pe_start'} = $pe_start;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_size'} = $pv_size;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_free'} = $pv_free;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_used'} = $pv_used;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_attr'} = $pv_attr;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_pe_count'} = $pv_pe_count;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_pe_alloc_count'} = $pv_pe_alloc_count;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_tags'} = $pv_tags;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_mda_count'} = $pv_mda_count;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_uuid'} = $pv_uuid;
+    $lvm->{$vg_name}->{$pv_name}->{'dev_size'} = $dev_size;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_mda_free'} = $pv_mda_free;
+    $lvm->{$vg_name}->{$pv_name}->{'pv_mda_size'} = $pv_mda_size;
+}
+close(LVM);
+
+# Analyze the existing volume groups
+#open(LVM,$lvmcmd."vgdisplay -c |") || mr_exit(-1,"Unable to execute ".$lvmcmd."vgdisplay -c");
+open(LVM,$lvmcmd."vgs --noheadings --nosuffix --units m --separator : | -o vg_all") || mr_exit(-1,"Unable to execute ".$lvmcmd."vgs");
+while (<LVM>) {
+
+=pod
+
+All the VG fields from the vgs command are gathered under the VG name
+The following names are used:
+
+From vgs -o help
+vg_fmt               - Type of metadata.                                              
+vg_uuid              - Unique identifier.                                             
+vg_attr              - Various attributes - see man page.                             
+vg_size              - Total size of VG in current units.                             
+vg_free              - Total amount of free space in current units.                   
+vg_sysid             - System ID indicating when and where it was created.            
+vg_extent_size       - Size of Physical Extents in current units.                     
+vg_extent_count      - Total number of Physical Extents.                              
+vg_free_count        - Total number of unallocated Physical Extents.                  
+max_lv               - Maximum number of LVs allowed in VG or 0 if unlimited.         
+max_pv               - Maximum number of PVs allowed in VG or 0 if unlimited.         
+pv_count             - Number of PVs.                                                 
+lv_count             - Number of LVs.                                                 
+snap_count           - Number of snapshots.                                           
+vg_seqno             - Revision number of internal metadata.  Incremented whenever it changes.
+vg_tags              - Tags, if any.                                                          
+vg_mda_count         - Number of metadata areas in use by this VG.                            
+vg_mda_free          - Free metadata area space for this VG in current units.                 
+vg_mda_size          - Size of smallest metadata area for this VG in current units.
+
+=cut
+    s/^[\s]*//;
+    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(/:/);
+    $lvm->{$vg_name}->{'vg_fmt'} = $vg_fmt;
+    $lvm->{$vg_name}->{'vg_uuid'} = $vg_uuid;
+    $lvm->{$vg_name}->{'vg_attr'} = $vg_attr;
+    $lvm->{$vg_name}->{'vg_size'} = $vg_size;
+    $lvm->{$vg_name}->{'vg_free'} = $vg_free;
+    $lvm->{$vg_name}->{'vg_sysid'} = $vg_sysid;
+    $lvm->{$vg_name}->{'vg_extend_size'} = $vg_extend_size;
+    $lvm->{$vg_name}->{'vg_extend_count'} = $vg_extend_count;
+    $lvm->{$vg_name}->{'vg_free_count'} = $vg_free_count;
+    $lvm->{$vg_name}->{'max_lv'} = $max_lv;
+    $lvm->{$vg_name}->{'max_pv'} = $max_pv;
+    $lvm->{$vg_name}->{'pv_count'} = $pv_count;
+    $lvm->{$vg_name}->{'lv_count'} = $lv_count;
+    $lvm->{$vg_name}->{'snap_count'} = $snap_count;
+    $lvm->{$vg_name}->{'vg_seqno'} = $vg_seqno;
+    $lvm->{$vg_name}->{'vg_tags'} = $vg_tags;
+    $lvm->{$vg_name}->{'vg_mda_count'} = $vg_mda_count;
+    $lvm->{$vg_name}->{'vg_mda_free'} = $vg_mda_free;
+    $lvm->{$vg_name}->{'vg_mda_size'} = $vg_mda_size;
+}
+close(LVM);
+
+# Analyze the existing logical volumes
+#open(LVM,$lvmcmd."lvdisplay -c |") || mr_exit(-1,"Unable to execute ".$lvmcmd."lvdisplay -c");
+open(LVM,$lvmcmd."lvs --noheadings --nosuffix --units m --separator : -o vg_name,lv_all|") || mr_exit(-1,"Unable to execute ".$lvmcmd."lvs");
+while (<LVM>) {
+    s/^[\s]*//;
+
+=pod
+
+The 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
+pv_name              - Name of the physical volume PV
+
+=cut
+
+    # Array of PVs for that VG
+    $lvm->{$vg_name}->{'pvs'}->[$lvm->{$vg_name}->{'pvnum'}] = $pv_name;
+
+=pod
+
+All the PV fields from the pvs command are gathered under their PV name (substructure)
+The following names are used:
+
+
+    # From lvs -o help
+
+    #vg_name              - Name of the related volume group
+    #lv_uuid              - Unique identifier.                           
+    #lv_name              - Name.  LVs created for internal use are enclosed in brackets.
+    #lv_attr              - Various attributes - see man page.                           
+    #lv_major             - Persistent major number or -1 if not persistent.             
+    #lv_minor             - Persistent minor number or -1 if not persistent.             
+    #lv_read_ahead        - Read ahead setting in current units.                         
+    #lv_kernel_major      - Currently assigned major number or -1 if LV is not active.   
+    #lv_kernel_minor      - Currently assigned minor number or -1 if LV is not active.   
+    #lv_kernel_read_ahead - Currently-in-use read ahead setting in current units.        
+    #lv_size              - Size of LV in current units.                                 
+    #seg_count            - Number of segments in LV.                                    
+    #origin               - For snapshots, the origin device of this LV.                 
+    #origin_size          - For snapshots, the size of the origin device of this LV.     
+    #snap_percent         - For snapshots, the percentage full if LV is active.          
+    #copy_percent         - For mirrors and pvmove, current percentage in-sync.          
+    #move_pv              - For pvmove, Source PV of temporary LV created by pvmove.     
+    #convert_lv           - For lvconvert, Name of temporary LV created by lvconvert.    
+    #lv_tags              - Tags, if any.                                                
+    #mirror_log           - For mirrors, the LV holding the synchronisation log.         
+    #modules              - Kernel device-mapper modules required for this LV.
+
+=cut
+
+    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(/:/);
+    # The LVM hash is indexed by VGs
+    $lvm->{$vg_name}->{'lvnum'}++;
+    # That array will start at 1 then
+    # Array of LVs for that VG
+    $lvm->{$vg_name}->{'lvs'}->[$lvm->{$vg_name}->{'lvnum'}] = $lv_name;
+    # All LV fields gathered under the LV name
+    $lvm->{$vg_name}->{$lv_name}->{'lv_uuid'} = $lv_uuid;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_attr'} = $lv_attr;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_major'} = $lv_major;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_minor'} = $lv_minor;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_read_ahead'} = $lv_read_ahead;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_kernel_major'} = $lv_kernel_major;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_kernel_minor'} = $lv_kernel_minor;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_kernel_read_ahead'} = $lv_kernel_read_ahead;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_size'} = $lv_size;
+    $lvm->{$vg_name}->{$lv_name}->{'origin'} = $origin;
+    $lvm->{$vg_name}->{$lv_name}->{'origin_size'} = $origin_size;
+    $lvm->{$vg_name}->{$lv_name}->{'snap_percent'} = $snap_percent;
+    $lvm->{$vg_name}->{$lv_name}->{'copy_percent'} = $copy_percent;
+    $lvm->{$vg_name}->{$lv_name}->{'move_pv'} = $move_pv;
+    $lvm->{$vg_name}->{$lv_name}->{'convert_lv'} = $convert_lv;
+    $lvm->{$vg_name}->{$lv_name}->{'lv_tags'} = $lv_tags;
+    $lvm->{$vg_name}->{$lv_name}->{'mirror_log'} = $mirror_log;
+    $lvm->{$vg_name}->{$lv_name}->{'modules'} = $modules;
+}
+close(LVM);
+return($lvm);
+}
+
-=item B<mr_lvm_analyze>
-
@@ -137 +359 @@
-
-my $OUTPUT = shift;
-my $lvm;
-
-my ($lvmver,$lvmcmd) = mr_lvm_check();
-
+
+
-
-print $OUTPUT "LVM:$lvmver\n";
@@ -150 +372 @@
-        s/^[\s]*//;
-        my ($pv,$vg,$foo,$foo2,$size,$foo3) = split(/:/);
-        $lvm->{$vg}->{'pv'}[$lvm->{$vg}->{'pvnum'}] = $pv;
-        $lvm->{$vg}->{'pvnum'}++;
+        # that array will start at 1 then
+        $lvm->{$vg}->{'pv'}->[$lvm->{$vg}->{'pvnum'}] = $pv;
-        $lvm->{$vg}->{$pv}->{'size'} = $size;
-        print $OUTPUT "PV:$_";
@@ -192 +415 @@
-my $OUTPUT = shift;
-my $mrmult = shift;
-
-($lvmver,$lvmcmd) = mr_lvm_check()
+
+$lvmver
-
-# Generate the startup scrit needed to restore LVM conf
@@ -199 +422 @@
-# Multiply by the multiplier given in input or 1 of none
-
-print $OUTPUT "# Desactivate Volume Groups\n";
-print $OUTPUT $lvmcmd."vgchange -an\n";
-print $OUTPUT "\n";
-
-my $firsttime = 0;
-while (<$INPUT>) {
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        print $OUTPUT "# Creating Physical Volumes $pvname\n";
-
+
+
+
-        print $OUTPUT "\n";
-    } elsif (/^VG:/) {
-
+
+
+
-        if ($lvmver < 2) {
-            print $OUTPUT "# Removing device first as LVM v1 doesn't do it\n";
-            print $OUTPUT "rm -Rf /dev/$vgname\n";
-        }
-$lvmaxnum = 255 if ($lvmaxnum > 256
-$pvmaxnum = 255 if ($pvmaxnum > 256
+#$lvmaxnum = 255 if (($lvmaxnum > 256) or (not defined $lvmaxnum)
+#$pvmaxnum = 255 if (($pvmaxnum > 256) or (not defined $pvmaxnum)
-        print $OUTPUT "# Create Volume Group $vgname\n";
-        # Pb sur pesize unite ?
-
+
+
+
-        print $OUTPUT "\n";
+
-    } elsif (/^LV:/) {
-        if ($firsttime == 0) {
@@ -232 +470 @@
-        my ($tag,$lvname,$vgname,$lvaccess,$lvstat,$lvnum,$oclv,$lvsize,$leinlv,$lealloc,$allocpol,$readahead,$major,$minor) = split(/:/);
-        print $OUTPUT "# Create Logical Volume $lvname\n";
-
+
+
+
-        #[ "$stripes" ]    && output="$output -i $stripes"
-        #[ "$stripesize" ] && output="$output -I $stripesize"
-    }
-}
+
-print $OUTPUT "\n";
-print $OUTPUT "# Scanning again Volume Groups\n";

devel/mr/sbin/mranalyze-lvm

@@ -140 +140 @@
-}
-
-ver
+
-
-$lvmver == 0
-") 
+not defined $lvm
+\n") ;
-} else {
-v$lvmver Structure Analyzed") 
+Structure :".Dumper($lvm)."\n");
-}
+
+open(LVM, "> /tmp/lvm.out") || mr_exit(-1, "Unable to write to /tmp/lvm.out");
+$lvm = mr_lvm_analyze(\*LVM);
+close(LVM);
+open(LVM, "/tmp/lvm.out") || mr_exit(-1, "Unable to read to /tmp/lvm.out");
+$lvm = mr_lvm_prepare(\*LVM,$OUTPUT,1);
+close(LVM);
+
-if (defined $opts{'o'}) {
-    close($OUTPUT);