File Coverage

blib/lib/Linux/LVM.pm

Criterion	Covered	Total	%
statement	12	266	4.5
branch	0	162	0.0
condition			n/a
subroutine	4	12	33.3
pod	0	8	0.0
total	16	448	3.5

package Linux::LVM;

use 5.006;
use strict;
use warnings;

require Exporter;
use AutoLoader qw(AUTOLOAD);

our @ISA = qw(Exporter);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

# This allows declaration	use Linux::LVM ':all';
# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
# will save memory.
our %EXPORT_TAGS = ( 'all' => [ qw( get_volume_group_list
                                    get_volume_group_information
                                    get_logical_volume_information
                                    get_physical_volume_information
                                    get_vg_information
                                    get_pv_info
                                    get_lv_info
) ] );

our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );

our @EXPORT = qw( get_volume_group_list
                  get_volume_group_information
                  get_logical_volume_information
                  get_physical_volume_information
                  get_vg_information
                  get_pv_info
                  get_lv_info
);

our $VERSION = '0.17';
our $units;

# Preloaded methods go here.

# Autoload methods go after =cut, and are processed by the autosplit program.

#-----------------------------------------------------------------------#
# Subroutine: units                                                     #
#-----------------------------------------------------------------------#
# Description: Set units to be used for pe_size, lv_size, etc.          #
#              legal values are same as lvm --units:                    #
#              hbskmgtpeHBSKMGTPE                                       #
#              (h)uman-readable, (b)ytes, (s)ectors, (k)ilobytes,       #
#              (m)egabytes, (g)igabytes, (t)erabytes, (p)etabytes,      #
#              (e)xabytes.  Capitalise to use multiples of 1000 (S.I.)  #
#              instead of 1024.                                         #
#              Can also specify custom units e.g. --units 3M            #
#-----------------------------------------------------------------------#
# Parameters: None                                                      #
#-----------------------------------------------------------------------#
# Return Values: On success, a array with the volume group names.       #
#-----------------------------------------------------------------------#
sub units {
    shift;
    $units     = shift() if @_;
    return $units;
}

#-----------------------------------------------------------------------#
# Subroutine: get_volume_group_list                                     #
#-----------------------------------------------------------------------#
# Description: This function will return a sorted list of all of the    #
#              active volume groups on the system.                      #
#-----------------------------------------------------------------------#
# Parameters: None                                                      #
#-----------------------------------------------------------------------#
# Return Values: On success, a array with the volume group names.       #
#-----------------------------------------------------------------------#
sub get_volume_group_list() {
    my %vg = get_vg_information();
    return (sort keys(%vg));
} # End of the get_volume_group_list routine.


#-----------------------------------------------------------------------#
# Subroutine: get_volume_group_information                              #
#-----------------------------------------------------------------------#
# Description: This function will return a hash containing all of the   #
#              data about the specified volume group.                   #
#-----------------------------------------------------------------------#
# Parameters: A string containing a volume group name.                  #
#-----------------------------------------------------------------------#
# Return Values: On success, a hash with the volume group data.         #
#-----------------------------------------------------------------------#
sub get_volume_group_information($) {
    my $volume_group = $_[0];
    my %vg_info;
    my %vg = get_vg_information();

    foreach(sort keys %{$vg{$volume_group}}) {
        if   ( $_ eq "pvols" ) { next; }
        elsif( $_ eq "lvols" ) { next; }
        else                   {
            $vg_info{$_} = $vg{$volume_group}->{$_};
        }
    }
    return %vg_info;
} # End of the get_volume_group_information routine.


#-----------------------------------------------------------------------#
# Subroutine: get_volume_group_information                              #
#-----------------------------------------------------------------------#
# Description: This function will return a hash containing all of the   #
#              data about the specified volume group.                   #
#-----------------------------------------------------------------------#
# Parameters: A string containing a volume group name.                  #
#-----------------------------------------------------------------------#
# Return Values: On success, a hash with the volume group data.         #
#-----------------------------------------------------------------------#
sub get_logical_volume_information($) {
    my $volume_group = $_[0];
    my %lv_info;
    my $lvname;
    my %vg = get_vg_information();

    foreach $lvname (sort keys %{$vg{$volume_group}->{lvols}}) {
        foreach(sort keys %{$vg{$volume_group}->{lvols}->{$lvname}}) {
            $lv_info{$lvname}->{$_} = $vg{$volume_group}->{lvols}->{$lvname}->{$_};
        }
    }
    return %lv_info;
} # End of the get_logical_volume_information routine.


