head	1.13;
access;
symbols
	SNMPDX_1_0_0:1.13
	SNMPDX_0_2_11:1.12
	SNMPDX_0_2_10:1.11
	SNMPDX_0_2_9:1.10
	SNMPDX_0_2_8:1.9
	SNMPDX_0_2_7:1.9
	SNMPDX_0_2_6:1.6
	SNMPDX_0_2_5:1.6
	SNMPDX_0_2_4:1.6
	SNMPDX_0_2_3:1.6
	SNMPDX_0_2_2:1.6
	SNMPDX_0_2_1:1.5
	SNMPDX_0_2_0:1.5;
locks; strict;
comment	@# @;


1.13
date	2007.03.01.10.52.39;	author rse;	state Exp;
branches;
next	1.12;
commitid	FNuFlqR2Qo3fkn8s;

1.12
date	2005.10.05.17.42.13;	author rse;	state Exp;
branches;
next	1.11;

1.11
date	2004.07.29.09.48.25;	author thl;	state Exp;
branches;
next	1.10;

1.10
date	2004.07.28.13.00.59;	author thl;	state Exp;
branches;
next	1.9;

1.9
date	2003.09.20.10.33.17;	author rse;	state Exp;
branches;
next	1.8;

1.8
date	2003.09.20.10.11.22;	author rse;	state Exp;
branches;
next	1.7;

1.7
date	2003.09.10.15.01.46;	author rse;	state Exp;
branches;
next	1.6;

1.6
date	2003.09.09.13.43.45;	author thl;	state Exp;
branches;
next	1.5;

1.5
date	2003.09.04.10.07.47;	author thl;	state Exp;
branches;
next	1.4;

1.4
date	2003.09.04.09.21.04;	author thl;	state Exp;
branches;
next	1.3;

1.3
date	2003.09.04.08.33.16;	author thl;	state Exp;
branches;
next	1.2;

1.2
date	2003.09.03.15.41.04;	author thl;	state Exp;
branches;
next	1.1;

1.1
date	2003.09.03.09.22.03;	author rse;	state Exp;
branches;
next	;


desc
@@


1.13
log
@Upgrade build environment to GNU shtool 2.0.6 and GNU autoconf 2.60
@
text
@##
##  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;

@


1.12
log
@flush pending changes
@
text
@d3 2
a4 2
##  Copyright (c) 2003-2005 The OSSP Project <http://www.ossp.org/>
##  Copyright (c) 2003-2005 Ralf S. Engelschall <rse@@engelschall.com>
@


1.11
log
@remove superfluous "my"
@
text
@d3 3
a5 3
##  Copyright (c) 2003 The OSSP Project <http://www.ossp.org/>
##  Copyright (c) 2003 Ralf S. Engelschall <rse@@engelschall.com>
##  Copyright (c) 2003 Cable & Wireless <http://www.cw.com/>
@


1.10
log
@remove irrelevant assignments which perl >= 5.8.4 optimizes away anyway
@
text
@d67 1
a67 1
            my $sysVMRamFree =
@


1.9
log
@Reimplement the FreeBSD sysVMRam* variables because the vmstat->avm
is totally bogus and cannot be used for RAM usage determination at
all. Instead calculate the stuff through the only reliable source: the
vm.stats.vm* sysctl(8) variables which directly came from the kernel
variables of the VM subsystem. The used calculation in sysVM.pm is now
derived from a larger basic research on this topic resulting in a script
which gives this output:

SYSTEM MEMORY INFORMATION:
mem_wire:         179642368 (    171MB) [  8%] Wired: disabled for paging out
mem_active:  +    158838784 (    151MB) [  7%] Active: recently referenced
mem_inactive:+   1147584512 (   1094MB) [ 54%] Inactive: recently not referenced
mem_cache:   +     71606272 (     68MB) [  3%] Cached: almost avail. for allocation
mem_free:    +    549912576 (    524MB) [ 26%] Free: fully available for allocation
mem_gap_vm:  +       364544 (      0MB) [  0%] Memory gap: UNKNOWN
-------------- ------------ ----------- ------
mem_all:     =   2107949056 (   2010MB) [100%] Total real memory managed
mem_gap_sys: +     35684352 (     34MB)        Memory gap: Kernel?!
-------------- ------------ -----------
mem_phys:    =   2143633408 (   2044MB)        Total real memory available
mem_gap_hw:  +      3850240 (      3MB)        Memory gap: Segment Mappings?!
-------------- ------------ -----------
mem_hw:      =  -2147483648 (   2048MB)        Total real memory installed

