Munin contributed plugins

#!/usr/bin/python

#

#    Copyright (C) 2011,2012  Andreas Thienemann <andreas@bawue.net>

#

#    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 3 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 program.  If not, see <http://www.gnu.org/licenses/>.

#

"""

=head1 NAME

freeipmi_ - Munin plugin to retreive temperature and fan speed measurements

from a local machine via IPMI.

=head1 APPLICABLE SYSTEMS

All machines with an IPMI capable baseboard management controller.

On most supported systems this plugin works nearly out of the box as long as

both Python and the freeipmi binaries in a semi-recent version are installed.

If the machine works out of the box can be tested by calling bmc-info.

If there's text output, a bmc card was detected. If there's an entry for

"Sensor Device" visible in the "Additional Device Support" entry you're good.

If you get a "ipmi_cmd_get_device_id: driver timeout" message you have most

likely no bmc to query.

In certain cases however bmc-info will just seem to hang for quite some time.

In this case, autodetection does not work because the smbios table has

incorrect information. One system known to experience this problem is the

HP Proliant Microserver.

Adding env.freeipmi_args "--no-probing --driver-type=KCS --driver-address=0xca2 --register-spacing=1"

to the munin plugin configuration will make the plugin work. This is the

specific line for the HP Proliant Microserver mentioned above. Your mileage

may vary.

Basic configuration for every system is that the plugin needs to be called as root.

Add the following to your /etc/munin/plugin-conf.d/freeipmi:

 [freeipmi_*]

 user root

=head1 INTERPRETATION

The plugin shows the temperature in Celsius or the fanspeed in rotations per minute.

=head1 MAGIC MARKERS

  #%# family=contrib

  #%# capabilities=autoconf suggest

=head1 VERSION

0.0.1

=head1 BUGS

Only local support for now. Remote could be hacked in via freeipmi_args for now.

Andreas Thienemann <andreas@bawue.net>

GPLv3+

"""

import subprocess

import sys

import os

import re

import pprint

# Parse some environment variables

if os.getenv("freeipmi_args") is not None:

    freeipmi_args = " %s" % (os.getenv("freeipmi_args"))

else:

    freeipmi_args = ""

# We are a wildcard plugin, figure out whether we are called for temp or fan

if sys.argv[0].split("_")[1] == "temp":

    mode = "Temperature"

elif sys.argv[0].split("_")[1] == "fan":

    mode = "Fan"

else:

    mode = None

def whereis(prog):

    """Check if prog can be found in the path and if yes, return the full pathname"""

    prog = os.path.basename(prog)

    for dir in os.getenv("PATH").split(":"):

        for root, dirs, files in os.walk(dir):

            if prog in files:

                return os.path.join(dir, prog)

    return None

def normalize_sensor(name):

    name = name.lower().replace("-","M").replace("+","P")

    name = re.sub("[^a-z0-9A-Z]","_", name)

    return name

# Code sniplet from Philipp Keller

# http://code.pui.ch/2007/02/19/set-timeout-for-a-shell-command-in-python/

def timeout_command(command, timeout):

    """call shell-command and either return its output or kill it

    if it doesn't normally exit within timeout seconds and return None"""

    import subprocess, datetime, os, time, signal

    start = datetime.datetime.now()

    process = subprocess.Popen(command.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)

    while process.poll() is None:

        time.sleep(0.1)

        now = datetime.datetime.now()

        if (now - start).seconds> timeout:

            os.kill(process.pid, signal.SIGKILL)

            os.waitpid(-1, os.WNOHANG)

            return None

    return process.stdout.read()

def bmc_detect():

    """Check whether there's a baseboard management controller we can query."""

    if whereis("bmc-info") is None:

        print "no (bmc-info not found in path. Please install FreeIPMI.)"

        sys.exit(0)

    else:

        out = timeout_command("bmc-info%s" % (freeipmi_args), 2)

        if out is not None and "[Sensor Device]" in out:

            print "yes"

            sys.exit(0)

        else:

            print "no (no supported bmc found)"

            sys.exit(0)

def read_sensors():

    """Return all sensor data as a dict"""

    out = timeout_command("ipmi-sensors --verbose%s" % (freeipmi_args), 2)

    sensors = dict()

    sensor = dict()

    sensor_id = None

    for line in out.split("\n"):

        if ":" in line:

            k,v = line.split(": ")

            if k == "Record ID":

                sensor = dict()

                sensor_id = int(v)

                sensor[k] = v

            else:

                sensor[k] = v

        else:

            sensors[sensor_id] = sensor

    return sensors

def print_config():

    """Return configuration arguments for munin"""

    print "graph_title FreeIPMI Sensors: %s" % (mode)

    if mode == "Fan":

        print "graph_vlabel RPM"

        print "graph_info This graph shows the RPMs of the fans as reported by IPMI"

    elif mode == "Temperature":

        print "graph_vlabel Degrees C"

        print "graph_info This graph shows the temperatures as reported by IPMI"

    print "graph_category sensors"

    sensors = read_sensors()

    for id in sorted(sensors):

        if sensors[id]["Group Name"] == mode:

            label = normalize_sensor(sensors[id]["Sensor Name"])

            for n in ["Normal Max.", "Normal Min.", "Sensor Reading", "Lower Critical Threshold", "Upper Critical Threshold", "Lower Non-Critical Threshold", "Upper Non-Critical Threshold"]:

                sensors[id][n] = sensors[id][n].replace("NA","")

                sensors[id][n] = sensors[id][n].split('.')[0]

            print "%s.label %s" % (label, label)

            print "%s.warning %s:%s" % (label, sensors[id]["Lower Non-Critical Threshold"], sensors[id]["Upper Non-Critical Threshold"])

            print "%s.critical %s:%s" % (label, sensors[id]["Lower Critical Threshold"], sensors[id]["Upper Critical Threshold"])

            print "%s.graph_args --base 1000 -l 0" % (label)

            print "%s.graph_scale no" % (label)

#            pprint.pprint(sensors[id])

    sys.exit(0)

def fetch():

    sensors = read_sensors()

    for id in sorted(sensors):

        if sensors[id]["Group Name"] == mode:

            label = normalize_sensor(sensors[id]["Sensor Name"])

            print "%s.value %s" % (label, sensors[id]["Sensor Reading"].split(".")[0])

    sys.exit(0)

if "config" in sys.argv[1:]:

    print_config()

elif "autoconf" in sys.argv[1:]:

    bmc_detect()

elif "suggest" in sys.argv[1:]:

    sensors = read_sensors()

    fan, temperature = [0, 0]

    for id in sensors:

        if sensors[id]["Group Name"] == "Fan":

            fan += 1

        elif sensors[id]["Group Name"] == "Temperature":

            temperature += 1

    if fan > 0:

        print "fan"

    if temperature > 0:

        print "temp"

    sys.exit(0)

else:

    fetch()

#!/usr/bin/env python

from commands import getstatusoutput as gso

def safe(s):

    s=s.replace("-", "_")

    s=s.replace(" ", "_")

    s=s.replace(".", "_")

    return s