#-----------------------------------------------------------------------#
# Subroutine: get_volume_group_information                              #
#-----------------------------------------------------------------------#
# Description: This function will return a hash containing all of the   #
#              data about the specified volume group.                   #
#-----------------------------------------------------------------------#
# Parameters: A string containing a volume group name.                  #
#-----------------------------------------------------------------------#
# Return Values: On success, a hash with the volume group data.         #
#-----------------------------------------------------------------------#
sub get_physical_volume_information($) {
    my $volume_group = $_[0];
    my %pv_info;
    my $pvname;
    my %vg = get_vg_information();

    foreach $pvname (sort keys %{$vg{$volume_group}->{pvols}}) {
        foreach(sort keys %{$vg{$volume_group}->{pvols}->{$pvname}}) {
            $pv_info{$pvname}->{$_} = $vg{$volume_group}->{pvols}->{$pvname}->{$_};
        }
    }
    return %pv_info;
} # End of the get_physical_volume_information routine.


#-----------------------------------------------------------------------#
# Subroutine: get_vg_information                                        #
#-----------------------------------------------------------------------#
# Description: This function will return a hash containing all of the   #
#              volume group information for the system.                 #
#-----------------------------------------------------------------------#
# Parameters: None                                                      #
#-----------------------------------------------------------------------#
# Return Values: On success, a hash with all of the vg information.     #
#-----------------------------------------------------------------------#
sub get_vg_information() {
    my %vghash;
    my $vgn;
    my $lvn;
    my $pvn;

    my @vginfo;

    my $units_arg = '';
    $units_arg = " --units $units " if ($units);
    if ( -e "/usr/sbin/vgdisplay" ) {
        @vginfo = `/usr/sbin/vgdisplay -v $units_arg`;
    } else {
        if( ! -e "/sbin/vgdisplay" ) { die("LVM utilities not installed in /sbin or /usr/sbin"); }
        @vginfo = `/sbin/vgdisplay -v $units_arg`;
    }

    VGINF: foreach(@vginfo) {
        chomp;
        s/^\s+//g;
        s/\s+$//g;
        next VGINF if m/^$/;

        # Parse the volume group name.
        if( m/VG Name\s+(\S+)/ ) {
            $vgn = $1; $vghash{$vgn}->{vgname} = $1;
            next VGINF; }

        # Parse the volume group access.
        elsif( m/VG Access\s+(\S+)/ ) {
            $vghash{$vgn}->{access} = $1;
            next VGINF; }

        # Parse the volume group status.
        elsif( m/VG Status\s+(.+)/ ) {
            $vghash{$vgn}->{status} = $1;
            next VGINF; }

        # Parse the volume group number.
        elsif( m/VG #\s+(\S+)/ ) {
            $vghash{$vgn}->{vg_number} = $1;
            next VGINF; }

        # Parse the maximum logical volume size and size unit for the volume group.
        elsif( m/MAX LV Size\s+(\S+) (\S+)/ ) {
            $vghash{$vgn}->{max_lv_size} = $1;
            $vghash{$vgn}->{max_lv_size_unit} = $2;
            next VGINF; }

        # Parse the maximum number of logical volumes for the volume group.
        elsif( m/MAX LV\s+(\S+)/ ) {
            $vghash{$vgn}->{max_lv} = $1;
            next VGINF; }

        # Parse the current number of logical volumes for the volume group.
        elsif( m/Cur LV\s+(\S+)/ ) {
            $vghash{$vgn}->{cur_lv} = $1;
            next VGINF; }

        # Parse the number of open logical volumes for the volume group.
        elsif( m/Open LV\s+(\S+)/ )   {
            $vghash{$vgn}->{open_lv} = $1;
            next VGINF; }

        # Parse the number of physical volumes accessible to the volume group.
        elsif( m/Max PV\s+(\S+)/ ) {
            $vghash{$vgn}->{max_pv} = $1;
            next VGINF; }

        # Parse the current number of physical volumes in the volume group.
        elsif( m/Cur PV\s+(\S+)/ ) {
            $vghash{$vgn}->{cur_pv} = $1;
            next VGINF; }

        # Parse the number of active physical volumes in the volume group.
        elsif( m/Act PV\s+(\S+)/ ) {
            $vghash{$vgn}->{act_pv} = $1;
            next VGINF; }

        # Parse the size of the volume group.
        elsif( m/VG Size\s+(\S+) (\S+)/ ) {
            $vghash{$vgn}->{vg_size} = $1;
            $vghash{$vgn}->{vg_size_unit} = $2;
            next VGINF; }

        # Parse the physical extent size and unit for one extent of volume group.
        elsif( m/PE Size\s+(\S+) (\S+)/ ) {
            $vghash{$vgn}->{pe_size} = $1;
            $vghash{$vgn}->{pe_size_unit} = $2;
            next VGINF; }

        # Parse the total number and number of free physical extents from the physical disk.
        elsif( m/Total PE \/ Free PE\s+(\S+) \/ (\S+)/m ) {
            $vghash{$vgn}->{pvols}->{$pvn}->{total_pe} = $1;
            $vghash{$vgn}->{pvols}->{$pvn}->{free_pe} = $2;
            next VGINF; }

        # Parse the total number of physical extents from the volume group.
        elsif( m/Total PE\s+(\S+)/ ) {
            $vghash{$vgn}->{total_pe} = $1;
            next VGINF; }

        # Parse the number of allocated physical extents from the volume group.
        elsif( m/Alloc PE \/ Size\s+(\S+) \/ (\S+) (\S+)/ ) {
            $vghash{$vgn}->{alloc_pe} = $1;
            $vghash{$vgn}->{alloc_pe_size} = $2;
            $vghash{$vgn}->{alloc_pe_size_unit} = $3;
            next VGINF; }

        # Parse the volume group name.
        elsif( m/Free  PE \/ Size\s+(\S+) \/ (\S+) (\S+)/ ) {
            $vghash{$vgn}->{free_pe} = $1;
            $vghash{$vgn}->{free_pe_size} = $2;
            $vghash{$vgn}->{free_pe_size_unit} = $3;
            next VGINF; }

        # Parse the volume group uuid.
        elsif( m/VG UUID\s+(\S+)/ ) {
            $vghash{$vgn}->{uuid} = $1;
            next VGINF; }

        # Parse the logical volume name.
        elsif( m/LV Name\s+(\S+)/ ) {
            $lvn = $1;
            $vghash{$vgn}->{lvols}->{$lvn}->{name} = $1;
            next VGINF; }

        # since version 2.02.89 'LV Name' is no longer the full path, 'LV Path' is.
        # LV Path may be bogus or missing in some cases, such as thin pools.
        if( m/LV Path\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{name} = $1;
            next LVINF; }

        # Parse the logical volume UUID.
        elsif( m/LV UUID\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{uuid} = $1;
            next VGINF; }

        # Parse the logical volume UUID.
        elsif( m/Segments\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{segments} = $1;
            next VGINF; }

        # Parse the logical volume size and unit.
        elsif( m/LV Size\s+(\S+) (\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{lv_size} = $1;
            $vghash{$vgn}->{lvols}->{$lvn}->{lv_size_unit} = $2;
            next VGINF; }

        # Parse the logical volume write access.
        elsif( m/LV Write Access\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{write_access} = $1;
            next VGINF; }

        # Parse the logical volume status.
        elsif( m/LV Status\s+(.+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{status} = $1;
            next VGINF; }

        # Parse the number of logical extents in the logical volume.
        elsif( m/Current LE\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{cur_le} = $1;
            next VGINF; }

        # Parse the number of allocated logical extents in the logical volume.
        elsif( m/Allocated LE\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{alloc_le} = $1;
            next VGINF; }

        # Parse the allocation type for the logical volume.
        elsif( m/Allocation\s+(.+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{allocation} = $1;
            next VGINF; }

        # Parse the volume number.
        elsif( m/LV #\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{lv_number} = $1;
            next VGINF; }

        # Parse the number of times the logical volume is open.
        elsif( m/# open\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{open_lv} = $1;
            next VGINF; }

        # Parse the block device of the logical volume.
        elsif( m/Block device\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{device} = $1;
            next VGINF; }

        # Parse the value for the read ahead sectors of the logical volume.
        elsif( m/Read ahead sectors\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{read_ahead} = $1;
            next VGINF; }


        elsif( m/Allocated to snapshot\s+(\S+)%/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{'allocated_to_snapshot'} = $1;
            next VGINF; }

        elsif( m/COW-table size\s+([0-9\.]+)\s+(\S+)/ ) {
            $vghash{$vgn}->{lvols}->{$lvn}->{'cow_table_size'} = $1;
            $vghash{$vgn}->{lvols}->{$lvn}->{'cow_table_unit'} = $2;
            next VGINF; }

        elsif( m/Mirrored volumes\s+(.+)/ ) {
                $vghash{$vgn}->{lvols}->{$lvn}->{'mirrored_volumes'} = $1;
                next VGINF; }

        # Parse the physical disk name.
        elsif( m/PV Name\s+(\S+)/ ) {
            $pvn = $1;
            $vghash{$vgn}->{pvols}->{$pvn}->{device} = $1;
            next VGINF; }

        # Parse the status of the physical disk.
        elsif( m/PV Status\s+(.+)/ ) {
            $vghash{$vgn}->{pvols}->{$pvn}->{status} = $1;
            next VGINF; }

        # Parse the status of the physical disk.
        elsif( m/PV UUID\s+(.+)/ ) {
            $vghash{$vgn}->{pvols}->{$pvn}->{uuid} = $1;
            next VGINF; }

    }
    return %vghash;
} # End of the get_vg_information routine.


#-----------------------------------------------------------------------#
# Subroutine: get_pv_info                                               #
#-----------------------------------------------------------------------#
# Description: This function will return a hash containing all of the   #
#              information about the specified physical volume.         #
#-----------------------------------------------------------------------#
# Parameters: None                                                      #
#-----------------------------------------------------------------------#
# Return Values: On success, a hash with all of the pv information.     #
#-----------------------------------------------------------------------#
sub get_pv_info($) {
    my $pvname = $_[0];
    my %pvhash;
    my @pvinfo;

    if( ! -e "$pvname" ) { die("Physical Disk: $pvname does not exist."); }

    my $units_arg = '';
    $units_arg = " --units $units " if ($units);

    if ( -e "/usr/sbin/pvdisplay" ) {
        @pvinfo = `/usr/sbin/pvdisplay $units_arg $pvname`;
    } else {
        if( ! -e "/sbin/pvdisplay" ) { die("LVM utilities not installed in /sbin or /usr/sbin"); }
        @pvinfo = `/sbin/pvdisplay $units_arg $pvname`;
    }


    PVINF: foreach(@pvinfo) {
        # Get the name of the physical volume.
        if( m/PV Name\s+(\S+)/ ) {
            $pvhash{pv_name} = $1;
            next PVINF; }

        # Get the name of the volume group the physical volume belongs to.
        if( m/VG Name\s+(\S+)/ ) {
            $pvhash{vg_name} = $1;
            next PVINF; }

        # Get the size information of the physical volume.
        if( m/PV Size\s+(\S+) (\S+)/ ) {
            $pvhash{size} = $1;
            $pvhash{size_unit} = $2;
            next PVINF; }

        # Get the physical volume number.
        if( m/PV\#\s+(\S+)/ ) {
            $pvhash{pv_number} = $1;
            next PVINF; }

        # Get the status of the physical volume.
        if( m/PV Status\s+(.+)/ ) {
            $pvhash{status} = $1;
            next PVINF; }

        # Get the allocation status of the physical volume.
        if( m/Allocatable\s+(.+)/ ) {
            $pvhash{allocatable} = $1;
            next PVINF; }

        # Get the number of logical volumes on the physical volume.
        if( m/Cur LV\s+(\S+)/ ) {
            $pvhash{num_lvols} = $1;
            next PVINF; }

        # Get the physical extent size and unit of the physical volume.
        if( m/PE Size \((\S+)\)\s+(\S+)/ ) {
            $pvhash{pe_size} = $2;
            $pvhash{pe_size_unit} = $1;
            next PVINF; }

        # Get the total numver of physical extents on the physical volume.
        if( m/Total PE\s+(\S+)/ ) {
            $pvhash{total_pe} = $1;
            next PVINF; }

        # Get the number of free extents on the physical volume.
        if( m/Free PE\s+(\S+)/ ) {
            $pvhash{free_pe} = $1;
            next PVINF; }

        # Get the number of allocated physical extents on the physical volume.
        if( m/Allocated PE\s+(\S+)/ ) {
            $pvhash{alloc_pe} = $1;
            next PVINF; }

        # Get the UUID of the physical volume.
        if( m/PV UUID\s+(\S+)/ ) {
            $pvhash{uuid} = $1;
            next PVINF; }
    }
    return %pvhash;
} # End of the get_pv_info routine.


#-----------------------------------------------------------------------#
# Subroutine: get_lv_info                                               #
#-----------------------------------------------------------------------#
# Description: This function will return a hash containing all of the   #
#              information about the specified logical volume.          #
#-----------------------------------------------------------------------#
# Parameters: None                                                      #
#-----------------------------------------------------------------------#
# Return Values: On success, a hash with all of the lv information.     #
#-----------------------------------------------------------------------#
sub get_lv_info($) {
    my $lvname = $_[0];
    my %lvhash;
    my @lvinfo;

    if( ! -e "$lvname" ) { die("Logical Disk: $lvname does not exist."); }

    my $units_arg = '';
    $units_arg = " --units $units " if ($units);
    if ( -e "/usr/sbin/vgdisplay" ) {
        @lvinfo = `/usr/sbin/lvdisplay $units_arg $lvname`;
    } else {
        if( ! -e "/sbin/vgdisplay" ) { die("LVM utilities not installed in /sbin or /usr/sbin"); }
        @lvinfo = `/sbin/lvdisplay $units_arg $lvname`;
    }

    LVINF: foreach(@lvinfo) {

        # Get the logical volume name.
        if( m/LV Name\s+(\S+)/ ) {
            $lvhash{lv_name} = $1;
            next LVINF; }


        # since version 2.02.89 'LV Name' is no longer the full path, 'LV Path' is.
        # LV Path may be bogus or missing in some cases, such as thin pools.
        if( m/LV Path\s+(\S+)/ ) {
            $lvhash{lv_name} = $1;
            next LVINF; }

        # Get the volume group name.
        if( m/VG Name\s+(\S+)/ ) {
            $lvhash{vg_name} = $1;
            next LVINF; }

        # Get the volume group name.
        if( m/LV UUID\s+(\S+)/ ) {
            $lvhash{uuid} = $1;
            next LVINF; }

        # Get the logical volume write status.
        if( m/LV Write Access\s+(.+)/ ) {
            $lvhash{access} = $1;
            next LVINF; }

        # Get the logical volume status.
        if( m/LV Status\s+(.+)/ ) {
            $lvhash{status} = $1;
            next LVINF; }

        # Get the logical volume number.
        if( m/LV \#\s+(\S+)/ ) {
            $lvhash{lv_number} = $1;
            next LVINF; }

        # Get the number of opens for the logical volume.
        if( m/\# open\s+(\S+)/ ) {
            $lvhash{lv_open} = $1;
            next LVINF; }

        # Get the logical volume size and size unit.
        if( m/LV Size\s+(\S+) (\S+)/ )  {
            $lvhash{size} = $1;
            $lvhash{size_unit} = $2;
            next LVINF; }

        # Get the number of extents assigned to the logical volume.
        if( m/Current LE\s+(\S+)/ ) {
            $lvhash{current_le} = $1;
            next LVINF; }

        # Get the number of extents allocated to the logical volume.
        if( m/Allocated LE\s+(\S+)/ )  {
            $lvhash{alloc_le} = $1;
            next LVINF; }

        # Get the extent allocation type of the logical volume.
        if( m/Allocation\s+(.+)/ ) {
            $lvhash{allocation} = $1;
            next LVINF; }

        # Get the number of read ahead sectors for the logical volume.
        if( m/Read ahead sectors\s+(\S+)/ ) {
            $lvhash{read_ahead} = $1;
            next LVINF; }

        # Get the block device of the logical volume.
        if( m/Block device\s+(\S+)/ ) {
            $lvhash{block_device} = $1;
            next LVINF; }

        if( m/Allocated to snapshot\s+(\S+)%/ ) {
            $lvhash{allocated_to_snapshot} = $1;
            next LVINF; }

        elsif( m/COW-table size\s+([0-9\.]+)\s+(\S+)/ ) {
            $lvhash{'cow_table_size'} = $1;
            $lvhash{'cow_table_unit'} = $2;
            next LVINF; }
    }
    return %lvhash;
} # End of the get_lv_info routine.


1;
__END__