##
##  OSSP snmpdx - SNMP Daemon Extension
##  Copyright (c) 2003-2007 The OSSP Project <http://www.ossp.org/>
##  Copyright (c) 2003-2007 Ralf S. Engelschall <rse@engelschall.com>
##  Copyright (c) 2003-2005 Cable & Wireless <http://www.cw.com/>
##
##  This file is part of OSSP snmpdx, a SNMP daemon extension which
##  can be found at http://www.ossp.org/pkg/tool/snmpdx/.
##
##  This program is free software; you can redistribute it and/or
##  modify it under the terms of the GNU General Public  License
##  as published by the Free Software Foundation; either version
##  2.0 of the License, or (at your option) any later version.
##
##  This program is distributed in the hope that it will be useful,
##  but WITHOUT ANY WARRANTY; without even the implied warranty of
##  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
##  General Public License for more details.
##
##  You should have received a copy of the GNU General Public License
##  along with this file; if not, write to the Free Software
##  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
##  USA, or contact Ralf S. Engelschall <rse@engelschall.com>.
##
##  sysVM.pm: probe for System Virtual Memory
##

package My::Probe::sysVM;
our @ISA = qw(My::Probe);

sub oids ($) {
    my ($self) = @_;
    return $self->{-ctx}->{-mib}->oids("*.snmpdx.host.system.sysVM.*");
}

