diff --git a/lib/Zabbix/Agent/Addons/LVM.pm b/lib/Zabbix/Agent/Addons/LVM.pm
new file mode 100644
index 0000000..d23fbe3
--- /dev/null
+++ b/lib/Zabbix/Agent/Addons/LVM.pm
@@ -0,0 +1,918 @@
+package Zabbix::Agent::Addons::LVM;
+
+# Forked from Linux::LVM
+# with support for thin pools
+
+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.18';
+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+(\S+))?/ ) {
+            $vghash{$vgn}->{alloc_pe} = $1;
+            $vghash{$vgn}->{alloc_pe_size} = $2;
+            $vghash{$vgn}->{alloc_pe_size_unit} = $3 || "B";
+            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+)/ ) {
+            $lvn = $1 unless $lvn;
+            $vghash{$vgn}->{lvols}->{$lvn}->{name} = $1;
+            next VGINF; }
+
+        # 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; }
+
+        # Thin pools have data and metadata allocations
+        elsif( m/Allocated pool data\s+(\S+)%/ ) {
+            $vghash{$vgn}->{lvols}->{$lvn}->{'allocated_pool_data'} = $1;
+            next VGINF; }
+
+        elsif( m/Allocated metadata\s+(\S+)%/ ) {
+            $vghash{$vgn}->{lvols}->{$lvn}->{'allocated_meta_data'} = $1;
+            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;
+
+    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; }
+
+        # Thin pools have data and metadata allocation
+        if( m/Allocated pool data\s+(\S+)%/ ) {
+            $lvhash{allocated_pool_data} = $1;
+            next LVINF; }
+
+        if( m/Allocated metadata\s+(\S+)%/ ) {
+            $lvhash{allocated_meta_data} = $1;
+            next LVINF; }
+    }
+    return %lvhash;
+} # End of the get_lv_info routine.
+
+
+1;
+__END__
+# Below is stub documentation for your module. You'd better edit it!
+
+=head1 NAME
+
+Linux::LVM - Perl extension for accessing Logical Volume Manager(LVM)
+             data structures on Linux.
+
+=head1 SYNOPSIS
+
+  use Linux::LVM;
+  Linux::LVM->units('G'); 
+
+=head1 ABSTRACT
+
+  The live data used in the examples is included in the DESCRIPTION area
+  for your convenience and reference.
+  
+=head1 DESCRIPTION
+ 
+  units()  Get or set the units used to report sizes of LVs, PVs, etc.
+           legal values: hbskmgtpeHBSKMGTPE
+           see man lvm documentation of --units
+ 
+  get_volume_group_list()	This routine will return an array that
+				contains the names of the volume groups.
+
+  @vgs = get_volume_group_list(); print "@vgs \n"; 
+  Would yield the following: vg00
+   
+    
+  get_volume_group_information($)	This routine will return all of
+					the volume group information about
+					the specified volume group.
+
+  %vg = get_volume_group_information("vg00");
+  foreach(sort keys %vg) {
+     print "$_ = $vg{$_}\n";
+  }
+  Would yield the following:
+     access = read/write
+     act_pv = 2
+     alloc_pe = 3840
+     alloc_pe_size = 15
+     alloc_pe_size_unit = GB
+     cur_lv = 3
+     cur_pv = 2
+     free_pe = 864
+     free_pe_size = 3.38
+     free_pe_size_unit = GB
+     max_lv = 256
+     max_lv_size = 255.99
+     max_lv_size_unit = GB
+     max_pv = 256
+     open_lv = 0
+     pe_size = 4
+     pe_size_unit = MB
+     status = available/resizable
+     total_pe = 4704
+     uuid = BBq8si-NyRR-9ZNW-3J5e-DoRO-RBHK-ckrszi
+     vg_number = 0
+     vg_size = 18.38
+     vg_size_unit = GB
+     vgname = vg00
+   
+  
+  get_logical_volume_information($)	This routine will return all of the
+					logical volume information associated
+					with the specified volume group.
+ 
+  %lv = get_logical_volume_information("vg00");
+  foreach $lvname (sort keys %lv) {
+      foreach(sort keys %{$lv{$lvname}}) {
+          print "$_ = $lv{$lvname}->{$_}\n"; 
+      }
+      print "\n"; 
+  }
+  Would yield the following results:
+  alloc_le = 1024
+  allocation = next free
+  cur_le = 1024
+  device = 58:0
+  lv_number = 1
+  lv_size = 4
+  lv_size_unit = GB
+  name = /dev/vg00/lvol1
+  open_lv = 0
+  read_ahead = 1024
+  status = available
+  write_access = read/write
+  
+  alloc_le = 1280
+  allocation = next free
+  cur_le = 1280
+  device = 58:1
+  lv_number = 2
+  lv_size = 5
+  lv_size_unit = GB
+  name = /dev/vg00/lvol2
+  open_lv = 0
+  read_ahead = 1024
+  status = available
+  write_access = read/write
+  
+  alloc_le = 1536
+  allocation = next free
+  cur_le = 1536
+  device = 58:2
+  lv_number = 3
+  lv_size = 6
+  lv_size_unit = GB
+  name = /dev/vg00/lvol3
+  open_lv = 0
+  read_ahead = 1024
+  status = available
+  write_access = read/write
+   
+   
+  get_physical_volume_information($)	This routine will return all of the information
+					information about the physical volumes assigned 
+					to the specified volume group.
+   
+  %pv = get_physical_volume_information("vg00");
+  foreach $pvname (sort keys %pv) {
+      foreach(sort keys %{$pv{$pvname}}) {
+          print "$_ = $pv{$pvname}->{$_}\n";
+      }
+      print "\n";
+  }
+  Would yield the following results:
+  device = /dev/hda3
+  free_pe = 0
+  pv_number = 1
+  status = available / allocatable
+  total_pe = 2160
+  
+  device = /dev/hda4
+  free_pe = 864
+  pv_number = 2
+  status = available / allocatable
+  total_pe = 2544
+              
+              
+  get_lv_info($)	This routine will return all of the information about the
+			specified logical volume.  The information will be returned
+			in a hash.
+              
+  get_lv_info
+  %lv = get_lv_info("/dev/vg00/lvol1");
+  foreach (sort keys %lv) {
+      print "$_ = $lv{$_} \n";
+  }
+  Would yield the following results:
+  access = read/write 
+  alloc_le = 1024 
+  allocation = next free 
+  block_device = 58:0 
+  current_le = 1024 
+  lv_name = /dev/vg00/lvol1 
+  lv_number = 1 
+  lv_open = 0 
+  read_ahead = 1024 
+  size = 4 
+  size_unit = GB 
+  status = available 
+  vg_name = vg00 
+              
+              
+              
+  get_pv_info($)	This routine will return all of the information about the
+			specified physical volume.  The information will be returned
+			in a hash.
+              
+  %pv = get_pv_info("/dev/hda3");
+  foreach (sort keys %pv) {
+      print "$_ = $pv{$_} \n";
+  }
+  Would yield the following results:
+  alloc_pe = 2160 
+  allocatable = yes (but full) 
+  free_pe = 0 
+  num_lvols = 2 
+  pe_size = 4096 
+  pe_size_unit = KByte 
+  pv_name = /dev/hda3 
+  pv_number = 1 
+  sectors = 17703630 
+  size = 8.44 
+  size_info = NOT usable 4.19 MB [LVM: 136 KB] 
+  size_unit = GB 
+  status = available 
+  total_pe = 2160 
+  uuid = 2c5ADu-oEdt-ovCe-rqp0-MWpF-I5u1-8XigH4 
+  vg_name = vg00 
+              
+                   
+     
+  Command Output Used In The Above Examples: /sbin/vgdisplay -v
+  --- Volume group ---
+  VG Name               vg00
+  VG Access             read/write
+  VG Status             available/resizable
+  VG #                  0
+  MAX LV                256
+  Cur LV                3
+  Open LV               0
+  MAX LV Size           255.99 GB
+  Max PV                256
+  Cur PV                2
+  Act PV                2
+  VG Size               18.38 GB
+  PE Size               4 MB
+  Total PE              4704
+  Alloc PE / Size       3840 / 15 GB
+  Free  PE / Size       864 / 3.38 GB
+  VG UUID               BBq8si-NyRR-9ZNW-3J5e-DoRO-RBHK-ckrszi
+  
+  --- Logical volume ---
+  LV Name                /dev/vg00/lvol1
+  VG Name                vg00
+  LV Write Access        read/write
+  LV Status              available
+  LV #                   1
+  # open                 0
+  LV Size                4 GB
+  Current LE             1024
+  Allocated LE           1024
+  Allocation             next free
+  Read ahead sectors     1024
+  Block device           58:0
+  
+  --- Logical volume ---
+  LV Name                /dev/vg00/lvol2
+  VG Name                vg00
+  LV Write Access        read/write
+  LV Status              available
+  LV #                   2
+  # open                 0
+  LV Size                5 GB
+  Current LE             1280
+  Allocated LE           1280
+  Allocation             next free
+  Read ahead sectors     1024
+  Block device           58:1
+  
+  --- Logical volume ---
+  LV Name                /dev/vg00/lvol3
+  VG Name                vg00
+  LV Write Access        read/write
+  LV Status              available
+  LV #                   3
+  # open                 0
+  LV Size                6 GB
+  Current LE             1536
+  Allocated LE           1536
+  Allocation             next free
+  Read ahead sectors     1024
+  Block device           58:2
+  
+  --- Physical volumes ---
+  PV Name (#)           /dev/hda3 (1)
+  PV Status             available / allocatable
+  Total PE / Free PE    2160 / 0
+  
+  PV Name (#)           /dev/hda4 (2)
+  PV Status             available / allocatable
+  Total PE / Free PE    2544 / 864
+
+
+=head1 SEE ALSO
+
+L<vgdisplay>(1M)
+L<lvdisplay>(1M)
+L<pvdisplay>(1M)
+
+=head1 AUTHOR
+
+Chad Kerner, E<lt>chadkerner@yahoo.comE<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2003 by Chad Kerner
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+Modified by Daniel Berteaud <daniel@firewall-services.com> to add
+support for LVM thin
+
+=cut
diff --git a/zabbix_scripts/check_lvm_sudo b/zabbix_scripts/check_lvm_sudo
index c01e117..83af2f4 100644
--- a/zabbix_scripts/check_lvm_sudo
+++ b/zabbix_scripts/check_lvm_sudo
@@ -1,8 +1,8 @@
 #!/usr/bin/perl -w
 
-use Linux::LVM;
+use Zabbix::Agent::Addons::LVM;
 
-Linux::LVM->units(B);
+Zabbix::Agent::Addons::LVM->units(B);
 
 if (@ARGV < 2){
     usage();
diff --git a/zabbix_scripts/disco_lvm_sudo b/zabbix_scripts/disco_lvm_sudo
index e976605..7723c65 100644
--- a/zabbix_scripts/disco_lvm_sudo
+++ b/zabbix_scripts/disco_lvm_sudo
@@ -1,6 +1,6 @@
 #!/usr/bin/perl -w
 
-use Linux::LVM;
+use Zabbix::Agent::Addons::LVM;
 use JSON;
 
 my $what = $ARGV[0];