def config(data,title):

    for i in data:

        print "%s.label %s"%(safe(i[0]), i[0])

        # check for non-critical thresholds

        if i[6] != 'na':

            if i[7] != 'na':

                warning = "%s:%s"%(i[6],i[7])

            else:

                warning = "%s:"%i[6]

        else:

            if i[7] != 'na':

                warning = "%s"%i[7]

            else:

                warning = ""

        if warning:    

            print "%s.warning %s"%(safe(i[0]),warning)

        # check for critical thresholds

        if i[5] == 'na':

            i[5] == i[4] # N/A, so see if there is a non-recoverable threshold

        if i[8] == 'na':

            i[8] == i[9] # N/A, so see if there is a non-recoverable threshold

        if i[5] != 'na':

            if i[8] != 'na':

                critical = "%s:%s"%(i[5],i[8])

            else:

                critical = "%s:"%i[5]

        else:

            if i[8] != 'na':

                critical = "%s"%i[8]

            else:

                critical = ""

        if critical:    

            print "%s.critical %s"%(safe(i[0]),critical)

    print "graph_title %s"%title

    if title == "Voltages":

        print "graph_args -X 0 --logarithmic -l 1 -u 15"

        #print "graph_args --base 1000 --logarithmic"

    else:

        print "graph_args -l 0"

    print "graph_vlabel %s"%i[2]

    print "graph_period minute"

    print "graph_category IPMI"

def get_data():

    import sys

    category = sys.argv[0].split("_",1)[1]

    data = []

    if category =="Fans":

        ids = ("Fan 1 Tach", "Fan 2 Tach", "Fan 3 Tach",

               "Fan 4 Tach", "Fan 5 Tach", "Fan 6 Tach",)

        title = "Fan Speed"

    elif category == "Temperature":

        ids = ("Ambient Temp", "Memory Temp",)

        title = "Temperatures"

    elif category == "Voltage":

        ids = ("Planar 1.5V", "Planar 1.8V",

              "Planar 3.3V", "Planar 5V", "Planar 12V",

              "Planar VBAT", "CPU 1 VCore", "CPU 2 VCore",)

        title = "Voltages"

    status, output = gso("ipmitool sensor")

    for row in output.split("\n"):

        items = map(str.strip,row.split("|"))

        field,value,units,status,lower_nonrecoverable,lower_critical,lower_non_critical,upper_non_critical,upper_critical,upper_nonrecoverable=items

        if field in ids:

            if value == 'na': continue

            data.append(items)

    return data,title

def sample(data):

    for i in data:

        print "%s.value %s"%(safe(i[0]),i[1])

def main():

    import sys

    data,title = get_data()

    if 'config' in sys.argv:

        return config(data,title)

    sample(data)

if __name__ == '__main__':

    main()

#! /usr/bin/perl -w

#

# This plugin will graph the chassis fan speed on a Dell PowerEdge Server

# via the ipmi-sensors tool. It has been tested on the following chassis:

# 

#   PE1850

#

# To enable: 

#

#   ln -s /usr/share/munin/plugins/ipmi-fans /etc/munin/plugins/ipmi-fans

#

# Configuration parameters for /etc/munin/plugin-conf.d/munin-node

#

# [ipmi_fans]

#   user 	 - User that has permissions to run the omreport binary

#   env.omreport - Path to the omreport binary

#

# Parameters:

#

#   config

#   autoconf

#

# Author: Alexx Roche <munin-ipmi-plugin@alexx.net>

# Built on the work of Justin Shepherd <galstrom21@gmail.com>

# Revision: 2.1  2011/01/10

#

#%# family=auto

#%# capabilities=autoconf

use strict;

my $IPMI;

if(-f "/usr/sbin/ipmi-sensors"){ $IPMI='/usr/sbin/ipmi-sensors'; }

unless($IPMI){

   $IPMI = `which ipmi-sensors 2>/dev/null|sed 's/.*no ipmi-sensors//'`; 

   #$IPMI = `echo -n \$(which ipmi-sensors)`;

}

chomp($IPMI);

unless($IPMI){ exit 1; }

if ($ARGV[0] && $ARGV[0] eq "autoconf"){

    if (-f $IPMI){

	print "yes\n";

    }else{

	print "no ($IPMI does not exist)\n";

	exit(1);

    }

}else{

        my $cmd = "$IPMI --verbose --sensors=\"\$(echo \$($IPMI |grep FAN|sed 's/:.*//'))\"";

	#if ($ARGV[0] eq 'cmd'){ print $cmd; exit;};

        my @result = `$cmd`;

        my (%val, $index);

	$index=0;

	my $count=0;

	#Four of these seem to be unlabled, I'm going to guess that they are the CPU(s) and HDD(s)

	my @unknown = ('HDD0','HDD1','CPU0','CPU1');

        foreach my $line (@result) {

                $line =~ s/\s+/ /g;

                $line =~ s/\s$//g;

                if(!$line || $line eq ""){

			$index++;

			next;

		}

                my ($key, $val) = split(/\: /, $line);

		unless($key){

		#	$index++;

	#		next;

		}

                if($key eq 'Sensor Name'){

		    if($val eq 'Temp'){

			$val = $unknown[$count];

			$count++;

		    }

                    #my @data = split / /, $val;

		    #$data[2]=~s/^\(//;

		    #$data[2]=~s/\)$//;

		    	#my($warn,$crit) = split/\//, $data[2];

                   $val{$index}{'Probe Name'} = "$val";

		}elsif($key eq 'Upper Critical Threshold'){

		    $val=~s/ .*$//;

		    next unless $val=~m/^\d+\.\d+$/;

                    $val{$index}{'Critical Threshold'} = "$val";

		}elsif($key eq 'Normal Max.'){

		    $val=~s/ .*//;

                    $val{$index}{'Warning Threshold'} = $val;

                }elsif($key eq 'Sensor Reading'){

		    $val=~s/ .*//;

                    $val{$index}{'Reading'} = $val;

		}elsif($key eq 'Sensor Max. Reading' && !$val{$index}{'Critical Threshold'}){

		    $val=~s/ .*$//;

                    $val{$index}{'Critical Threshold'} = "$val";

		}

        }

        if ($ARGV[0] && $ARGV[0] eq "config") {

                print "graph_title IPMI - Fan Speeds\n";

                print "graph_args --base 1000 -l 0\n";

                print "graph_vlabel Speed in RPM\n";

                print "graph_category Sensors\n";

                foreach my $j (sort keys %val) {

                        print "probe_$j\.label $val{$j}{'Probe Name'}\n";

                        print "probe_$j\.warning $val{$j}{'Warning Threshold'}\n";

                        print "probe_$j\.critical $val{$j}{'Critical Threshold'}\n";

                }

        }else{

             foreach my $j (sort keys %val) {

                if($val{$j}{'Reading'}){

		   print "probe_$j.value $val{$j}{'Reading'}\n";

		}

             }

        }

}

exit(0);

#!/usr/bin/perl -w

#

# IPMI data gathering for munin.

# 

# Author: 2008 Benjamin Pineau <ben.pineau@gmail.com>

# This work is hereby released into the Public Domain. 

# To view a copy of the public domain dedication, visit

# http://creativecommons.org/licenses/publicdomain/

#

# Requirements :

#

#   - ipmitool command line utility (and kernel drivers)

#   - access rights to /dev/ipmi0 device (ie, root privileges

#     can be configured in /etc/munin/plugin-conf.d/munin-node)

# 

# Parameters supported:

#

#   config

#   autoconf

#

# Setup :

#

#   ipmitool sdr || echo "please load IPMI kernel modules"

#   cp ipmi_sdr_ /usr/share/munin/plugins/

#   chmod +x /usr/share/munin/plugins/ipmi_sdr_

#   ln -s /usr/share/munin/plugins/ipmi_sdr_ /etc/munin/plugins/ipmi_sdr_fan

#   ln -s /usr/share/munin/plugins/ipmi_sdr_ /etc/munin/plugins/ipmi_sdr_current