sub probe ($$) {
    my ($self, $obj) = @_;

    if ($self->{-ctx}->{-platform}->id() =~ m/FreeBSD/i) {
        ##
        ##  FreeBSD 4/5
        ##
        ##  sysVMRamMax   "/sbin/sysctl -a", "hw.physmem", convert bytes to MB
        ##  sysVMRamUsed  sysVMRamMax - sysVMRamFree
        ##  sysVMRamFree  "/sbin/sysctl -a", "vm.stats.vm.*", convert pages to MB
        ##  sysVMSwapMax  "/usr/sbin/swapinfo -k", 1K-blocks, last line, convert KB to MB
        ##  sysVMSwapUsed "/usr/sbin/swapinfo -k", Used, last line, convert KB to MB
        ##  sysVMSwapFree sysVMSwapMax - sysVMSwapUsed
        ##  sysVMActivity "/usr/bin/vmstat", add pi and po column
        ##
        if ($obj->{-name} =~ m/\.sysVMRam(Max|Used|Free)$/) {
            my $sysVMRamMax;
            my $sysVMRamUsed;
            my $sysVMRamFree;

            #   query system for sysctl(8) variables
            my $out = $self->{-ctx}->{-sys}->run("/sbin/sysctl -a", "1m");
            my $sysctl = {};
            foreach my $line (split(/\n/, $out->{-stdout})) {
                $sysctl->{$1} = $2 if ($line =~ m/^([^:]+):\s+(.+)\s*$/s);
            }

            #   determine sysVMRamMax
            $sysVMRamMax = int(&mem_rounded($sysctl->{"hw.physmem"}) / (1024*1024));

            #   determine sysVMRamFree
            $sysVMRamFree =
                int((  $sysctl->{"hw.pagesize"}
                     * (  $sysctl->{"vm.stats.vm.v_inactive_count"} 
                        + $sysctl->{"vm.stats.vm.v_cache_count"}
                        + $sysctl->{"vm.stats.vm.v_free_count"}    )) / (1024*1024));

            #   determine sysVMRamUsed
            if (defined($sysVMRamMax) and defined($sysVMRamFree)) {
                $sysVMRamUsed = ($sysVMRamMax - $sysVMRamFree);
            }

            #   provide result
            $obj->{-value} = $sysVMRamMax  if ($obj->{-name} =~ m/\.sysVMRamMax$/);
            $obj->{-value} = $sysVMRamUsed if ($obj->{-name} =~ m/\.sysVMRamUsed$/);
            $obj->{-value} = $sysVMRamFree if ($obj->{-name} =~ m/\.sysVMRamFree$/);
        }
        elsif ($obj->{-name} =~ m/\.sysVMSwap(Max|Used|Free)$/) {
            my $sysVMSwapMax;
            my $sysVMSwapUsed;
            my $sysVMSwapFree;

            #   determine sysVMSwapMax and sysVMSwapUsed
            my $out = $self->{-ctx}->{-sys}->run("/usr/sbin/swapinfo -k", "1m");
            my $raw = $out->{-stdout};
            my $n2i = {};
            if ($raw =~ m/^\s*([^\n]*\b1K-blocks[^\n]*\bUsed[^\n]*).*\n([^\n]+)$/s) {
                $n2i = &mkn2i(split(/\s+/, $1));
            }
            my @dat = split(/\s+/, $2);
            if (defined($n2i->{_1K_blocks})) {
                $sysVMSwapMax = int(@dat[$n2i->{_1K_blocks}] / 1024)
            }
            if (defined($n2i->{Used})) {
                $sysVMSwapUsed = int(@dat[$n2i->{Used}] / 1024)
            }

            #   determine sysVMSwapFree
            if (defined($sysVMSwapMax) and defined($sysVMSwapUsed)) {
                $sysVMSwapFree = $sysVMSwapMax - $sysVMSwapUsed;
            }

            #   provide result
            $obj->{-value} = $sysVMSwapMax  if ($obj->{-name} =~ m/\.sysVMSwapMax$/);
            $obj->{-value} = $sysVMSwapUsed if ($obj->{-name} =~ m/\.sysVMSwapUsed$/);
            $obj->{-value} = $sysVMSwapFree if ($obj->{-name} =~ m/\.sysVMSwapFree$/);
        }
        elsif ($obj->{-name} =~ m/\.sysVMActivity$/) {
            my $sysVMActivity;

            my $out = $self->{-ctx}->{-sys}->run("/usr/bin/vmstat", "1m");
            my $raw = $out->{-stdout};
            my $n2i = {};
            if ($raw =~ m/^[^\n]*\n *([^\n]*(\bp[io]\b[^\n]*){2})\n *([^\n]*)\n$/s) {
                $n2i = &mkn2i(split / +/, $1);
            }
            if (defined($n2i->{pi}) and defined($n2i->{po})) {
                my @dat = split(/ +/, $3);
                $sysVMActivity = @dat[$n2i->{pi}] + @dat[$n2i->{po}];
            }
            $obj->{-value} = $sysVMActivity;
        }
    }
    elsif ($self->{-ctx}->{-platform}->id() =~ m/Linux/i) {
        ##
        ##  Linux 2.2/2.4
        ##
        ##  sysVMRamMax   "/bin/cat /proc/meminfo", MemTotal, convert KB to MB
        ##  sysVMRamUsed  "/bin/cat /proc/meminfo", MemTotal-Buffers-Cached-MemFree, convert KB to MB
        ##  sysVMRamFree  sysVMRamMax - sysVMRamUsed
        ##  sysVMSwapMax  "/bin/cat /proc/meminfo", SwapTotal, convert KB to MB
        ##  sysVMSwapUsed sysVMSwapMax - sysVMSwapFree
        ##  sysVMSwapFree "/bin/cat /proc/meminfo", SwapFree, convert KB to MB
        ##  sysVMActivity "/usr/bin/vmstat", add si and so column
        ##
        ##  FIXME: sysVMRamMax does not include the kernel and some of
        ##  its structures so it is not pyhsical RAM, see dmesg | egrep
        ##  '^Memory:'. Additionally, /bin/cat is used here but could be
        ##  replaced by native Perl code to improve performance...
        ##
        if ($obj->{-name} =~ m/\.sysVMRam(Max|Used|Free)$/) {
            my $sysVMRamMax;
            my $sysVMRamUsed;
            my $sysVMRamFree;

            #   determine sysVMRamMax and sysVMRamUsed
            my $out = $self->{-ctx}->{-sys}->run("/bin/cat /proc/meminfo", "1m");
            my $raw = $out->{-stdout};
            my $tmp = {};
            $tmp->{MemTotal} = $1 if ($raw =~ m/\nMemTotal:[^\n]*\b(\d+)\b[^\n]*kB\n/s);
            $tmp->{Buffers}  = $1 if ($raw =~ m/\nBuffers:[^\n]*\b(\d+)\b[^\n]*kB\n/s);
            $tmp->{Cached}   = $1 if ($raw =~ m/\nCached:[^\n]*\b(\d+)\b[^\n]*kB\n/s);
            $tmp->{MemFree}  = $1 if ($raw =~ m/\nMemFree:[^\n]*\b(\d+)\b[^\n]*kB\n/s);
            if (defined($tmp->{MemTotal})) {
                $sysVMRamMax = int($tmp->{MemTotal} / 1024);
            }
            if (    defined($tmp->{MemTotal})
                and defined($tmp->{Buffers})
                and defined($tmp->{Cached})
                and defined($tmp->{MemFree}) ) {
                $sysVMRamUsed = int ((  $tmp->{MemTotal} 
                                      - $tmp->{Buffers} 
                                      - $tmp->{Cached} 
                                      - $tmp->{MemFree} ) / 1024 );
            }

            #   determine sysVMRamFree
            if (defined $sysVMRamMax and defined $sysVMRamUsed) {
                $sysVMRamFree = $sysVMRamMax - $sysVMRamUsed;
            }

            #   provide result
            $obj->{-value} = $sysVMRamMax  if ($obj->{-name} =~ m/\.sysVMRamMax$/);
            $obj->{-value} = $sysVMRamUsed if ($obj->{-name} =~ m/\.sysVMRamUsed$/);
            $obj->{-value} = $sysVMRamFree if ($obj->{-name} =~ m/\.sysVMRamFree$/);
        }
        elsif ($obj->{-name} =~ m/\.sysVMSwap(Max|Used|Free)$/) {
            my $sysVMSwapMax;
            my $sysVMSwapUsed;
            my $sysVMSwapFree;

            #   determine sysVMSwapMax and sysVMSwapFree
            my $out = $self->{-ctx}->{-sys}->run("/bin/cat /proc/meminfo", "1m");
            my $raw = $out->{-stdout};
            if ($raw =~ m/\nSwapTotal:[^\n]*\b(\d+)\b[^\n]*kB\n/s) {
                $sysVMSwapMax = int($1 / 1024);
            }
            if ($raw =~ m/\nSwapFree:[^\n]*\b(\d+)\b[^\n]*kB\n/s) {
                $sysVMSwapFree = int($1 / 1024);
            }

            #   determine sysVMSwapUsed
            if (defined($sysVMSwapMax) and defined($sysVMSwapFree)) {
                $sysVMSwapUsed = $sysVMSwapMax - $sysVMSwapFree;
            }

            #   provide result
            $obj->{-value} = $sysVMSwapMax  if ($obj->{-name} =~ m/\.sysVMSwapMax$/);
            $obj->{-value} = $sysVMSwapUsed if ($obj->{-name} =~ m/\.sysVMSwapUsed$/);
            $obj->{-value} = $sysVMSwapFree if ($obj->{-name} =~ m/\.sysVMSwapFree$/);
        }
        elsif ($obj->{-name} =~ m/\.sysVMActivity$/) {
            my $sysVMActivity;

            my $out = $self->{-ctx}->{-sys}->run("/usr/bin/vmstat", "1m");
            my $raw = $out->{-stdout};
            my $n2i = {};
            if ($raw =~ m/^[^\n]*\n *([^\n]*(\bs[io]\b[^\n]*){2})\n *([^\n]*)\n$/s) {
                $n2i = &mkn2i(split(/\s+/, $1)) if (not defined($n2i->{sr}));
            }
            if (defined($n2i->{si}) and defined($n2i->{so})) {
                my @dat = split(/\s+/, $3);
                $sysVMActivity = @dat[$n2i->{si}] + @dat[$n2i->{so}];
            }
            $obj->{-value} = $sysVMActivity;
        }
    }
    elsif ($self->{-ctx}->{-platform}->id() =~ m/SunOS/i) {
        ##
        ##  Sun Solaris 2.x (SunOS 5.x)
        ##
        ##  sysVMRamMax   "/usr/platform/$arch/sbin/prtdiag", Memory size
        ##  sysVMRamUsed  sysVMRamMax - sysVMRamFree
        ##  sysVMRamFree  "/bin/pagesize" * "/bin/sar -r 1 1", freemem, convert bytes to MB
        ##  sysVMSwapMax  "swap -l", egrep ^/ and accumulate, convert 512byte blocks to MB
        ##  sysVMSwapUsed sysVMSwapMax - sysVMSwapFree
        ##  sysVMSwapFree "swap -l", egrep ^/ and accumulate, convert 512byte blocks to MB
        ##  sysVMActivity "/bin/vmstat", sr column
        ##
        if ($obj->{-name} =~ m/\.sysVMRam(Max|Used|Free)$/) {
            my $sysVMRamMax;
            my $sysVMRamUsed;
            my $sysVMRamFree;

            #   determine architecture
            my $arch = $self->{-ctx}->{-platform}->arch();

            #   determine page size
            my $out = $self->{-ctx}->{-sys}->run("/bin/pagesize", "forever");
            my $raw = $out->{-stdout};
            my $pagesize = 4096;
            if ($raw =~ m/^(\d+)$/) {
                $pagesize = $1;
            }

            #   determine sysVMRamMax
            $out = $self->{-ctx}->{-sys}->run("/usr/platform/$arch/sbin/prtdiag -v", "1m");
            $raw = $out->{-stdout};
            if ($raw =~ m/\nMemory size: (\d+) Megabytes/s) {
                $sysVMRamMax = $1;
            }

            #   determine sysVMRamFree
            $out = $self->{-ctx}->{-sys}->run("/bin/sar -r 1 1", "1m");
            $raw = $out->{-stdout};
            my $n2i = {};
            if ($raw =~ m/^.*\n([^\n]*\bfreemem[^\n]*)\n(.*)$/s) {
                $n2i = &mkn2i(split(/\s+/, $1));
            }
            my @dat = split(/\s+/, $2);
            if (defined($n2i->{freemem})) {
                $tmp = @dat[$n2i->{freemem}];
            }
            $sysVMRamFree = int($tmp * $pagesize / (1024*1024)) if (defined($tmp));

            #   determine sysVMRamUsed
            if (defined($sysVMRamMax) and defined($sysVMRamFree)) {
                $sysVMRamUsed = $sysVMRamMax - $sysVMRamFree;
            }

            #   provide result
            $obj->{-value} = $sysVMRamMax  if ($obj->{-name} =~ m/\.sysVMRamMax$/);
            $obj->{-value} = $sysVMRamUsed if ($obj->{-name} =~ m/\.sysVMRamUsed$/);
            $obj->{-value} = $sysVMRamFree if ($obj->{-name} =~ m/\.sysVMRamFree$/);
        }
        elsif ($obj->{-name} =~ m/\.sysVMSwap(Max|Used|Free)$/) {
            my $sysVMSwapMax;
            my $sysVMSwapUsed;
            my $sysVMSwapFree;

            #   determine sysVMSwapMax, sysVMSwapFree
            my $out = $self->{-ctx}->{-sys}->run("/usr/sbin/swap -l", "1m");
            my $raw = $out->{-stdout};
            my $n2i = {};
            if ($raw =~ m/^\s*([^\n]*\bblocks[^\n]*\bfree[^\n]*)\n(.*)$/s) {
                $n2i = &mkn2i(split(/\s+/, $1)) if (scalar(keys(%{$n2i})) == 0);
            }
            my $tmpMax;
            my $tmpFree;
            foreach my $r (split(/\n/, $2)) {
                if ($r =~ m/^\//) {
                    my @dat = split(/\s+/, $r);
                    if (defined($n2i->{blocks})) {
                        $tmpMax  = 0 if (not defined($tmpMax));
                        $tmpMax  += @dat[$n2i->{blocks}];
                    }
                    if (defined($n2i->{free})) {
                        $tmpFree = 0 if (not defined($tmpFree));
                        $tmpFree += @dat[$n2i->{free}];
                    }
                }
            }
            $sysVMSwapMax  = int($tmpMax  * 512 / 1024 / 1024) if (defined($tmpMax));
            $sysVMSwapFree = int($tmpFree * 512 / 1024 / 1024) if (defined($tmpFree));

            #   determine sysVMSwapUsed
            if (defined($sysVMSwapMax) and defined($sysVMSwapFree)) {
                $sysVMSwapUsed = $sysVMSwapMax - $sysVMSwapFree;
            }

            #   provide result
            $obj->{-value} = $sysVMSwapMax  if ($obj->{-name} =~ m/\.sysVMSwapMax$/);
            $obj->{-value} = $sysVMSwapUsed if ($obj->{-name} =~ m/\.sysVMSwapUsed$/);
            $obj->{-value} = $sysVMSwapFree if ($obj->{-name} =~ m/\.sysVMSwapFree$/);
        }
        elsif ($obj->{-name} =~ m/\.sysVMActivity$/) {
            my $sysVMActivity;

            my $out = $self->{-ctx}->{-sys}->run("/bin/vmstat", "1m");
            my $raw = $out->{-stdout};
            my $n2i = {};
            if ($raw =~ m/^[^\n]*\n *([^\n]*\bsr\b[^\n]*)\n *([^\n]*)\n$/s) {
                $n2i = &mkn2i(split(/\s+/, $1)) if (not defined($n2i->{sr}));
            }
            if (defined $n2i->{sr}) {
                my @dat = split(/\s+/, $2);
                $sysVMActivity = @dat[$n2i->{sr}];
            }
            $obj->{-value} = $sysVMActivity;
        }
    }
    return;
}

#   table row name to index mapping
sub mkn2i ($) {
    my (@name) = @_;
    my $rc = {};
    my $i = 0;
    foreach my $f (@name) {
        $f =~ s/[^\w]/_/;
        $f =~ s/^([^a-zA-Z_])/_$1/;
        $rc->{$f} = $i++;
    };
    return $rc;
}

#   round the physical memory size to the next power of two which is
#   reasonable for memory cards. We do this by first determining the
#   guessed memory card size under the assumption that usual computer
#   hardware has an average of a maximally eight memory cards installed
#   and those are usually of equal size.
sub mem_rounded {
    my ($mem_size) = @_;
    my $chip_size  = 1;
    my $chip_guess = ($mem_size / 8) - 1;
    while ($chip_guess != 0) {
        $chip_guess >>= 1;
        $chip_size  <<= 1;
    }
    my $mem_round = (int($mem_size / $chip_size) + 1) * $chip_size;
    return $mem_round;
}

1;