Merge ~aieri/charm-nrpe:bug/1802887 into ~nrpe-charmers/charm-nrpe:master

[Andrea Ieri]

[check_mem] bump plugin version and turn on ignoring hugepages by default

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Unable to determine commit message from repository - please click "Set commit message" and enter the commit message manually.

[Peter Sabaini (peter-sabaini)]

lgtm, thanks!

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision d609bbe38148b8d30cf5e60843ec080dda36fd7b

diff --git a/config.yaml b/config.yaml
index 241f32e..1a967b5 100644
--- a/config.yaml
+++ b/config.yaml
@@ -111,10 +111,12 @@ options:
         .
         Set to '' in order to disable this check.
   mem:
-    default: "-C -u -w 85 -c 90"
+    default: "-C -h -u -w 85 -c 90"
     type: string
     description: |
         Check memory % used.
+        By default, thresholds are applied to the non-hugepages portion of the
+        memory.
         .
         Set to '' in order to disable this check.
   lacp_bonds:
diff --git a/files/plugins/check_mem.pl b/files/plugins/check_mem.pl
index 37217de..9b4c997 100755
--- a/files/plugins/check_mem.pl
+++ b/files/plugins/check_mem.pl
@@ -32,9 +32,9 @@ use Getopt::Std;
 #TODO - Use an alarm
 
 # Predefined exit codes for Nagios