SYSTEM MEMORY SUMMARY:
mem_used:         378380288 (    360MB) [ 17%] Logically unused memory
mem_avail:   +   1769103360 (   1687MB) [ 82%] Logically available memory
-------------- ------------ ----------- ------
mem_total:   =  -2147483648 (   2048MB) [100%] Logically total memory

The script itself is appended for reference, too.

--------------------------------------------------------------------
#!/usr/opkg/bin/perl

#   query the system through the generic sysctl(8) interface
#   (this does not require special priviledges)
my $sysctl = {};
my $sysctl_output = `/sbin/sysctl -a`;
foreach my $line (split(/\n/, $sysctl_output)) {
    if ($line =~ m/^([^:]+):\s+(.+)\s*$/s) {
        $sysctl->{$1} = $2;
    }
}

#   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;
}

#   determine the individual known information
#   NOTICE: forget hw.usermem, it is just (hw.physmem - vm.stats.vm.v_wire_count).
#   NOTICE: forget vm.stats.misc.zero_page_count, it is just the subset of
#           vm.stats.vm.v_free_count which is already pre-zeroed.
my $mem_hw        = &mem_rounded($sysctl->{"hw.physmem"});
my $mem_phys      = $sysctl->{"hw.physmem"};
my $mem_all       = $sysctl->{"vm.stats.vm.v_page_count"}      * $sysctl->{"hw.pagesize"};
my $mem_wire      = $sysctl->{"vm.stats.vm.v_wire_count"}      * $sysctl->{"hw.pagesize"};
my $mem_active    = $sysctl->{"vm.stats.vm.v_active_count"}    * $sysctl->{"hw.pagesize"};
my $mem_inactive  = $sysctl->{"vm.stats.vm.v_inactive_count"}  * $sysctl->{"hw.pagesize"};
my $mem_cache     = $sysctl->{"vm.stats.vm.v_cache_count"}     * $sysctl->{"hw.pagesize"};
my $mem_free      = $sysctl->{"vm.stats.vm.v_free_count"}      * $sysctl->{"hw.pagesize"};

#   determine the individual unknown information
my $mem_gap_vm    = $mem_all - ($mem_wire + $mem_active + $mem_inactive + $mem_cache + $mem_free);
my $mem_gap_sys   = $mem_phys - $mem_all;
my $mem_gap_hw    = $mem_hw   - $mem_phys;

#   determine logical summary information
my $mem_total = $mem_hw;
my $mem_avail = $mem_inactive + $mem_cache + $mem_free;
my $mem_used  = $mem_total - $mem_avail;

#   information annotations
my $info = {
    "mem_wire"     => 'Wired: disabled for paging out',
    "mem_active"   => 'Active: recently referenced',
    "mem_inactive" => 'Inactive: recently not referenced',
    "mem_cache"    => 'Cached: almost avail. for allocation',
    "mem_free"     => 'Free: fully available for allocation',
    "mem_gap_vm"   => 'Memory gap: UNKNOWN',
    "mem_all"      => 'Total real memory managed',
    "mem_gap_sys"  => 'Memory gap: Kernel?!',
    "mem_phys"     => 'Total real memory available',
    "mem_gap_hw"   => 'Memory gap: Segment Mappings?!',
    "mem_hw"       => 'Total real memory installed',
    "mem_used"     => 'Logically unused memory',
    "mem_avail"    => 'Logically available memory',
    "mem_total"    => 'Logically total memory',
};