#   ln -s /usr/share/munin/plugins/ipmi_sdr_ /etc/munin/plugins/ipmi_sdr_voltage

#   ln -s /usr/share/munin/plugins/ipmi_sdr_ /etc/munin/plugins/ipmi_sdr_temperature

#   echo -e "\n[ipmi_sdr*]\nuser root\ntimeout 15\n" >> /etc/munin/plugin-conf.d/munin-node

#   /etc/init.d/munin-node restart

#

# Magic markers

#%# family=auto

#%# capabilities=autoconf

use strict;

use warnings;

$ENV{'LANG'} = 'C';

$ENV{'LC_ALL'} = 'C';

my $ipmidump = $ENV{'ipmidump'} || '/var/lib/munin/plugin-state/ipmi_sdr';

my $ipmitool = $ENV{'ipmitool'} || 'ipmitool';

my $drefresh = $ENV{'drefresh'} || 86400;

my %sensors;

my $desc = {

    'fan'         => {

        'graph_title'  => 'Fans rotations per minute',

        'graph_vlabel' => 'RPM',

        'graph_info'   => 'Fans rotations per minute',

    },

    'voltage'     => {

        'graph_title'  => 'Electrical tensions',

        'graph_vlabel' => 'Volts',

        'graph_info'   => 'Electrical tensions',

    },

    'temperature' => {

        'graph_title'  => 'Hardware temperatures',

        'graph_vlabel' => 'Degrees Celsius',

        'graph_info'   => 'Hardware temperature sensors output',

    },

    'current'     => {

        'graph_title'  => 'Hardware power consumption',

        'graph_vlabel' => 'Watts or Amperes',

        'graph_info'   => 'Hardware power consumption',

    },

};

my $stype = $0 =~ /.*ipmi_sdr_(\w+)$/ ? lc($1) : 'temperature';

if (!defined($desc->{"$stype"})) {

    printf STDERR "Unknown sensor type : '$stype'. Aborting.\n";

    exit 1;

}

sub strip_spaces($) {

    (my $s = shift) =~ s/^\s*(.*?)\s*\n?$/$1/;

    return $s;

}

sub normalize_name($) {

    (my $l = lc(strip_spaces(shift))) =~ tr/\t ./_/;

    return $l;

}

sub sdrlist_parse(@) {

    foreach(@_) {

        next unless /^([^\|]+)\s*\|\s*(\w+)\s*\|[^\|]+\|[^\|]+\|\s*([\d\.]+)\s+/;

        $sensors{$_}{"name"}  = strip_spaces($1);

        $sensors{$_}{"value"} = strip_spaces($3);

        $sensors{$_}{"label"} = normalize_name($1) . normalize_name($2);

    }

}

if (defined $ARGV[0] and $ARGV[0] eq 'autoconf') {

    `$ipmitool help 2> /dev/null`;

    if ($?) {

        print "no ($ipmitool not found)";

        exit 1;

    }

    `$ipmitool sdr dump $ipmidump`;

    if ($?) {

        printf "no (ipmitool sdr dump returned code %d)\n", $? >> 8;

        exit 1;

    }

    `$ipmitool sdr type $stype -S $ipmidump`;

    if ($?) {

        print "no (ipmitool didn't found any sensor of type ";

        printf "'$stype', returned code %d)\n", $? >> 8;

        exit 1;

    }

    print "yes\n";

    exit 0;

}

# "ipmitool dump" dumps speeds up data retreival big time, by avoiding

# IPMI sensors autodiscovery. This only caches sensors names/types/ids 

# (not values/datas), so we can have a very long cache lifetime policy.

if (-f $ipmidump) {

    unlink($ipmidump) if (time - (stat($ipmidump))[9] >= $drefresh);

}

unless (-f $ipmidump) {

    `$ipmitool sdr dump $ipmidump` || die $!;

}

(my @dt = `$ipmitool sdr type $stype -S $ipmidump`) || die $!;

sdrlist_parse(@dt);

if (defined($ARGV[0]) && $ARGV[0] eq "config") {

    print "graph_category system\n";

    print "graph_title "  . $desc->{$stype}->{"graph_title"}  . "\n";

    print "graph_vlabel " . $desc->{$stype}->{"graph_vlabel"} . "\n";

    print "graph_info "   . $desc->{$stype}->{"graph_info"}   . "\n";

    foreach my $v (values(%sensors)) {

        print $v->{"label"} . ".label " . $v->{"name"} . "\n";

        print $v->{"label"} . ".type GAUGE\n";

    }

    exit 0;

}

foreach my $v (values(%sensors)) {

    print $v->{"label"} . ".value " . $v->{"value"} . "\n";

}

#! /usr/bin/perl -w

#

# This plugin will graph the chassis temp sensors on a Dell PowerEdge Server

# via the ipmi-sensors tool. It has been tested on the following chassis:

# 

#   PE1850

#

# To enable: 

#

#   ln -s /usr/share/munin/plugins/ipmi-therm /etc/munin/plugins/ipmi-therm

#

# Configuration parameters for /etc/munin/plugin-conf.d/munin-node

#

# [ipmi_therm]

#   user 	 - User that has permissions to run ipmi-sensors

#   env.category sensors

#

# Parameters:

#

#   config

#   autoconf

#

# Author: Alexx Roche <munin-ipmi-plugin@alexx.net>

# Built on the work of Justin Shepherd <galstrom21@gmail.com>

# Revision: 1.3  2011/01/10

#

#%# family=auto

#%# capabilities=autoconf

use strict;

my $IPMI;

if(-f "/usr/sbin/ipmi-sensors"){ $IPMI='/usr/sbin/ipmi-sensors'; }

unless($IPMI){

   $IPMI = `which ipmi-sensors 2>/dev/null|sed 's/.*no ipmi-sensors//'`; 

   #$IPMI = `echo -n \$(which ipmi-sensors)`;

}

chomp($IPMI);

unless($IPMI){ exit 1; }

if ($ARGV[0] && $ARGV[0] eq "autoconf"){

    if (-f $IPMI){

	print "yes\n";

    }else{

	print "no ($IPMI does not exist)\n";

	exit(1);

    }

}else{

        my $cmd = "$IPMI|grep Temp";

        my @result = `$cmd`;

        my (%val, $index);

	$index=0;

	my $count=0;

	#Four of these seem to be unlabled, I'm going to guess that they are the CPU(s) and HDD(s)

	my @unknown = ('CPU0','CPU1','HDD0','HDD1');

        foreach my $line (@result) {

                $line =~ s/\s+/ /g;

                $line =~ s/\s$//g;

                next if ($line eq "");

                my ($list, $field, $value, $state) = split(/\: /, $line);

		#print "L: $list F: $field V: $value S: $state\n";

                if($field=~m/^(Temp|Ambient|Planar|Riser)/) {

		    my $f=$1;

		    if($f eq 'Temp'){

			$f = $unknown[$count];

			$count++;

		    }

                    my @data = split / /, $value;

		    $data[2]=~s/^\(//;

		    $data[2]=~s/\)$//;

		    if($f){

		    	my($warn,$crit) = split/\//, $data[2];

			unless($warn=~m/\d+/){ $warn = 0; }

			unless($crit=~m/\d+/){ $crit = 200; }

                    	$val{$index}{'Probe Name'} = "$f";

                    	$val{$index}{'Reading'} = "$data[0]";

                    	$val{$index}{'Warning Threshold'} = ($crit - $warn);

                    	$val{$index}{'Critical Threshold'} = "$crit";

		  	$index++;

		    }

                }

        }

        if ($ARGV[0] && $ARGV[0] eq "config") {

                print "graph_title IPMI sensors - Temperature Probes\n";

                print "graph_args --base 1000 -l 0\n";

                print "graph_vlabel Temperature in Celsius\n";

                print "graph_category Sensors\n";

                foreach my $j (sort keys %val) {

                        print "probe_$j\.label $val{$j}{'Probe Name'}\n";

                        print "probe_$j\.warning $val{$j}{'Warning Threshold'}\n";

                        print "probe_$j\.critical $val{$j}{'Critical Threshold'}\n";

                }

        }else{

             foreach my $j (sort keys %val) {

                if($val{$j}{'Reading'}){

		   print "probe_$j.value $val{$j}{'Reading'}\n";

		}

             }

        }

}