-use vars qw($opt_c $opt_f $opt_u $opt_w $opt_C $opt_v %exit_codes);
-%exit_codes   = ('UNKNOWN' ,-1,
-        		 'OK'      , 0,
+use vars qw($opt_c $opt_f $opt_u $opt_w $opt_C $opt_v $opt_h %exit_codes);
+%exit_codes   = ('UNKNOWN' , 3,
+                 'OK'      , 0,
                  'WARNING' , 1,
                  'CRITICAL', 2,
                  );
@@ -43,32 +43,50 @@ use vars qw($opt_c $opt_f $opt_u $opt_w $opt_C $opt_v %exit_codes);
 init();
 
 # Get the numbers:
-my ($free_memory_kb,$used_memory_kb,$caches_kb) = get_memory_info();
+my ($free_memory_kb,$used_memory_kb,$caches_kb,$hugepages_kb) = get_memory_info();
 print "$free_memory_kb Free\n$used_memory_kb Used\n$caches_kb Cache\n" if ($opt_v);
+print "$hugepages_kb Hugepages\n" if ($opt_v and $opt_h);
 
 if ($opt_C) { #Do we count caches as free?
     $used_memory_kb -= $caches_kb;
     $free_memory_kb += $caches_kb;
 }
 
+if ($opt_h) {
+    $used_memory_kb -= $hugepages_kb;
+}
+
+print "$used_memory_kb Used (after Hugepages)\n" if ($opt_v);
+
 # Round to the nearest KB
 $free_memory_kb = sprintf('%d',$free_memory_kb);
 $used_memory_kb = sprintf('%d',$used_memory_kb);
 $caches_kb = sprintf('%d',$caches_kb);
 
 # Tell Nagios what we came up with
-tell_nagios($used_memory_kb,$free_memory_kb,$caches_kb);
+tell_nagios($used_memory_kb,$free_memory_kb,$caches_kb,$hugepages_kb);
 
 
 sub tell_nagios {
-    my ($used,$free,$caches) = @_;
-    
+    my ($used,$free,$caches,$hugepages) = @_;
+
     # Calculate Total Memory
     my $total = $free + $used;
     print "$total Total\n" if ($opt_v);
 
-    my $perfdata = "|TOTAL=${total}KB;;;; USED=${used}KB;;;; FREE=${free}KB;;;; CACHES=${caches}KB;;;;";
-    
+    my $perf_warn;
+    my $perf_crit;
+    if ( $opt_u ) {
+      $perf_warn = int(${total} * $opt_w / 100);
+      $perf_crit = int(${total} * $opt_c / 100);
+    } else {
+      $perf_warn = int(${total} * ( 100 - $opt_w ) / 100);
+      $perf_crit = int(${total} * ( 100 - $opt_c ) / 100);
+    }
+
+    my $perfdata = "|TOTAL=${total}KB;;;; USED=${used}KB;${perf_warn};${perf_crit};; FREE=${free}KB;;;; CACHES=${caches}KB;;;;";
+    $perfdata .= " HUGEPAGES=${hugepages}KB;;;;" if ($opt_h);
+
     if ($opt_f) {
       my $percent    = sprintf "%.1f", ($free / $total * 100);
       if ($percent <= $opt_c) {
@@ -104,13 +122,14 @@ sub usage() {
   print " -f           Check FREE memory\n";
   print " -u           Check USED memory\n";
   print " -C           Count OS caches as FREE memory\n";
+  print " -h           Remove hugepages from the total memory count\n";
   print " -w PERCENT   Percent free/used when to warn\n";
   print " -c PERCENT   Percent free/used when critical\n";
   print "\nCopyright (C) 2000 Dan Larsson <dl\@tyfon.net>\n";
   print "check_mem.pl comes with absolutely NO WARRANTY either implied or explicit\n";
   print "This program is licensed under the terms of the\n";
   print "MIT License (check source code for details)\n";
-  exit $exit_codes{'UNKNOWN'}; 
+  exit $exit_codes{'UNKNOWN'};
 }
 
 sub get_memory_info {
@@ -118,6 +137,9 @@ sub get_memory_info {
     my $free_memory_kb  = 0;
     my $total_memory_kb = 0;
     my $caches_kb       = 0;
+    my $hugepages_nr    = 0;
+    my $hugepages_size  = 0;
+    my $hugepages_kb    = 0;
 
     my $uname;
     if ( -e '/usr/bin/uname') {
@@ -146,8 +168,108 @@ sub get_memory_info {
             elsif (/^(Buffers|Cached|SReclaimable):\s+(\d+) kB/) {
                 $caches_kb += $2;
             }
+            elsif (/^Shmem:\s+(\d+) kB/) {
+                $caches_kb -= $1;
+            }
+            # These variables will most likely be overwritten once we look into
+            # /sys/kernel/mm/hugepages, unless we are running on linux <2.6.27
+            # and have to rely on them
+            elsif (/^HugePages_Total:\s+(\d+)/) {
+                $hugepages_nr = $1;
+            }
+            elsif (/^Hugepagesize:\s+(\d+) kB/) {
+                $hugepages_size = $1;
+            }
         }
+        $hugepages_kb = $hugepages_nr * $hugepages_size;
         $used_memory_kb = $total_memory_kb - $free_memory_kb;
+
+        # Read hugepages info from the newer sysfs interface if available
+        my $hugepages_sysfs_dir = '/sys/kernel/mm/hugepages';
+        if ( -d $hugepages_sysfs_dir ) {
+            # Reset what we read from /proc/meminfo
+            $hugepages_kb = 0;
+            opendir(my $dh, $hugepages_sysfs_dir)
+                || die "Can't open $hugepages_sysfs_dir: $!";
+            while (my $entry = readdir $dh) {
+                if ($entry =~ /^hugepages-(\d+)kB/) {
+                    $hugepages_size = $1;
+                    my $hugepages_nr_file = "$hugepages_sysfs_dir/$entry/nr_hugepages";
+                    open(my $fh, '<', $hugepages_nr_file)
+                        || die "Can't open $hugepages_nr_file for reading: $!";
+                    $hugepages_nr = <$fh>;
+                    close($fh);
+                    $hugepages_kb += $hugepages_nr * $hugepages_size;
+                }
+            }
+            closedir($dh);
+        }
+    }
+    elsif ( $uname =~ /HP-UX/ ) {
+      # HP-UX, thanks to Christoph Fürstaller
+      my @meminfo = `/usr/bin/sudo /usr/local/bin/kmeminfo`;
+      foreach (@meminfo) {
+        chomp;
+        if (/^Physical memory\s\s+=\s+(\d+)\s+(\d+.\d)g/) {
+            $total_memory_kb = ($2 * 1024 * 1024);
+        }
+        elsif (/^Free memory\s\s+=\s+(\d+)\s+(\d+.\d)g/) {
+            $free_memory_kb = ($2 * 1024 * 1024);
+        }
+      }
+     $used_memory_kb = $total_memory_kb - $free_memory_kb;
+    }
+    elsif ( $uname =~ /FreeBSD/ ) {
+      # The FreeBSD case. 2013-03-19 www.claudiokuenzler.com
+      # free mem = Inactive*Page Size + Cache*Page Size + Free*Page Size
+      my $pagesize = `sysctl vm.stats.vm.v_page_size`;
+      $pagesize =~ s/[^0-9]//g;
+      my $mem_inactive = 0;
+      my $mem_cache = 0;
+      my $mem_free = 0;
+      my $mem_total = 0;
+      my $free_memory = 0;
+        my @meminfo = `/sbin/sysctl vm.stats.vm`;
+        foreach (@meminfo) {
+            chomp;
+            if (/^vm.stats.vm.v_inactive_count:\s+(\d+)/) {
+            $mem_inactive = ($1 * $pagesize);
+            }
+            elsif (/^vm.stats.vm.v_cache_count:\s+(\d+)/) {
+            $mem_cache = ($1 * $pagesize);
+            }
+            elsif (/^vm.stats.vm.v_free_count:\s+(\d+)/) {
+            $mem_free = ($1 * $pagesize);
+            }
+            elsif (/^vm.stats.vm.v_page_count:\s+(\d+)/) {
+            $mem_total = ($1 * $pagesize);
+            }
+        }
+        $free_memory = $mem_inactive + $mem_cache + $mem_free;
+        $free_memory_kb = ( $free_memory / 1024);
+        $total_memory_kb = ( $mem_total / 1024);
+        $used_memory_kb = $total_memory_kb - $free_memory_kb;
+        $caches_kb = ($mem_cache / 1024);
+    }
+    elsif ( $uname =~ /joyent/ ) {
+      # The SmartOS case. 2014-01-10 www.claudiokuenzler.com
+      # free mem = pagesfree * pagesize
+      my $pagesize = `pagesize`;
+      my $phys_pages = `kstat -p unix:0:system_pages:pagestotal | awk '{print \$NF}'`;
+      my $free_pages = `kstat -p unix:0:system_pages:pagesfree | awk '{print \$NF}'`;
+      my $arc_size = `kstat -p zfs:0:arcstats:size | awk '{print \$NF}'`;
+      my $arc_size_kb = $arc_size / 1024;
+
+      print "Pagesize is $pagesize" if ($opt_v);
+      print "Total pages is $phys_pages" if ($opt_v);
+      print "Free pages is $free_pages" if ($opt_v);
+      print "Arc size is $arc_size" if ($opt_v);
+
+      $caches_kb += $arc_size_kb;
+
+      $total_memory_kb = $phys_pages * $pagesize / 1024;
+      $free_memory_kb = $free_pages * $pagesize / 1024;
+      $used_memory_kb = $total_memory_kb - $free_memory_kb;
     }
     elsif ( $uname =~ /SunOS/ ) {
         eval "use Sun::Solaris::Kstat";
@@ -170,7 +292,7 @@ sub get_memory_info {
                 }
             }
             $used_memory_kb = $total_memory_kb - $free_memory_kb;
-            
+
         }
         else { # We have kstat
             my $kstat = Sun::Solaris::Kstat->new();
@@ -180,21 +302,39 @@ sub get_memory_info {
             # to me how to determine UFS's cache size.  There's inode_cache,
             # and maybe the physmem variable in the system_pages module??
             # In the real world, it looks to be so small as not to really matter,
-            # so we don't grab it.  If someone can give me code that does this, 
+            # so we don't grab it.  If someone can give me code that does this,
             # I'd be glad to put it in.
             my $arc_size = (exists ${kstat}->{zfs} && ${kstat}->{zfs}->{0}->{arcstats}->{size}) ?
-                 ${kstat}->{zfs}->{0}->{arcstats}->{size} / 1024 
+                 ${kstat}->{zfs}->{0}->{arcstats}->{size} / 1024
                  : 0;
             $caches_kb += $arc_size;
             my $pagesize = `pagesize`;
-    
+
             $total_memory_kb = $phys_pages * $pagesize / 1024;
             $free_memory_kb = $free_pages * $pagesize / 1024;
             $used_memory_kb = $total_memory_kb - $free_memory_kb;
         }
     }
+    elsif ( $uname =~ /Darwin/ ) {
+        $total_memory_kb = (split(/ /,`/usr/sbin/sysctl hw.memsize`))[1]/1024;
+        my $pagesize     = (split(/ /,`/usr/sbin/sysctl hw.pagesize`))[1];
+        $caches_kb       = 0;
+        my @vm_stat = `/usr/bin/vm_stat`;
+        foreach (@vm_stat) {
+            chomp;
+            if (/^(Pages free):\s+(\d+)\.$/) {
+                $free_memory_kb = $2*$pagesize/1024;
+            }
+            # 'caching' concept works different on MACH
+            # this should be a reasonable approximation
+            elsif (/^Pages (inactive|purgable):\s+(\d+).$/) {
+                $caches_kb += $2*$pagesize/1024;
+            }
+        }
+        $used_memory_kb = $total_memory_kb - $free_memory_kb;
+    }
     elsif ( $uname =~ /AIX/ ) {
-        my @meminfo = `/usr/bin/vmstat -v`;
+        my @meminfo = `/usr/bin/vmstat -vh`;
         foreach (@meminfo) {
             chomp;
             if (/^\s*([0-9.]+)\s+(.*)/) {
@@ -208,6 +348,9 @@ sub get_memory_info {
                 if ($counter_name eq 'file pages') {
                     $caches_kb = $1*4;
                 }
+                if ($counter_name eq 'Number of 4k page frames loaned') {
+                    $free_memory_kb += $1*4;
+                }
             }
         }
         $used_memory_kb = $total_memory_kb - $free_memory_kb;
@@ -217,16 +360,16 @@ sub get_memory_info {
             print "You can't report on $uname caches!\n";
             exit $exit_codes{UNKNOWN};
         }
-    	my $command_line = `vmstat | tail -1 | awk '{print \$4,\$5}'`;
-    	chomp $command_line;
+        my $command_line = `vmstat | tail -1 | awk '{print \$4,\$5}'`;
+        chomp $command_line;
         my @memlist      = split(/ /, $command_line);
-    
+
         # Define the calculating scalars
         $used_memory_kb  = $memlist[0]/1024;
         $free_memory_kb = $memlist[1]/1024;
         $total_memory_kb = $used_memory_kb + $free_memory_kb;
     }
-    return ($free_memory_kb,$used_memory_kb,$caches_kb);
+    return ($free_memory_kb,$used_memory_kb,$caches_kb,$hugepages_kb);
 }
 
 sub init {
@@ -235,9 +378,9 @@ sub init {
       &usage;
     }
     else {
-      getopts('c:fuCvw:');
+      getopts('c:fuChvw:');
     }
-    
+
     # Shortcircuit the switches
     if (!$opt_w or $opt_w == 0 or !$opt_c or $opt_c == 0) {
       print "*** You must define WARN and CRITICAL levels!\n";
@@ -247,7 +390,7 @@ sub init {
       print "*** You must select to monitor either USED or FREE memory!\n";
       &usage;
     }
-    
+
     # Check if levels are sane
     if ($opt_w <= $opt_c and $opt_f) {
       print "*** WARN level must not be less than CRITICAL when checking FREE memory!\n";