#   print system results
printf("SYSTEM MEMORY INFORMATION:\n");
printf("mem_wire:      %12d (%7dMB) [%3d%%] %s\n", $mem_wire,     $mem_wire     / (1024*1024), ($mem_wire     / $mem_all) * 100, $info->{"mem_wire"});
printf("mem_active:  + %12d (%7dMB) [%3d%%] %s\n", $mem_active,   $mem_active   / (1024*1024), ($mem_active   / $mem_all) * 100, $info->{"mem_active"});
printf("mem_inactive:+ %12d (%7dMB) [%3d%%] %s\n", $mem_inactive, $mem_inactive / (1024*1024), ($mem_inactive / $mem_all) * 100, $info->{"mem_inactive"});
printf("mem_cache:   + %12d (%7dMB) [%3d%%] %s\n", $mem_cache,    $mem_cache    / (1024*1024), ($mem_cache    / $mem_all) * 100, $info->{"mem_cache"});
printf("mem_free:    + %12d (%7dMB) [%3d%%] %s\n", $mem_free,     $mem_free     / (1024*1024), ($mem_free     / $mem_all) * 100, $info->{"mem_free"});
printf("mem_gap_vm:  + %12d (%7dMB) [%3d%%] %s\n", $mem_gap_vm,   $mem_gap_vm   / (1024*1024), ($mem_gap_vm   / $mem_all) * 100, $info->{"mem_gap_vm"});
printf("-------------- ------------ ----------- ------\n");
printf("mem_all:     = %12d (%7dMB) [100%%] %s\n", $mem_all,      $mem_all      / (1024*1024), $info->{"mem_all"});
printf("mem_gap_sys: + %12d (%7dMB)        %s\n",  $mem_gap_sys,  $mem_gap_sys  / (1024*1024), $info->{"mem_gap_sys"});
printf("-------------- ------------ -----------\n");
printf("mem_phys:    = %12d (%7dMB)        %s\n",  $mem_phys,     $mem_phys     / (1024*1024), $info->{"mem_phys"});
printf("mem_gap_hw:  + %12d (%7dMB)        %s\n",  $mem_gap_hw,   $mem_gap_hw   / (1024*1024), $info->{"mem_gap_hw"});
printf("-------------- ------------ -----------\n");
printf("mem_hw:      = %12d (%7dMB)        %s\n",  $mem_hw,       $mem_hw       / (1024*1024), $info->{"mem_hw"});

#   print logical results
printf("\n");
printf("SYSTEM MEMORY SUMMARY:\n");
printf("mem_used:      %12d (%7dMB) [%3d%%] %s\n", $mem_used,  $mem_used  / (1024*1024), ($mem_used  / $mem_total) * 100, $info->{"mem_used"});
printf("mem_avail:   + %12d (%7dMB) [%3d%%] %s\n", $mem_avail, $mem_avail / (1024*1024), ($mem_avail / $mem_total) * 100, $info->{"mem_avail"});
printf("-------------- ------------ ----------- ------\n");
printf("mem_total:   = %12d (%7dMB) [100%%] %s\n", $mem_total, $mem_total / (1024*1024), $info->{"mem_total"});

--------------------------------------------------------------------
@
text
@d52 3
a54 3
            my $sysVMRamMax  = undef;
            my $sysVMRamUsed = undef;
            my $sysVMRamFree = undef;
d84 3
a86 3
            my $sysVMSwapMax  = undef;
            my $sysVMSwapUsed = undef;
            my $sysVMSwapFree = undef;
d114 1
a114 1
            my $sysVMActivity = undef;
d147 3
a149 3
            my $sysVMRamMax  = undef;
            my $sysVMRamUsed = undef;
            my $sysVMRamFree = undef;
d183 3
a185 3
            my $sysVMSwapMax  = undef;
            my $sysVMSwapUsed = undef;
            my $sysVMSwapFree = undef;
d208 1
a208 1
            my $sysVMActivity = undef;
d236 3
a238 3
            my $sysVMRamMax  = undef;
            my $sysVMRamUsed = undef;
            my $sysVMRamFree = undef;
d282 3
a284 3
            my $sysVMSwapMax  = undef;
            my $sysVMSwapUsed = undef;
            my $sysVMSwapFree = undef;
d293 2
a294 2
            my $tmpMax  = undef;
            my $tmpFree = undef;