exit(0);

#!/usr/bin/perl -w

#

# ipmisens3

# Munin plugin to read IPMI sensor data

# Zoltan HERPAI (c) 2009 <wigyori@uid0.hu>

#

#	Symlink this script into your /etc/munin/plugins directory in the

#	following way:

#

#	ipmisens2_[machine]_[sensors]

#

#	Supported machines:

#	- Asus K8N-LR: asmb2 (temp, volt, fan)

#	- Dell DCS-XS23: xs23 (temp, volt, fan)

#	- Dell M610 blade: m610 (temp)

#	- Dell PowerEdge 2650: pe2650 (temp, volt, fan)

#	- Fujitsu TX120: tx120 (temp, volt, fan)

#	- HP Proliant ML350G5: proliantg5 (temp)

#	- HP Proliant DL380G5: proliantg5 (temp)

#	- HP Proliant DL385G1: hpasmcli (temp, fan)

#	- IBM HS21/HS22/Dataplex DX360: ibmhsxx (volt)

#	- IBM LS20/LS21: ibmlsxx (temp, volt)

#	- IBM LS41: ibmls4x (temp, volt)

#	- IBM x3200/x3550: ibmx3xx0 (temp, volt, fan)

#	- IBM x346: x346 (temp, volt, fan)

#	- Intel SHG2 mainboard: shg2 (temp, volt, fan)

#	- Sun x2100/2100m2/2200/2200m2: x2100 (temp, volt, fan)

#	- Sun x2250: x2250 (temp, volt, fan)

#	- Sun x2270: x2270 (temp, volt, fan)

#	- Sun x4100/4100m2/4200/4200m2/4600: x4x00 (temp, volt, fan)

#	- Sun x4150: x4150 (temp, volt, fan)

#	- Sun V20z (V40z?): v20z (temp, volt, fan)

#	- Supermicro X7DB8/X7DCL: aocipmi20e (temp, volt, fan)

#	- Supermicro X8DT6/X8DTT-F: hermon (temp, volt, fan)

#	- Verari VB1205XM: vb1205 (temp, volt)

#

#	Supported but not tested:

#	- HP DL145G2: asmb2 (temp, volt, fan)

#

#	Notes:

#	- hpasmcli machtype requires HP's hpasmcli package, and the additional

#	  hpasmcliget script.

#

# Outputs submitted by:

# 	- Zoltan LAJBER <lajbi@lajli.gau.hu>

#	- Gergely MADARASZ <gorgo@broadband.hu>

#	- Louis van Belle <louis@van-belle.nl>

#	- Andras GOT <andrej@antiszoc.hu>

#	- Andras KORN <korn@chardonnay.math.bme.hu>

#	- Tamas TEVESZ <ice@extreme.hu>

#	- Gergely TOMKA <gergely@tomka.hu>

#	- Gabor SZOLLOSI <dev@localnet.hu>

#	- Reka KAROLYI <reka@karolyi.eu>

#	- Andras HORVATH <Andras.Horvath@cern.ch>

#

# CHANGELOG

#

# Revision 3.01		2010/09/23 Zoltan HERPAI <wigyori@uid0.hu>

#			* Add support for handling non-ipmitool-based machtypes

#			* Add support for HP Proliant DL385G1

#

# Revision 3.00		2010/05/25 Zoltan HERPAI <wigyori@uid0.hu>

#			* Add support for Supermicro X7DB8 via AOC IPMI20-E (aocipmi20e)

#			* Add support for Supermicro X7DCL via AOC IPMI20-E (aocipmi20e)

#			* Add support for Supermicro X8DT6 via Winbond Hermon BMC (hermon)

#			* Add support for Supermicro X8DTT-F via Winbond Hermon BMC (hermon)

#			* Add support for Dell M610 (m610)

#			* Add support for HP DL380G5 (proliantg5)

#			* Add support for HP ML350G5 (proliantg5)

#			* Re-add support for Asus K8N-LR via ASMB2 (asmb2)

#			* Add to-be-tested support for HP DL145G2 as per Paulo@muninexchange (asmb2)

#

# Revision 3.00early4	2010/01/09 Zoltan HERPAI <wigyori@uid0.hu>

#			* Add support for IBM HS22 (ibmhsxx)

#			* Add support for IBM iDataplex DX360 (ibmhsxx)

#			* Add support for Dell DCS XS23-sc (xs23)

#

# Revision 3.00early3	2009/12/30 Zoltan HERPAI <wigyori@uid0.hu>

#			* Support for easier debugging ($debug)

#			* Add support for IBM LS41 (ibmls4x)

#			* Add complete support for Sun x2270 (x2270)

#			* Add support for Sun x4500 (x4x00)

#			* Add support for Fujitsu-Siemens TX120 (tx120)

#

# Revision 3.00early2	2009/09/09 Zoltan HERPAI <wigyori@uid0.hu>

#			* Minor bugfix due to munin brain damage

#

# Revision 3.00early	2009/09/01 Zoltan HERPAI <wigyori@uid0.hu>

#			* Complete rewrite in perl.

#			* Sun x2100, x2100M2 and x2200 are now supported in 'x2100' machtype

#			* Bunch of new machtypes are supported

#

use strict;

use warnings;

use POSIX;

use FindBin qw($Script);

my $IPMITOOL = '/usr/bin/ipmitool';

my $curtime = time();

my $TEMPFILE = "/var/lib/munin/plugin-state/ipmisens3";

# set the ipmidump expiration to 1 day

my $TEMPREFRESH = 86400;

my $debug = 0;

my $devel = 0;

##############

# You should not need to edit anything below here

#

$ENV{PATH} = '/bin:/usr/bin:/usr/sbin';

$ENV{IFS} = "\n";

$0 =~ /.*_(.*)_(.*)/;

my $machine = $1;

my $sensor = $2;

# Test if ipmitool is available

if ( !$devel )

{

	if ( $machine ne 'hpasmcli' ) {

		`$IPMITOOL help 2> /dev/null`;

		if ($?)

		{

			print "no ($IPMITOOL not found)";

			exit 1;

		}

	}

}

print "Machine: $machine , sensor: $sensor\n" if ($debug);

# check expiration time of the dumpfile

if ( !$devel )

{

	if ( $machine ne 'hpasmcli' ) {

		if ( -f $TEMPFILE && $curtime - (stat($TEMPFILE))[9] >= $TEMPREFRESH )

		{

			print "Unlinking $TEMPFILE...\n" if ($debug);

			unlink ($TEMPFILE);

		}

	}

}

if ( !$devel )

{

	if ( $machine ne 'hpasmcli' ) {

		if ( ! -f $TEMPFILE )

		{

			print "Writing dumpfile $TEMPFILE...\n" if ($debug);

			`$IPMITOOL sdr dump $TEMPFILE` || die $!;

			if ($?)

			{

				print "no (retcode $?)\n";

				exit 2;

			}

		}

	}

}