d322 1
a322 1
            my $sysVMActivity = undef;
@


1.8
log
@some code refactoring and additional commenting before I try to fix the FreeBSD memory statistics
@
text
@d43 1
a43 1
        ##  sysVMRamMax   "/sbin/sysctl -n hw.physmem", convert bytes to MB
d45 1
a45 1
        ##  sysVMRamFree  "/usr/bin/vmstat", avm, convert KB to MB
d56 7
d64 1
a64 5
            my $out = $self->{-ctx}->{-sys}->run("/sbin/sysctl -n hw.physmem", "forever");
            my $raw = $out->{-stdout};
            if ($raw =~ m/^(\d+)$/) {
                $sysVMRamMax = int($1 / (1024*1024));
            }
d67 5
a71 10
            $out = $self->{-ctx}->{-sys}->run("/usr/bin/vmstat", "1m");
            $raw = $out->{-stdout};
            my $n2i = {};
            if ($raw =~ m/^[^\n]*\n *([^\n]*\bavm\b[^\n]*)\n *([^\n]*)\n$/s) {
                $n2i = &mkn2i(split(/\s+/, $1));
            }
            if (defined($n2i->{avm})) {
                my @@dat = split(/\s+/, $2);
                $sysVMRamFree = int(@@dat[$n2i->{avm}] / 1024);
            }
d75 1
a75 1
                $sysVMRamUsed = $sysVMRamMax - $sysVMRamFree;
d351 17
@


1.7
log
@More source tree cleanups and polishing, especially adding the GPL-based copyright header used inside OSSP packages
@
text
@d40 11
a50 4
        # sysVMRamMax   "/sbin/sysctl -n hw.physmem", convert bytes to MB
        # sysVMRamUsed  sysVMRamMax - sysVMRamFree
        # sysVMRamFree  "/usr/bin/vmstat", avm, convert KB to MB
        #
d56 3
a58 6
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat;

            #   sysVMRamMax
            $out = $self->{-ctx}->{-sys}->run("/sbin/sysctl -n hw.physmem", "forever");
            $raw = $out->{-stdout};
d60 1
a60 1
                $sysVMRamMax = int($1 / 1024 / 1024);
d63 1
a63 1
            #   sysVMRamFree
d66 1
a66 1
            $n2i = {};
d68 1
a68 1
                $n2i = &mkn2i(split / +/, $1);
d70 2
a71 2
            if (defined $n2i->{avm}) {
                @@dat = split(/ +/, $2);
d75 2
a76 2
            #   sysVMRamUsed
            if (defined $sysVMRamMax and defined $sysVMRamFree) {
d80 1
d85 1
a85 6

        # 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
        #
        if ($obj->{-name} =~ m/\.sysVMSwap(Max|Used|Free)$/) {
d90 4
a93 7
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat;

            #   sysVMSwapMax, sysVMSwapUsed
            $out = $self->{-ctx}->{-sys}->run("/usr/sbin/swapinfo -k", "1m");
            $raw = $out->{-stdout};
            $n2i = {};
d95 1
a95 1
                $n2i = &mkn2i(split / +/, $1);
d97 3
a99 3
            @@dat = split(/ +/, $2);
            if (defined $n2i->{_1K_blocks}) {
                $sysVMSwapMax  = int(@@dat[$n2i->{_1K_blocks}] / 1024)
d101 1
a101 1
            if (defined $n2i->{Used}) {
d105 2
a106 2
            #   sysVMSwapFree
            if (defined $sysVMSwapMax and defined $sysVMSwapUsed) {
d110 1
d115 1
a115 4

        # sysVMActivity "/usr/bin/vmstat", add pi and po column
        #
        if ($obj->{-name} =~ m/\.sysVMActivity$/) {
d118 3
a120 6
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat;

            $out = $self->{-ctx}->{-sys}->run("/usr/bin/vmstat", "1m");
            $raw = $out->{-stdout};
            $n2i = {};
d124 2
a125 2
            if (defined $n2i->{pi} and defined $n2i->{po}) {
                @@dat = split(/ +/, $3);
d132 16
a147 8
        # 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
        #
        # FIXME sysVMRamMax does not include the kernel and some of its structures so
        # FIXME             it is not pyhsical RAM, see dmesg | egrep '^Memory:'
        # FIXME /bin/cat is used here but could be replaced by native perl code to improve performance
        #
d153 4
a156 7
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat; my $tmp;

            #   sysVMRamMax, sysVMRamUsed
            $out = $self->{-ctx}->{-sys}->run("/bin/cat /proc/meminfo", "1m");
            $raw = $out->{-stdout};
            $tmp = {};
d161 1
a161 1
            if (defined $tmp->{MemTotal}) {
d164 8
a171 11

            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 );
d174 1
a174 1
            #   sysVMRamFree
d179 1
d184 1
a184 6

        # sysVMSwapMax  "/bin/cat /proc/meminfo", SwapTotal, convert KB to MB
        # sysVMSwapUsed sysVMSwapMax - sysVMSwapFree
        # sysVMSwapFree "/bin/cat /proc/meminfo", SwapFree, convert KB to MB
        #
        if ($obj->{-name} =~ m/\.sysVMSwap(Max|Used|Free)$/) {
d189 3
a191 6
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat;

            #   sysVMSwapMax, sysVMSwapFree
            $out = $self->{-ctx}->{-sys}->run("/bin/cat /proc/meminfo", "1m");
            $raw = $out->{-stdout};
d193 1
a193 1
                $sysVMSwapMax  = int($1 / 1024);
d199 2
a200 2
            #   sysVMSwapUsed
            if (defined $sysVMSwapMax and defined $sysVMSwapFree) {
d204 1
d209 1
a209 4

        # sysVMActivity "/usr/bin/vmstat", add si and so column
        #
        if ($obj->{-name} =~ m/\.sysVMActivity$/) {
d212 3
a214 6
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat;

            $out = $self->{-ctx}->{-sys}->run("/usr/bin/vmstat", "1m");
            $raw = $out->{-stdout};
            $n2i = {};
d216 1
a216 1
                $n2i = &mkn2i(split / +/, $1) if (not defined $n2i->{sr});
d218 2
a219 2
            if (defined $n2i->{si} and defined $n2i->{so}) {
                my @@dat = split(/ +/, $3);
d226 11
a236 4
        # sysVMRamMax   "/usr/platform/$arch/sbin/prtdiag", Memory size
        # sysVMRamUsed  sysVMRamMax - sysVMRamFree
        # sysVMRamFree  "/bin/pagesize" * "/bin/sar -r 1 1", freemem, convert bytes to MB
        #
d242 2
a243 2
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat; my $arch; my $pagesize; my $tmp;
d245 4
a248 5
            #   initialize arch; get or assume pagesize(1)
            $arch = $self->{-ctx}->{-platform}->arch();
            $out = $self->{-ctx}->{-sys}->run("/bin/pagesize", "forever");
            $raw = $out->{-stdout};
            $pagesize = 4096;
d253 1
a253 1
            #   sysVMRamMax
d260 1
a260 1
            #   sysVMRamFree
d263 1
a263 1
            $n2i = {};
d265 1
a265 1
                $n2i = &mkn2i(split / +/, $1);
d267 2
a268 2
            @@dat = split(/ +/, $2);
            if (defined $n2i->{freemem}) {
d271 1
a271 1
            $sysVMRamFree = int($tmp * $pagesize / 1024 / 1024) if (defined $tmp);
d273 2
a274 2
            #   sysVMRamUsed
            if (defined $sysVMRamMax and defined $sysVMRamFree) {
d278 1
d283 1
a283 6

        # 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
        #
        if ($obj->{-name} =~ m/\.sysVMSwap(Max|Used|Free)$/) {
d288 4
a291 7
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat; my $tmpMax; my $tmpFree;

            #   sysVMSwapMax, sysVMSwapFree
            $out = $self->{-ctx}->{-sys}->run("/usr/sbin/swap -l", "1m");
            $raw = $out->{-stdout};
            $n2i = {};
d293 1
a293 1
                $n2i = &mkn2i(split / +/, $1) if (scalar keys %$n2i == 0);
d295 3
a297 3
            $tmpMax = undef;
            $tmpFree = undef;
            foreach my $r (split /\n/, $2) {
d299 3
a301 3
                    @@dat = split(/ +/, $r);
                    if (defined $n2i->{blocks}) {
                        $tmpMax  = 0 if (not defined $tmpMax);
d304 2
a305 2
                    if (defined $n2i->{free}) {
                        $tmpFree = 0 if (not defined $tmpFree);
d310 2
a311 2
            $sysVMSwapMax  = int($tmpMax  * 512 / 1024 / 1024) if (defined $tmpMax);
            $sysVMSwapFree = int($tmpFree * 512 / 1024 / 1024) if (defined $tmpFree);
d313 2
a314 2
            #   sysVMSwapUsed
            if (defined $sysVMSwapMax and defined $sysVMSwapFree) {
d318 1
d323 1
a323 4

        # sysVMActivity "/bin/vmstat", sr column
        #
        if ($obj->{-name} =~ m/\.sysVMActivity$/) {
d326 3
a328 6
            #   local workspace
            my $out; my $raw; my $n2i; my @@dat;

            $out = $self->{-ctx}->{-sys}->run("/bin/vmstat", "1m");
            $raw = $out->{-stdout};
            $n2i = {};
d330 1
a330 1
                $n2i = &mkn2i(split / +/, $1) if (not defined $n2i->{sr});
d333 1
a333 1
                @@dat = split(/ +/, $2);
d342 1
a342 1
# name to index
@


1.6
log
@fix local variable warning
@
text
@d2 1
a2 1
##  snmpdx -- SNMP Daemon Extension
d7 2
a8 4
##  Permission to use, copy, modify, and distribute this software for
##  any purpose with or without fee is hereby granted, provided that
##  the above copyright notice and this permission notice appear in all
##  copies.
d10 4
a13 12
##  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
##  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
##  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
##  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
##  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
##  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
##  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
##  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
##  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
##  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
##  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
##  SUCH DAMAGE.
d15 11
a25 1
##  sysVM: System Virtual Memory
@


1.5
log
@variable name, namespace and coding style cleanup
@
text
@d310 1
a310 1
            my $n2i = {};
@


1.4
log
@sysVM for FreeBSD
@
text
@d49 3
d53 5
a57 3
            my $out = $self->{-ctx}->{-sys}->run("/sbin/sysctl -n hw.physmem", "forever");
            my $raw = $out->{-stdout};
            $sysVMRamMax = int($1 / 1024 / 1024) if ($raw =~ m/^(\d+)$/);
d60 3
a62 3
            my $out = $self->{-ctx}->{-sys}->run("/usr/bin/vmstat", "1m");
            my $raw = $out->{-stdout};
            my $i_vmstat = {};
d64 1
a64 1
                $i_vmstat = &n2i(split / +/, $1) if (not defined $i_vmstat->{sr});
d66 3
a68 3
            if (defined $i_vmstat->{avm}) {
                my @@data = split(/ +/, $2);
                $sysVMRamFree = int(@@data[$i_vmstat->{avm}] / 1024);
d90 3
d94 3
a96 3
            my $out = $self->{-ctx}->{-sys}->run("/usr/sbin/swapinfo -k", "1m");
            my $raw = $out->{-stdout};
            my $i_swapl = {};
d98 8
a105 1
                $i_swapl = &n2i(split / +/, $1) if (scalar keys %$i_swapl == 0);
a106 3
            @@data = split(/ +/, $2);
            $sysVMSwapMax  = int(@@data[$i_swapl->{_1K_blocks}] / 1024) if (defined $i_swapl->{_1K_blocks});
            $sysVMSwapUsed = int(@@data[$i_swapl->{Used}]       / 1024) if (defined $i_swapl->{Used});
d121 8
a128 4
            my $value = undef;
            my $out = $self->{-ctx}->{-sys}->run("/usr/bin/vmstat", "1m");
            my $raw = $out->{-stdout};
            my $i_vmstat = {};
d130 1
a130 1
                $i_vmstat = &n2i(split / +/, $1) if (not defined $i_vmstat->{sr});
d132 3
a134 3
            if (defined $i_vmstat->{pi} and defined $i_vmstat->{po}) {
                my @@data = split(/ +/, $3);
                $value = @@data[$i_vmstat->{pi}] + @@data[$i_vmstat->{po}];
d136 1
a136 1
            $obj->{-value} = $value;
d153 3
d157 9
a165 9
            my $out = $self->{-ctx}->{-sys}->run("/bin/cat /proc/meminfo", "1m");
            my $raw = $out->{-stdout};
            my $i_meminfo = {};
            $i_meminfo->{MemTotal} = int($1 / 1024) if ($raw =~ m/\nMemTotal:[^\n]*\b(\d+)\b[^\n]*kB\n/s);
            $i_meminfo->{Buffers}  = int($1 / 1024) if ($raw =~ m/\nBuffers:[^\n]*\b(\d+)\b[^\n]*kB\n/s);
            $i_meminfo->{Cached}   = int($1 / 1024) if ($raw =~ m/\nCached:[^\n]*\b(\d+)\b[^\n]*kB\n/s);
            $i_meminfo->{MemFree}  = int($1 / 1024) if ($raw =~ m/\nMemFree:[^\n]*\b(\d+)\b[^\n]*kB\n/s);
            if (defined $i_meminfo->{MemTotal}) {
                $sysVMRamMax = $i_meminfo->{MemTotal};
d168 4
a171 4
            if (    defined $i_meminfo->{MemTotal}
                and defined $i_meminfo->{Buffers}
                and defined $i_meminfo->{Cached}
                and defined $i_meminfo->{MemFree}
d173 5
a177 4
                $sysVMRamUsed  =   $i_meminfo->{MemTotal} 
                                 - $i_meminfo->{Buffers} 
                                 - $i_meminfo->{Cached} 
                                 - $i_meminfo->{MemFree};
d199 3
d203 2
a204 3
            my $out = $self->{-ctx}->{-sys}->run("/bin/cat /proc/meminfo", "1m"); #FIXME this could be done in perl natively to improve performance
            my $raw = $out->{-stdout};
            my $i_swapl = {};
d225 8
a232 4
            my $value = undef;
            my $out = $self->{-ctx}->{-sys}->run("/usr/bin/vmstat", "1m");
            my $raw = $out->{-stdout};
            my $i_vmstat = {};
d234 1
a234 1
                $i_vmstat = &n2i(split / +/, $1) if (not defined $i_vmstat->{sr});
d236 3
a238 3
            if (defined $i_vmstat->{si} and defined $i_vmstat->{so}) {
                my @@data = split(/ +/, $3);
                $value = @@data[$i_vmstat->{si}] + @@data[$i_vmstat->{so}];
d240 1
a240 1
            $obj->{-value} = $value;
d253 3
d257 7
a263 3
            my $arch = $self->{-ctx}->{-platform}->arch();
            my $out = $self->{-ctx}->{-sys}->run("/bin/pagesize", "forever");
            my $pagesize = $out->{-stdout} || 4096;
d266 2
a267 2
            my $out = $self->{-ctx}->{-sys}->run("/usr/platform/$arch/sbin/prtdiag -v", "1m");
            my $raw = $out->{-stdout};
d273 3
a275 3
            my $out = $self->{-ctx}->{-sys}->run("/bin/sar -r 1 1", "1m");
            my $raw = $out->{-stdout};
            my $i_sarr = {};
d277 1
a277 1
                $i_sarr = &n2i(split / +/, $1) if (scalar keys %$i_sarr == 0);
d279 3
a281 4
            @@data = split(/ +/, $2);
            if (defined $i_sarr->{freemem}) {
                $sysVMRamFree  = 0 if (not defined $sysVMRamFree);
                $sysVMRamFree  += @@data[$i_sarr->{freemem}];
d283 1
a283 1
            $sysVMRamFree = int($sysVMRamFree * $pagesize / 1024 / 1024) if (defined $sysVMRamFree);
d304 3
d308 3
a310 3
            my $out = $self->{-ctx}->{-sys}->run("/usr/sbin/swap -l", "1m");
            my $raw = $out->{-stdout};
            my $i_swapl = {};
d312 1
a312 1
                $i_swapl = &n2i(split / +/, $1) if (scalar keys %$i_swapl == 0);
d314 2
d318 4
a321 4
                    @@data = split(/ +/, $r);
                    if (defined $i_swapl->{blocks}) {
                        $sysVMSwapMax  = 0 if (not defined $sysVMSwapMax);
                        $sysVMSwapMax  += @@data[$i_swapl->{blocks}];
d323 3
a325 3
                    if (defined $i_swapl->{free}) {
                        $sysVMSwapFree = 0 if (not defined $sysVMSwapFree);
                        $sysVMSwapFree += @@data[$i_swapl->{free}];
d329 2
a330 2
            $sysVMSwapMax  = int($sysVMSwapMax  * 512 / 1024 / 1024) if (defined $sysVMSwapMax);
            $sysVMSwapFree = int($sysVMSwapFree * 512 / 1024 / 1024) if (defined $sysVMSwapFree);
d345 8
a352 4
            my $value = undef;
            my $out = $self->{-ctx}->{-sys}->run("/bin/vmstat", "1m");
            my $raw = $out->{-stdout};
            my $i_vmstat = {};
d354 1
a354 1
                $i_vmstat = &n2i(split / +/, $1) if (not defined $i_vmstat->{sr});
d356 3
a358 3
            if (defined $i_vmstat->{sr}) {
                my @@data = split(/ +/, $2);
                $value = @@data[$i_vmstat->{sr}];
d360 1
a360 1
            $obj->{-value} = $value;
d367 1
a367 1
sub n2i ($) {
@


1.3
log
@sysVM for Linux
@
text
@d40 38
a77 5
        # sysVMRamMax   sysctl -n hw.physmem
        # sysVMRamUsed  vmstat: avm
        # sysVMRamFree  sysVMRamMax - sysVMRamUsed
        # sysVMSwapMax  swapinfo -k | tail -1
        # sysVMSwapUsed swapinfo -k | tail -1
d79 43
a121 1
        # sysVMActivity vmstat: pi+po
a141 1
                $self->{-ctx}->{-log}->printf(1, "DEBUG: 1=$1\n");
a145 1
                $self->{-ctx}->{-log}->printf(1, "DEBUG: MemTotal=%s\n", $i_meminfo->{MemTotal});
d331 2
@


1.2
log
@sysVM for SunOS
@
text
@d25 1
a25 1
##  sysVM: System Vritual Memory
d49 2
a50 2
        # sysVMRamMax   /proc/meminfo:MemTotal
        # sysVMRamUsed  /proc/meminfo:MemTotal-Buffers-Cached-MemFree
d52 46
a97 1
        # sysVMSwapMax  /proc/meminfo:SwapTotal
d99 44
a142 1
        # sysVMSwapFree /proc/meminfo:SwapFree
@


1.1
log
@merge RAM and Swap into sysVM and start initial probe for it
@
text
@d39 122
a160 13
    #               FreeBSD                Linux                                          Solaris
    #Mem Total      sysctl -n hw.physmem   /proc/meminfo:MemTotal                         /usr/platform/`uname -i`/sbin/prtdiag:Memory size
    #Mem Used       vmstat: avm            /proc/meminfo:MemTotal-Buffers-Cached-MemFree  "total" - "free"
    #Mem Free       "total"-"used"         "total"-"used"                                 sar -r  1 1: freemem * `pagesize`
    #Mem Status     N.A.                   N.A.                                           /usr/platform/`uname -i`/sbin/prtdiag:Status col. 
    #
    #Swap Total     swapinfo -k | tail -1  /proc/meminfo:SwapTotal                        swap -l: blocks * 512 (accumulate)
    #Swap Used      swapinfo -k | tail -1  "total" - "free"                               "total"-"free"
    #Swap Free      "total"-"used"         /proc/meminfo:SwapFree                         swap -l: free * 512 (accumulate)
    #
    #Mem/Swap       vmstat: pi+po          vmstat: si+so                                  vmstat: sr
    #Page Activity
   
d162 11
@