my @ipmioutput;

# Read the sensors

if ( $machine ne 'hpasmcli' ) {

	@ipmioutput = `$IPMITOOL sdr -S $TEMPFILE`;

}

else {

	@ipmioutput = `cat /tmp/ipmi-sensors`;

}

#my @ipmioutput = `cat ~wigyori/ipmisens2/outputs/hp_ml350g5`;

if ($?)

{

	print "no (retcode $?)\n";

	exit 3;

}

my $arg;

if ( defined($ARGV[0]) && $ARGV[0] ne "" )

{

	print "argv: ".$ARGV[0]."\n" if ($debug);

	if ( $ARGV[0] eq 'config' )	{ $arg = 'config'; }

	if ( $ARGV[0] eq 'autoconf' )	{ $arg = 'autoconf'; }

	if ( $arg eq 'autoconf' )	{ print "no\n"; exit 0; }

	my %cnf;

	if ( $arg eq 'config' )

	{

		# Base sensor config

		if ( $sensor eq 'temp' )

		{

			%cnf = (

				'graph_title' => 'Temperature',

				'graph_vlabel' => 'C',

				'graph_category' => 'sensors',

			);

		}

		if ( $sensor eq 'volt' )

		{

			%cnf = (

				'graph_title' => 'Voltages',

				'graph_vlabel' => 'Volts',

				'graph_category' => 'sensors',

			);

		}

		if ( $sensor eq 'fan' )

		{

			if ( $machine ne 'hpasmcli' ) {

				%cnf = (

					'graph_title' => 'Fan speeds',

					'graph_vlabel' => 'RPM',

					'graph_category' => 'sensors',

				);

			}

			else {

				%cnf = (

					'graph_title' => 'Fan speeds',

					'graph_vlabel' => '%',

					'graph_category' => 'sensors',

				);

			}

		}

		# Static descriptors

		my %base;

		# Sun x4100

		$base{'x4x00'}->{'mbt_amb'} = 'Mainboard';

		$base{'x4x00'}->{'fpt_amb'} = 'FP';

		$base{'x4x00'}->{'pdbt_amb'} = 'PSU';

		$base{'x4x00'}->{'iot_amb'} = 'Disks';

		$base{'x4x00'}->{'p0t_core'} = 'CPU0';

		$base{'x4x00'}->{'p1t_core'} = 'CPU1';

		$base{'x4x00'}->{'ft0fm0f0'} = 'ft0.fm0.f0';

		$base{'x4x00'}->{'ft0fm1f0'} = 'ft0.fm1.f0';

		$base{'x4x00'}->{'ft0fm2f0'} = 'ft0.fm2.f0';

		$base{'x4x00'}->{'ft0fm0f1'} = 'ft0.fm0.f1';

		$base{'x4x00'}->{'ft0fm1f1'} = 'ft0.fm1.f1';

		$base{'x4x00'}->{'ft0fm2f1'} = 'ft0.fm2.f1';

		$base{'x4x00'}->{'ft1fm0f0'} = 'ft1.fm0.f0';

		$base{'x4x00'}->{'ft1fm1f0'} = 'ft1.fm1.f0';

		$base{'x4x00'}->{'ft1fm2f0'} = 'ft1.fm2.f0';

		$base{'x4x00'}->{'ft1fm0f1'} = 'ft1.fm0.f1';

		$base{'x4x00'}->{'ft1fm1f1'} = 'ft1.fm1.f1';

		$base{'x4x00'}->{'ft1fm2f1'} = 'ft1.fm2.f1';

		$base{'x4x00'}->{'mbv_bat'} = 'BAT';

		$base{'x4x00'}->{'mbv_3v3stby'} = '3.3VSTBY';

		$base{'x4x00'}->{'mbv_3v3'} = '3.3V';

		$base{'x4x00'}->{'mbv_5v'} = '5V';

		$base{'x4x00'}->{'mbv_12v'} = '+12V';

		$base{'x4x00'}->{'mbv_dash12v'} = '-12V';

		$base{'x4x00'}->{'mbv_2v5core'} = 'MB 2.5V';

		$base{'x4x00'}->{'mbv_1v8core'} = 'MB 1.8V';

		$base{'x4x00'}->{'mbv_1v2core'} = 'MB 1.2V';

		$base{'x4x00'}->{'p0v_1v5'} = 'CPU0 1.5V';

		$base{'x4x00'}->{'p0v_2v5core'} = 'CPU0 2.5V';

		$base{'x4x00'}->{'p0v_1v25core'} = 'CPU0 1.25V';

		$base{'x4x00'}->{'p1v_1v5'} = 'CPU1 1.5V';

		$base{'x4x00'}->{'p1v_2v5core'} = 'CPU1 2.5V';

		$base{'x4x00'}->{'p1v_1v25core'} = 'CPU1 1.25V';

		# Sun x4100m2 extents

		$base{'x4x00'}->{'mbv_1v5core'} = 'MB 1.5V';

		$base{'x4x00'}->{'p0v_vddio'} = 'CPU0 VDDIO';

		$base{'x4x00'}->{'p0v_vdd'} = 'CPU0 VDD';

		$base{'x4x00'}->{'p0v_vtt'} = 'CPU0 VTT';

		$base{'x4x00'}->{'p1v_vddio'} = 'CPU1 VDDIO';

		$base{'x4x00'}->{'p1v_vdd'} = 'CPU1 VDD';

		$base{'x4x00'}->{'p1v_vtt'} = 'CPU1 VTT';

		# Sun x4600 voltage extents

		$base{'x4x00'}->{'mbv_1v2'} = 'MB +1.2V';

		$base{'x4x00'}->{'mbv_1v5'} = 'MB +1.5V';

		$base{'x4x00'}->{'mbv_2v5'} = 'MB +2.5V';

		$base{'x4x00'}->{'mbv_3v3aux_r'} = 'MB +3.3VAUX';

		$base{'x4x00'}->{'p0v_12v'} = 'CPU0 module +12V';

		$base{'x4x00'}->{'p1v_12v'} = 'CPU1 module +12V';

		$base{'x4x00'}->{'p2v_12v'} = 'CPU2 module +12V';

		$base{'x4x00'}->{'p3v_12v'} = 'CPU3 module +12V';

		$base{'x4x00'}->{'p4v_12v'} = 'CPU4 module +12V';

		$base{'x4x00'}->{'p5v_12v'} = 'CPU5 module +12V';

		$base{'x4x00'}->{'p6v_12v'} = 'CPU6 module +12V';

		$base{'x4x00'}->{'p7v_12v'} = 'CPU7 module +12V';

		$base{'x4x00'}->{'p0v_2v5'} = 'CPU0 module +2.5V';

		$base{'x4x00'}->{'p1v_2v5'} = 'CPU1 module +2.5V';

		$base{'x4x00'}->{'p2v_2v5'} = 'CPU2 module +2.5V';

		$base{'x4x00'}->{'p3v_2v5'} = 'CPU3 module +2.5V';

		$base{'x4x00'}->{'p4v_2v5'} = 'CPU4 module +2.5V';

		$base{'x4x00'}->{'p5v_2v5'} = 'CPU5 module +2.5V';

		$base{'x4x00'}->{'p6v_2v5'} = 'CPU6 module +2.5V';

		$base{'x4x00'}->{'p7v_2v5'} = 'CPU7 module +2.5V';

		$base{'x4x00'}->{'p0v_1v2'} = 'CPU0 module +1.2V';

		$base{'x4x00'}->{'p1v_1v2'} = 'CPU1 module +1.2V';

		$base{'x4x00'}->{'p2v_1v2'} = 'CPU2 module +1.2V';

		$base{'x4x00'}->{'p3v_1v2'} = 'CPU3 module +1.2V';

		$base{'x4x00'}->{'p4v_1v2'} = 'CPU4 module +1.2V';

		$base{'x4x00'}->{'p5v_1v2'} = 'CPU5 module +1.2V';

		$base{'x4x00'}->{'p6v_1v2'} = 'CPU6 module +1.2V';

		$base{'x4x00'}->{'p7v_1v2'} = 'CPU7 module +1.2V';

		$base{'x4x00'}->{'p0v_3v3aux_r'} = 'CPU0 module +3.3VAUX';

		$base{'x4x00'}->{'p1v_3v3aux_r'} = 'CPU1 module +3.3VAUX';

		$base{'x4x00'}->{'p2v_3v3aux_r'} = 'CPU2 module +3.3VAUX';

		$base{'x4x00'}->{'p3v_3v3aux_r'} = 'CPU3 module +3.3VAUX';

		$base{'x4x00'}->{'p4v_3v3aux_r'} = 'CPU4 module +3.3VAUX';

		$base{'x4x00'}->{'p5v_3v3aux_r'} = 'CPU5 module +3.3VAUX';

		$base{'x4x00'}->{'p6v_3v3aux_r'} = 'CPU6 module +3.3VAUX';

		$base{'x4x00'}->{'p7v_3v3aux_r'} = 'CPU7 module +3.3VAUX';

		$base{'x4x00'}->{'p0v_3v3led'} = 'CPU0 module +3.3V LED';

		$base{'x4x00'}->{'p1v_3v3led'} = 'CPU1 module +3.3V LED';

		$base{'x4x00'}->{'p2v_3v3led'} = 'CPU2 module +3.3V LED';

		$base{'x4x00'}->{'p3v_3v3led'} = 'CPU3 module +3.3V LED';

		$base{'x4x00'}->{'p4v_3v3led'} = 'CPU4 module +3.3V LED';

		$base{'x4x00'}->{'p5v_3v3led'} = 'CPU5 module +3.3V LED';

		$base{'x4x00'}->{'p6v_3v3led'} = 'CPU6 module +3.3V LED';

		$base{'x4x00'}->{'p7v_3v3led'} = 'CPU7 module +3.3V LED';

		$base{'x4x00'}->{'p2v_1v25core'} = 'CPU2 1.25V';

		$base{'x4x00'}->{'p3v_1v25core'} = 'CPU3 1.25V';

		$base{'x4x00'}->{'p4v_1v25core'} = 'CPU4 1.25V';

		$base{'x4x00'}->{'p5v_1v25core'} = 'CPU5 1.25V';

		$base{'x4x00'}->{'p6v_1v25core'} = 'CPU6 1.25V';

		$base{'x4x00'}->{'p7v_1v25core'} = 'CPU7 1.25V';

		$base{'x4x00'}->{'p0v_core'} = 'CPU0 Vcore';

		$base{'x4x00'}->{'p1v_core'} = 'CPU1 Vcore';

		$base{'x4x00'}->{'p2v_core'} = 'CPU2 Vcore';

		$base{'x4x00'}->{'p3v_core'} = 'CPU3 Vcore';

		$base{'x4x00'}->{'p4v_core'} = 'CPU4 Vcore';

		$base{'x4x00'}->{'p5v_core'} = 'CPU5 Vcore';

		$base{'x4x00'}->{'p6v_core'} = 'CPU6 Vcore';

		$base{'x4x00'}->{'p7v_core'} = 'CPU7 Vcore';

		# Sun x4600 temp extents

		$base{'x4x00'}->{'p2t_core'} = 'CPU2';

		$base{'x4x00'}->{'p3t_core'} = 'CPU3';

		$base{'x4x00'}->{'p4t_core'} = 'CPU4';

		$base{'x4x00'}->{'p5t_core'} = 'CPU5';

		$base{'x4x00'}->{'p6t_core'} = 'CPU6';

		$base{'x4x00'}->{'p7t_core'} = 'CPU7';

		$base{'x4x00'}->{'p0t_amb'} = 'CPU0 module';

		$base{'x4x00'}->{'p1t_amb'} = 'CPU1 module';

		$base{'x4x00'}->{'p2t_amb'} = 'CPU2 module';

		$base{'x4x00'}->{'p3t_amb'} = 'CPU3 module';

		$base{'x4x00'}->{'p4t_amb'} = 'CPU4 module';

		$base{'x4x00'}->{'p5t_amb'} = 'CPU5 module';

		$base{'x4x00'}->{'p6t_amb'} = 'CPU6 module';

		$base{'x4x00'}->{'p7t_amb'} = 'CPU7 module';

		$base{'x4x00'}->{'mbt_amb0'} = 'System board 0';

		$base{'x4x00'}->{'mbt_amb1'} = 'System board 1';

		$base{'x4x00'}->{'mbt_amb2'} = 'System board 2';

		# Sun x4500 voltage extents

		$base{'x4x00'}->{'procp0v_1v25'} = 'CPU0 1.25V';

		$base{'x4x00'}->{'procp1v_1v25'} = 'CPU1 1.25V';

		$base{'x4x00'}->{'procp0v_1v5'} = 'CPU0 1.5V';

		$base{'x4x00'}->{'procp1v_1v5'} = 'CPU1 1.5V';

		$base{'x4x00'}->{'procp0v_2v5'} = 'CPU0 2.5V';

		$base{'x4x00'}->{'procp1v_2v5'} = 'CPU1 2.5V';

		$base{'x4x00'}->{'procv_1v8'} = 'CPU 1.8V';

		$base{'x4x00'}->{'iov_1v5'} = 'IO 1.5V';

		$base{'x4x00'}->{'iov_2v5'} = 'IO 2.5V';

		$base{'x4x00'}->{'iov_5v_disk'} = 'IO 5V disk';

		$base{'x4x00'}->{'iov_dash12v'} = 'IO -12V';

		# Sun x4500 temp extents

		$base{'x4x00'}->{'iofrontt_amb'} = 'IO front';

		$base{'x4x00'}->{'ioreart_amb'} = 'IO rear';

		$base{'x4x00'}->{'procfrontt_amb'} = 'CPU front';

		$base{'x4x00'}->{'procreart_amb'} = 'CPU rear';

		$base{'x4x00'}->{'procp0t_core'} = 'CPU0 temp';

		$base{'x4x00'}->{'procp1t_core'} = 'CPU1 temp';

		$base{'x4x00'}->{'dbpt_amb'} = 'DBP';

		# Sun V20z (V40z?)

		$base{'v20z'}->{'ambient'} = 'System';

		$base{'v20z'}->{'cpu0die'} = 'CPU0 die';

		$base{'v20z'}->{'cpu0mem'} = 'CPU0 mem';

		$base{'v20z'}->{'cpu1die'} = 'CPU1 die';

		$base{'v20z'}->{'cpu1mem'} = 'CPU1 mem';

		$base{'v20z'}->{'gbeth'} = 'GBNIC';

		$base{'v20z'}->{'hddbp'} = 'HDD backplane';

		$base{'v20z'}->{'sp'} = 'Service CPU';

		# Sun x2100

		$base{'x2100'}->{'cpucorevoltage'} = 'CPU core';

		$base{'x2100'}->{'batteryvolt'} = 'VBAT';

		$base{'x2100'}->{'ddr26v'} = 'DDR 2.6V';

		$base{'x2100'}->{'vcc33v'} = '+3.3V';

		$base{'x2100'}->{'vcc5v'} = '+5V';

		$base{'x2100'}->{'vcc12v'} = '+12V';

		$base{'x2100'}->{'cputemp'} = 'CPU';

		$base{'x2100'}->{'system'} = 'System';

		# Sun x2100M2 extents

		$base{'x2100'}->{'ddrp118v'} = 'DDR P1 1.8V';

		$base{'x2100'}->{'vcc33vstb'} = '+3.3VSTBY';

		$base{'x2100'}->{'ambienttemp'} = 'System';

		# Sun x2200 extents

		$base{'x2100'}->{'ddrp018v'} = 'DDR P0 1.8V';

		$base{'x2100'}->{'ambienttemp0'} = 'System temp 0';

		$base{'x2100'}->{'ambienttemp1'} = 'System temp 1';

		$base{'x2100'}->{'cpu0temp'} = 'CPU0 temp';

		$base{'x2100'}->{'cpu1temp'} = 'CPU1 temp';

		# Intel SHG2

		$base{'shg2'}->{'baseboard12v'} = 'MB 12V';

		$base{'shg2'}->{'baseboard15v'} = 'MB 1.5V';

		$base{'shg2'}->{'baseboard25v'} = 'MB 2.5V';

		$base{'shg2'}->{'baseboard33v'} = 'MB 3.3V';

		$base{'shg2'}->{'baseboard33vsb'} = '3.3VSTBY';

		$base{'shg2'}->{'baseboard5v'} = 'MB 5V';

		$base{'shg2'}->{'baseboarddash12v'} = 'MB -12V';

		$base{'shg2'}->{'batteryvoltage'} = 'VBAT';

		$base{'shg2'}->{'processorvrm'} = 'VRM';

		# IBM x346

		$base{'x346'}->{'125vsense'} = '+1.25V';

		$base{'x346'}->{'12vasense'} = '+12V A';

		$base{'x346'}->{'12vbsense'} = '+12V B';

		$base{'x346'}->{'12vcsense'} = '+12V C';

		$base{'x346'}->{'13vsense'} = '+1.3V';

		$base{'x346'}->{'15vsense'} = '+1.5V';

		$base{'x346'}->{'18vsense'} = '+1.8V';

		$base{'x346'}->{'25vsense'} = '+2.5V';

		$base{'x346'}->{'5vsense'} = '+5V';

		$base{'x346'}->{'cpu1vcore'} = 'CPU1 Vcore';

		$base{'x346'}->{'cpu2vcore'} = 'CPU2 Vcore';

		$base{'x346'}->{'cpuvtt'} = 'CPU VTT';

		$base{'x346'}->{'dash12vsense'} = '-12V';

		$base{'x346'}->{'vbat'} = 'VBAT';

		$base{'x346'}->{'cpu1'} = 'CPU1';

		$base{'x346'}->{'cpu2'} = 'CPU2';

		$base{'x346'}->{'dasd'} = 'DASD';

		$base{'x346'}->{'ambient'} = 'System';

		# Sun x2250

		$base{'x2250'}->{'3v3_stby'} = '3.3VSTBY';

		$base{'x2250'}->{'3v3'} = '+3.3V';

		$base{'x2250'}->{'5v'} = '+5V';

		$base{'x2250'}->{'12v'} = '+12V';

		$base{'x2250'}->{'1v5'} = '+1.5V';

		$base{'x2250'}->{'1v8'} = '+1.8V';

		$base{'x2250'}->{'0v9'} = '+0.9V';

		$base{'x2250'}->{'vtt'} = 'VTT';

		$base{'x2250'}->{'1v5_esb'} = 'ESB +1.5V';

		$base{'x2250'}->{'1v2_nic'} = 'NIC +1.2V';

		$base{'x2250'}->{'1v8_nic'} = 'NIC +1.8V';

		$base{'x2250'}->{'1v5_fbd'} = 'FBDIMM +1.5V';

		# Sun x2270

		$base{'x2270'}->{'3v3_stby'} = '3.3VSTBY';

		$base{'x2270'}->{'3v3'} = '+3.3V';

		$base{'x2270'}->{'5v'} = '+5V';

		$base{'x2270'}->{'12v'} = '+12V';

		$base{'x2270'}->{'3v3_vbat'} = '3.3VBAT';

		$base{'x2270'}->{'1v5'} = '+1.5V';

		$base{'x2270'}->{'p0_1v5_ddr'} = 'DDR P0 +1.5V';

		$base{'x2270'}->{'p1_1v5_ddr'} = 'DDR P1 +1.5V';

		$base{'x2270'}->{'p0_1v8'} = 'P0 +1.8V';

		$base{'x2270'}->{'p1_1v8'} = 'P1 +1.8V';

		$base{'x2270'}->{'p0_vtt'} = 'P0 VTT';

		$base{'x2270'}->{'p1_vtt'} = 'P1 VTT';

		$base{'x2270'}->{'p0_vccp'} = 'P0 VCCp';

		$base{'x2270'}->{'p1_vccp'} = 'P1 VCCp';

		# Sun x4150

		$base{'x4150'}->{'mb_t_amb0'} = 'MB Sensor 0';

		$base{'x4150'}->{'mb_t_amb1'} = 'MB Sensor 1';

		$base{'x4150'}->{'mb_t_amb2'} = 'MB Sensor 2';

		$base{'x4150'}->{'mb_t_amb3'} = 'MB Sensor 3';

		$base{'x4150'}->{'ps0_t_amb'} = 'PS 1 temp';

		$base{'x4150'}->{'ps1_t_amb'} = 'PS 2 temp';

		$base{'x4150'}->{'t_amb'} = 'System';

		$base{'x4150'}->{'ps0_f0'} = 'PS 1 fan';

		$base{'x4150'}->{'ps1_f0'} = 'PS 2 fan';

		$base{'x4150'}->{'mb_p0_v_vcc'} = 'CPU0 VCC';

		$base{'x4150'}->{'mb_p1_v_vcc'} = 'CPU1 VCC';

		$base{'x4150'}->{'mb_v_12v'} = '+12V';

		$base{'x4150'}->{'mb_v_1v5'} = '+1.5V';

		$base{'x4150'}->{'mb_v_1v8'} = '+1.8V';

		$base{'x4150'}->{'mb_v_2v5stby'} = '+2.5VSTBY';

		$base{'x4150'}->{'mb_v_3v3'} = '+3.3V';

		$base{'x4150'}->{'mb_v_3v3stby'} = '+3.3VSTBY';

		$base{'x4150'}->{'mb_v_5v'} = '+5V';

		$base{'x4150'}->{'mb_v_nic'} = 'NIC';

		$base{'x4150'}->{'mb_v_vtt'} = 'VTT';

		$base{'x4150'}->{'ps0_v_in'} = 'PS 1 voltage in';

		$base{'x4150'}->{'ps0_v_out'} = 'PS 1 voltage out';

		$base{'x4150'}->{'ps1_v_in'} = 'PS 2 voltage in';

		$base{'x4150'}->{'ps1_v_out'} = 'PS 2 voltage out';

		# Verari VB1205XM

		$base{'vb1205'}->{'12v'} = '+12V';

		$base{'vb1205'}->{'1_2v'} = '+1.2V';

		$base{'vb1205'}->{'1_5v'} = '+1.5V';

		$base{'vb1205'}->{'3_3v'} = '+3.3V';

		$base{'vb1205'}->{'5v'} = '+5V';

		$base{'vb1205'}->{'5vsb'} = '+5VSTBY';

		$base{'vb1205'}->{'cpu1vcore'} = 'CPU1 Vcore';

		$base{'vb1205'}->{'cpu2vcore'} = 'CPU2 Vcore';

		$base{'vb1205'}->{'dash12v'} = '-12V';

		$base{'vb1205'}->{'vbat'} = 'VBAT';

		$base{'vb1205'}->{'cputemp1'} = 'CPU 1 temp';

		$base{'vb1205'}->{'cputemp2'} = 'CPU 2 temp';

		$base{'vb1205'}->{'systemp'} = 'System';

		# Dell PowerEdge 2650

		$base{'pe2650'}->{'esmmbfan1'} = 'Fan 1';

		$base{'pe2650'}->{'esmmbfan2'} = 'Fan 2';

		$base{'pe2650'}->{'esmmbfan3'} = 'Fan 3';

		$base{'pe2650'}->{'esmmbfan4'} = 'Fan 4';

		$base{'pe2650'}->{'esmmbfan5'} = 'Fan 5';

		$base{'pe2650'}->{'esmmbfan6'} = 'Fan 6';

		$base{'pe2650'}->{'esmmbfan7'} = 'Fan 7';

		$base{'pe2650'}->{'esmmb12'} = 'MB +12V';

		$base{'pe2650'}->{'esmmb25'} = 'MB +2.5V';

		$base{'pe2650'}->{'esmmb33'} = 'MB +3.3V';

		$base{'pe2650'}->{'esmmb5'} = 'MB +5V';

		$base{'pe2650'}->{'esmmbbat'} = 'VBAT';

		$base{'pe2650'}->{'esmmbdash12'} = 'MB -12V';

		$base{'pe2650'}->{'esmrombpk'} = 'ROMB PK';

		$base{'pe2650'}->{'esmvtt'} = 'VTT';

		$base{'pe2650'}->{'esmcpu'} = 'CPU';

		$base{'pe2650'}->{'esm5aux'} = '5V AUX';

		$base{'pe2650'}->{'esmcpu1'} = 'CPU1';

		$base{'pe2650'}->{'esmcpu2'} = 'CPU2';

		$base{'pe2650'}->{'esmfrti_o'} = 'Front I/O';

		$base{'pe2650'}->{'esmriser'} = 'Riser';

		# IBM x3200

		$base{'ibmx3xx0'}->{'planar12v'} = '+12V';

		$base{'ibmx3xx0'}->{'planar15v'} = '+1.5V';

		$base{'ibmx3xx0'}->{'planar18v'} = '+1.8V';

		$base{'ibmx3xx0'}->{'planar33v'} = '+3.3V';

		$base{'ibmx3xx0'}->{'planar5v'} = '+5V';

		$base{'ibmx3xx0'}->{'cpuvcore'} = 'CPU Vcore';

		$base{'ibmx3xx0'}->{'cpuvtt'} = 'VTT';

		$base{'ibmx3xx0'}->{'ambient'} = 'System';

		$base{'ibmx3xx0'}->{'cpu'} = 'CPU';

		# IBM x3550 extents

		$base{'ibmx3xx0'}->{'planarvbat'} = 'VBAT';

		# IBM LS41

		$base{'ibmlsxx'}->{'12vsense'} = '+12V';

		$base{'ibmlsxx'}->{'3_3vsense'} = '+3.3V';

		$base{'ibmlsxx'}->{'5vsense'} = '+5V';

		$base{'ibmlsxx'}->{'planarvbat'} = 'VBAT';

		# IBM LS20 extents

		$base{'ibmlsxx'}->{'1_8vsense'} = '+1.8V';

		$base{'ibmlsxx'}->{'1_8vsbsense'} = '+1.8VSB';

		$base{'ibmlsxx'}->{'12vsbsense'} = '+12VSB';

		$base{'ibmlsxx'}->{'12v_isense'} = '+12V_I';

		# IBM HS21 

		$base{'ibmhsxx'}->{'planar0_9v'} = '+0.9V';

		$base{'ibmhsxx'}->{'planar12v'} = '+12V';

		$base{'ibmhsxx'}->{'planar3_3v'} = '+3.3V';

		$base{'ibmhsxx'}->{'planar5v'} = '+5V';

		$base{'ibmhsxx'}->{'planarvbat'} = 'VBAT';

		# IBM iDataplex DX320 extents

		$base{'ibmhsxx'}->{'cpu1vcore'} = 'CPU1 Vcore';

		$base{'ibmhsxx'}->{'cpu2vcore'} = 'CPU2 Vcore';

		# Fujitsu-Siemens TX120

		$base{'tx120'}->{'12v'} = '12V';

		$base{'tx120'}->{'15v'} = '1.5V';

		$base{'tx120'}->{'18v'} = '1.8V';

		$base{'tx120'}->{'33v'} = '3.3V';

		$base{'tx120'}->{'5v'} = '5V';

		$base{'tx120'}->{'dash12v'} = '-12V';

		$base{'tx120'}->{'stdby33v'} = '3.3VSTBY';

		$base{'tx120'}->{'vtt'} = 'VTT';

		$base{'tx120'}->{'battery3v'} = '3VBAT';

		$base{'tx120'}->{'fanpsu'} = 'Fan PSU';

		$base{'tx120'}->{'fan1sys'} = 'Fan Sys 1';

		$base{'tx120'}->{'fan2sys'} = 'Fan Sys 2';

		$base{'tx120'}->{'fancpu'} = 'Fan CPU';

		$base{'tx120'}->{'ambient'} = 'Ambient';

		$base{'tx120'}->{'systemboard'} = 'System board';

		$base{'tx120'}->{'cpu'} = 'CPU';

		# Dell DCS XS23-sc

		$base{'xs23'}->{'systemfan'} = 'System fan';

		$base{'xs23'}->{'cpu0'} = 'CPU 0';

		$base{'xs23'}->{'cpu1'} = 'CPU 1';

		$base{'xs23'}->{'midplane'} = 'Midplane';

		$base{'xs23'}->{'p12v'} = 'Planar 12V';

		$base{'xs23'}->{'p15v'} = 'Planar 1.5V';

		$base{'xs23'}->{'p18v'} = 'Planar 1.8V';

		$base{'xs23'}->{'p33v'} = 'Planar 3.3V';

		$base{'xs23'}->{'p5v'} = 'Planar 5V';

		$base{'xs23'}->{'vtt'} = 'Vtt';

		$base{'xs23'}->{'vcc33vaux'} = 'Vcc 3.3V AUX';

		# Supermicro X8DT6 / X8DTT-F via Winbond Hermon BMC

		$base{'hermon'}->{'fan1'} = 'Fan 1';

		$base{'hermon'}->{'fan2'} = 'Fan 2';

		$base{'hermon'}->{'fan3'} = 'Fan 3';

		$base{'hermon'}->{'fan4'} = 'Fan 4';

		$base{'hermon'}->{'fan5'} = 'Fan 5';

		$base{'hermon'}->{'fan6'} = 'Fan 6';

		$base{'hermon'}->{'fan7'} = 'Fan 7';

		$base{'hermon'}->{'fan8'} = 'Fan 8';

		$base{'hermon'}->{'system'} = 'System';

		$base{'hermon'}->{'cpu1temp'} = 'CPU1 temp';

		$base{'hermon'}->{'cpu2temp'} = 'CPU2 temp';

		$base{'hermon'}->{'12v'} = '+12V';

		$base{'hermon'}->{'15v'} = '+1.5V';