From a7f89980e5b3f4b9a74c70dbc5ffe8aabd28be28 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Sun, 6 Jul 2014 18:04:32 +0200 Subject: Imported Upstream version 2.9.3 --- hpiutil/hpisel.c | 934 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 934 insertions(+) create mode 100644 hpiutil/hpisel.c (limited to 'hpiutil/hpisel.c') diff --git a/hpiutil/hpisel.c b/hpiutil/hpisel.c new file mode 100644 index 0000000..e922b81 --- /dev/null +++ b/hpiutil/hpisel.c @@ -0,0 +1,934 @@ +/* + * hpisel.c + * + * Author: Andy Cress arcress at users.sourceforge.net + * Copyright (c) 2003-2005 Intel Corporation. + * + * 04/28/03 Andy Cress - created + * 04/30/03 Andy Cress v0.6 first good run with common use cases + * 05/06/03 Andy Cress v0.7 added -c option to clear it + * 05/29/03 Andy Cress v0.8 fixed pstr warnings + * 06/13/03 Andy Cress v0.9 fixed strcpy bug, + * workaround for SensorEvent.data3 + * 06/19/03 Andy Cress 0.91 added low SEL free space warning + * 06/25/03 Andy Cress v1.0 rework event data logic + * 07/23/03 Andy Cress workaround for OpenHPI BUGGY stuff + * 11/12/03 Andy Cress v1.1 check for CAPABILITY_SEL + * 03/03/04 Andy Cress v1.2 use better free space logic now + * 10/14/04 Andy Cress v1.3 added HPI_A/HPI_B logic + * 02/11/05 Andy Cress v1.4 added decode routines from showsel.c + * 03/30/05 Dave Howell v1.5 added support to enable displaying domain + * event log for HPI_B + * 04/07/05 Andy Cress v1.6 fix domain resourceid & HPI_A/B flags, + * add logic to clear domain event log. + * + * Note that hpiutil 1.0.0 did not return all event data fields, so event + * types other than 'user' did not have all bytes filled in as they + * would have from IPMI alone. A patch to the Intel HPI library in + * version 1.0.1 resolved this. + */ +/*M* +Copyright (c) 2003-2005, Intel Corporation +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + a.. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + b.. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + c.. Neither the name of Intel Corporation nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS 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 COPYRIGHT OWNER OR 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. + *M*/ + +#include +#include +#include +#include +#include +#include "SaHpi.h" + +#ifdef HPI_A +/* HPI A (1.0) spec */ +char progver[] = "1.6 HPI-A"; +#else +/* HPI B name changes */ +#define SaHpiSelEntryT SaHpiEventLogEntryT +#define SaHpiSelEntryIdT SaHpiEventLogEntryIdT +#define SaHpiSelInfoT SaHpiEventLogInfoT +#define SAHPI_CAPABILITY_SEL SAHPI_CAPABILITY_EVENT_LOG /*0x00000004*/ +#define SAHPI_EC_USER SAHPI_EC_SENSOR_SPECIFIC /*0x7E*/ +char progver[] = "1.6 HPI-B"; +#endif +int fdebug = 0; +int fclear = 0; +int fdomain = 0; + +#ifdef HPI_A +#define NEVTYPES 5 +char *evtypes[NEVTYPES] = {"sensor","hotswap","watchdog","oem ","user "}; +#else +#define NEVTYPES 9 +char *evtypes[NEVTYPES] = {"resource","domain","sensor","sens_enable", + "hotswap","watchdog","HPI sw", "oem ","user "}; +#endif + +#define NECODES 27 +struct { int code; char *str; +} ecodes[NECODES] = { + { 0, "Success" }, + { -1001, "HPI unspecified error" }, + { -1002, "HPI unsupported function" }, + { -1003, "HPI busy" }, + { -1004, "HPI request invalid" }, + { -1005, "HPI command invalid" }, + { -1006, "HPI timeout" }, + { -1007, "HPI out of space" }, + { -1008, "HPI data truncated" }, +#ifdef HPI_A + { -1009, "HPI data length invalid" }, +#else + { -1009, "HPI invalid parameter" }, +#endif + { -1010, "HPI data exceeds limits" }, + { -1011, "HPI invalid params" }, + { -1012, "HPI invalid data" }, + { -1013, "HPI not present" }, + { -1014, "HPI invalid data field" }, + { -1015, "HPI invalid sensor command" }, + { -1016, "HPI no response" }, + { -1017, "HPI duplicate request" }, + { -1018, "HPI updating" }, + { -1019, "HPI initializing" }, + { -1020, "HPI unknown error" }, + { -1021, "HPI invalid session" }, + { -1022, "HPI invalid domain" }, + { -1023, "HPI invalid resource id" }, + { -1024, "HPI invalid request" }, + { -1025, "HPI entity not present" }, + { -1026, "HPI uninitialized" } +}; +char def_estr[15] = "HPI error %d "; + +#define NUM_EC 14 +struct { int val; char *str; +} eventcats[NUM_EC] = { +{ /*0x00*/ SAHPI_EC_UNSPECIFIED, "unspecified"}, +{ /*0x01*/ SAHPI_EC_THRESHOLD, "Threshold"}, +{ /*0x02*/ SAHPI_EC_USAGE, "Usage "}, +{ /*0x03*/ SAHPI_EC_STATE, "State "}, +{ /*0x04*/ SAHPI_EC_PRED_FAIL, "Predictive"}, +{ /*0x05*/ SAHPI_EC_LIMIT, "Limit "}, +{ /*0x06*/ SAHPI_EC_PERFORMANCE, "Performnc"}, +{ /*0x07*/ SAHPI_EC_SEVERITY, "Severity "}, +{ /*0x08*/ SAHPI_EC_PRESENCE, "DevPresen"}, +{ /*0x09*/ SAHPI_EC_ENABLE, "DevEnable"}, +{ /*0x0a*/ SAHPI_EC_AVAILABILITY, "Availabil"}, +{ /*0x0b*/ SAHPI_EC_REDUNDANCY, "Redundanc"}, +{ /*0x7e*/ SAHPI_EC_USER, "SensorSpc"}, /*UserDefin*/ +{ /*0x7f*/ SAHPI_EC_GENERIC, "OemDefin " }}; + +#define NUM_ES 6 +struct { int val; char *str; } eventstates[NUM_ES] = { +{ SAHPI_ES_LOWER_MINOR , "lo-min" }, +{ SAHPI_ES_LOWER_MAJOR , "lo-maj" }, +{ SAHPI_ES_LOWER_CRIT , "lo-crt" }, +{ SAHPI_ES_UPPER_MINOR , "hi-min" }, +{ SAHPI_ES_UPPER_MAJOR , "hi-maj" }, +{ SAHPI_ES_UPPER_CRIT , "hi-crt" } }; + +#define uchar unsigned char +#define ushort unsigned short +#define uint unsigned int +#define ulong unsigned long +typedef struct +{ + short record_id; + uchar record_type; + uint timestamp; + short generator_id; /*slave_addr/channel*/ + uchar evm_rev; //event message revision + uchar sensor_type; + uchar sensor_number; + uchar event_trigger; + uchar event_data1; + uchar event_data2; + uchar event_data3; +} SEL_RECORD; + +/* sensor_types: See IPMI 1.5 Table 36-3, IPMI 2.0 Table 42-3 */ +#define NSTYPES 0x2D +static char *sensor_types[NSTYPES] = { +/* 00h */ "reserved", +/* 01h */ "Temperature", +/* 02h */ "Voltage", +/* 03h */ "Current", +/* 04h */ "Fan", +/* 05h */ "Platform Chassis Intrusion", +/* 06h */ "Security Violation", +/* 07h */ "Processor", +/* 08h */ "Power Supply", +/* 09h */ "Power Unit", +/* 0Ah */ "Cooling Device", +/* 0Bh */ "FRU Sensor", +/* 0Ch */ "Memory", +/* 0Dh */ "Drive Slot", +/* 0Eh */ "POST Memory Resize", +/* 0Fh */ "System Firmware", /*incl POST code errors*/ +/* 10h */ "SEL Disabled", +/* 11h */ "Watchdog 1", +/* 12h */ "System Event", /* offset 0,1,2 */ +/* 13h */ "Critical Interrupt", /* offset 0,1,2 */ +/* 14h */ "Button", /* offset 0,1,2 */ +/* 15h */ "Board", +/* 16h */ "Microcontroller", +/* 17h */ "Add-in Card", +/* 18h */ "Chassis", +/* 19h */ "Chip Set", +/* 1Ah */ "Other FRU", +/* 1Bh */ "Cable/Interconnect", +/* 1Ch */ "Terminator", +/* 1Dh */ "System Boot Initiated", +/* 1Eh */ "Boot Error", +/* 1Fh */ "OS Boot", +/* 20h */ "OS Critical Stop", +/* 21h */ "Slot/Connector", +/* 22h */ "ACPI Power State", +/* 23h */ "Watchdog 2", +/* 24h */ "Platform Alert", +/* 25h */ "Entity Presence", +/* 26h */ "Monitor ASIC", +/* 27h */ "LAN", +/* 28h */ "Management Subsystem Health", +/* 29h */ "Battery", +/* 2Ah */ "Session Audit", +/* 2Bh */ "Version Change", +/* 2Ch */ "FRU State" +}; + +#define NFWERRS 15 +static struct { /* See Table 36-3, type 0Fh, offset 00h */ + int code; char *msg; + } fwerrs[NFWERRS] = { + { 0x00, "Unspecified"}, + { 0x01, "No system memory"}, + { 0x02, "No usable memory"}, + { 0x03, "Unrecovered Hard Disk"}, + { 0x04, "Unrecovered System Board"}, + { 0x05, "Unrecovered Diskette"}, + { 0x06, "Unrecovered Hard Disk Ctlr"}, + { 0x07, "Unrecovered PS2 USB"}, + { 0x08, "Boot media not found"}, + { 0x09, "Unrecovered video controller"}, + { 0x0A, "No video device"}, + { 0x0B, "Firmware ROM corruption"}, + { 0x0C, "CPU voltage mismatch"}, + { 0x0D, "CPU speed mismatch"}, + { 0x0E, "Reserved" } +}; + +#define NFWSTAT 27 +static struct { /* See Table 36-3, type 0Fh, offset 01h & 02h */ + int code; char *msg; + } fwstat[NFWSTAT] = { + { 0x00, "Unspecified"}, + { 0x01, "Memory init"}, + { 0x02, "Hard disk init"}, + { 0x03, "Secondary processor"}, + { 0x04, "User authentication"}, + { 0x05, "User-init sys setup"}, + { 0x06, "USB configuration"}, + { 0x07, "PCI configuration"}, + { 0x08, "Option ROM init"}, + { 0x09, "Video init"}, + { 0x0a, "Cache init"}, + { 0x0b, "SM Bus init"}, + { 0x0c, "Keyboard init"}, + { 0x0d, "Mgt controller"}, + { 0x0e, "Docking attach"}, + { 0x0f, "Enabling docking"}, + { 0x10, "Docking eject"}, + { 0x11, "Disabling docking"}, + { 0x12, "OS wake-up"}, + { 0x13, "Starting OS boot"}, + { 0x14, "Baseboard init"}, + { 0x15, "reserved"}, + { 0x16, "Floppy init"}, + { 0x17, "Keyboard test"}, + { 0x18, "Mouse test"}, + { 0x19, "Primary processor"}, + { 0x1A, "Reserved"} +}; + +#define NGDESC 7 +struct { + ushort g_id; + char desc[10]; +} gen_desc[NGDESC] = { /*empirical, format defined in IPMI 1.5 Table 23-5 */ + { 0x0000, "IPMB"}, + { 0x0001, "EFI "}, + { 0x0003, "BIOS"}, + { 0x0020, "BMC "}, + { 0x0021, "SMI "}, + { 0x0028, "CHAS"}, /* Chassis Bridge Controller */ +/*{0x0031, "SMI/IPMB"}, * ia64/mBMC POST errors (rqSa/rqLun) */ +/*{0x0033, "MemCtlr"}, * ia64 memory controller? (rqSa/rqLun) */ + { 0x00c0, "HSC "} /* SAF-TE Hot-Swap Controller*/ +}; + +#define NCRITS 10 +char * crit_int_str[NCRITS] = { /* Critical Interrupt descriptions */ + /*00*/ "FP NMI ", /* Front Panel NMI */ + /*01*/ "Bus Timout", + /*02*/ "IOch NMI ", /* IO channel check NMI */ + /*03*/ "Soft NMI ", + /*04*/ "PCI PERR ", + /*05*/ "PCI SERR ", + /*06*/ "EISA Timout", + /*07*/ "Bus Warn ", /* Bus Correctable Error */ + /*08*/ "Bus Error", /* Bus Uncorrectable Error */ + /*09*/ "Fatal NMI" }; + +#define NSLOTC 9 +char * slot_str[NSLOTC] = { /* Slot/Connector descriptions */ + /*00*/ "Fault ", + /*01*/ "Identify", + /*02*/ "Inserted", + /*03*/ "InsReady", + /*04*/ "RemReady", + /*05*/ "PowerOff", + /*06*/ "RemRequest", + /*07*/ "Interlock", + /*08*/ "Disabled" }; + +#define NSDESC 47 +struct { + ushort genid; /*generator id: BIOS, BMC, etc. (slave_addr/channel)*/ + uchar s_typ; /*1=temp,2=voltage,4=fan,... */ + uchar s_num; + uchar evtrg; /*event trigger/type, see IPMI 1.5 table 36.1 & 36.2 */ + uchar data1; + uchar data2; + uchar data3; + char desc[40]; +} sens_desc[NSDESC] = { +{0xffff,0x05, 0x05, 0x6f, 0x44, 0xff, 0xff, "LAN unplugged"}, /*chassis*/ +{0xffff,0x05, 0x05, 0xef, 0x44, 0xff, 0xff, "LAN restored "}, /*chassis*/ +{0xffff,0x06, 0xff, 0xff, 0x45, 0xff, 0xff, "Password"}, /*security*/ +{0xffff,0x07, 0xff, 0xff, 0x41, 0xff, 0xff, "Thermal trip"}, /*processor*/ +{0xffff,0x08, 0xff, 0x6f, 0x40, 0xff, 0xff, "Presence detected"},/*PowerSupply*/ +{0xffff,0x08, 0xff, 0x6f, 0x41, 0xff, 0xff, "Failure detected"},/*power supply*/ +{0xffff,0x08, 0xff, 0x6f, 0x42, 0xff, 0xff, "Predictive failure"}, +{0xffff,0x08, 0xff, 0x6f, 0x43, 0xff, 0xff, "AC Lost"}, +{0xffff,0x08, 0xff, 0xef, 0x40, 0xff, 0xff, "not present"}, /*power supply*/ +{0xffff,0x08, 0xff, 0xef, 0x41, 0xff, 0xff, "is OK "}, /*power supply*/ +{0xffff,0x08, 0xff, 0xef, 0x42, 0xff, 0xff, "Predictive OK"}, +{0xffff,0x08, 0xff, 0xef, 0x43, 0xff, 0xff, "AC Regained"}, /*power supply*/ +{0xffff,0x09, 0xff, 0xff, 0x40, 0xff, 0xff, "Redundancy OK "}, /*power unit*/ +{0xffff,0x09, 0xff, 0xff, 0x41, 0xff, 0xff, "Redundancy Lost"}, +{0xffff,0x09, 0xff, 0xff, 0x44, 0xff, 0xff, "AC Lost"}, +{0xffff,0x09, 0xff, 0xff, 0x46, 0xff, 0xff, "Failure detected"}, +{0xffff,0x09, 0xff, 0xff, 0x47, 0xff, 0xff, "Predictive failure"},/*power unit*/ +{0xffff,0x0c, 0xff, 0xff, 0x00, 0xff, 0xff, "Correctable ECC"}, /*memory*/ +{0xffff,0x0f, 0x06, 0xff, 0xff, 0xff, 0xff, "POST Code"}, +{0xffff,0x10, 0x09, 0xff, 0x42, 0x0f, 0xff, "Log Cleared"}, +{0xffff,0x10, 0x09, 0xff, 0xc0, 0x03, 0xff, "ECC Memory Errors"}, + /* Often see these 3 Boot records with reboot: + * 12 83 6f 05 00 ff = System/SEL Time Sync 1 (going down) + * 12 83 6f 05 80 ff = System/SEL Time Sync 2 (coming up) + * 12 83 6f 01 ff ff = OEM System Boot Event (Completed POST) */ +{0xffff,0x12, 0x83, 0xff, 0x05, 0x00, 0xff, "Boot: ClockSync 1"}, +{0xffff,0x12, 0x83, 0xff, 0x05, 0x80, 0xff, "Boot: ClockSync 2"}, +{0xffff,0x12, 0x83, 0xff, 0x01, 0xff, 0xff, "OEM System Booted"}, +{0xffff,0x12, 0x08, 0xff, 0x01, 0xff, 0xff, "OEM System Booted"}, /*ia64*/ +{0xffff,0x12, 0x00, 0x6f, 0xff, 0xff, 0xff, "PEF Action"}, /*ia64*/ +{0xffff,0x12, 0x83, 0x6f, 0x80, 0xff, 0xff, "System Reconfigured"}, /*BMC*/ +{0x00c0,0x0d, 0xff, 0x08, 0x00, 0xff, 0xff, "Device Removed"}, /*HSC*/ +{0x00c0,0x0d, 0xff, 0x08, 0x01, 0xff, 0xff, "Device Inserted"}, /*HSC*/ +{0xffff,0x14, 0xff, 0xff, 0x42, 0xff, 0xff, "Reset Button pressed"}, +{0xffff,0x14, 0xff, 0xff, 0x40, 0xff, 0xff, "Power Button pressed"}, +{0xffff,0x14, 0xff, 0xff, 0x01, 0xff, 0xff, "ID Button pressed"}, +{0xffff,0x23, 0xff, 0xff, 0x40, 0xff, 0xff, "Expired, no action"},/*watchdog2*/ +{0xffff,0x23, 0xff, 0xff, 0x41, 0xff, 0xff, "Hard Reset action"}, /*watchdog2*/ +{0xffff,0x23, 0xff, 0xff, 0x42, 0xff, 0xff, "Power down action"}, /*watchdog2*/ +{0xffff,0x23, 0xff, 0xff, 0x43, 0xff, 0xff, "Power cycle action"},/*watchdog2*/ +{0xffff,0x23, 0xff, 0xff, 0x48, 0xff, 0xff, "Timer interrupt"}, /*watchdog2*/ +{0xffff,0xf3, 0x85, 0xff, 0x41, 0xff, 0xff, "State is now OK"}, +{0xffff,0x20, 0x00, 0xff, 0xff, 0xff, 0xff, "OS Kernel Panic"}, +{0xffff,0xff, 0xff, 0x01, 0x57, 0xff, 0xff, "Hi Noncrit thresh"}, +{0xffff,0xff, 0xff, 0x01, 0x59, 0xff, 0xff, "Hi Crit thresh"}, +{0xffff,0xff, 0xff, 0x01, 0x50, 0xff, 0xff, "Lo Noncrit thresh"}, +{0xffff,0xff, 0xff, 0x01, 0x52, 0xff, 0xff, "Lo Crit thresh"}, +{0xffff,0xff, 0xff, 0x81, 0x57, 0xff, 0xff, "HiN thresh OK now"}, +{0xffff,0xff, 0xff, 0x81, 0x59, 0xff, 0xff, "HiC thresh OK now"}, +{0xffff,0xff, 0xff, 0x81, 0x50, 0xff, 0xff, "LoN thresh OK now"}, +{0xffff,0xff, 0xff, 0x81, 0x52, 0xff, 0xff, "LoC thresh OK now"} + /*Thresholds apply to sensor types 1=temp, 2=voltage, 4=fan */ + /*Note that last 2 bytes usu show actual & threshold values*/ + /*evtrg: 0x01=thresh, 0x81=restored */ +}; + +/*------------------------------------------------------------------------ + * get_misc_desc + * Uses the sens_desc array to decode misc entries not otherwise handled. + * Called by decode_sel_entry + *------------------------------------------------------------------------*/ +char * get_misc_desc(uchar type, uchar num, ushort genid, uchar trig, + uchar data1, uchar data2, uchar data3); +char * +get_misc_desc(uchar type, uchar num, ushort genid, uchar trig, + uchar data1, uchar data2, uchar data3) +{ + int i; + char *pstr = NULL; + + /* Use sens_desc array for other misc descriptions */ + data1 &= 0x0f; /*ignore top half of sensor offset for matching */ + for (i = 0; i < NSDESC; i++) { + if ((sens_desc[i].s_typ == 0xff) || + (sens_desc[i].s_typ == type)) { + if (sens_desc[i].s_num != 0xff && + sens_desc[i].s_num != num) + continue; + if (sens_desc[i].genid != 0xffff && + sens_desc[i].genid != genid) + continue; + if (sens_desc[i].evtrg != 0xff && + sens_desc[i].evtrg != trig) + continue; + if (sens_desc[i].data1 != 0xff && + (sens_desc[i].data1 & 0x0f) != data1) + continue; + if (sens_desc[i].data2 != 0xff && + sens_desc[i].data2 != data2) + continue; + if (sens_desc[i].data3 != 0xff && + sens_desc[i].data3 != data3) + continue; + /* have a match, use description */ + pstr = (char *)sens_desc[i].desc; + break; + } + } /*end for*/ + return(pstr); +} /* end get_misc_desc() */ + +void decode_sensor_event(uchar sensor_type, uchar sensor_number, ushort gen_id, + uchar event_trigger, uchar data1, uchar data2, uchar data3, + char *outbuf); +void +decode_sensor_event(uchar sensor_type, uchar sensor_number, ushort gen_id, + uchar event_trigger, uchar data1, uchar data2, uchar data3, + char *outbuf) +{ + char mystr[26] = "(123)"; /*for panic string*/ + char poststr[24] = "OEM Post Code = %x%x"; + char genstr[10] = "03 "; + char *gstr; + char *pstr; + uchar dtype; + int i; + + /* set dtype, used as array index below */ + if (sensor_type >= NSTYPES) dtype = 0; + else dtype = sensor_type; + switch(sensor_type) { + case 0x20: /*OS Crit Stop*/ + /* Show first 3 chars of panic string */ + mystr[0] = '('; + mystr[1] = sensor_number & 0x7f; + mystr[2] = data2 & 0x7f; + mystr[3] = data3 & 0x7f; + mystr[4] = ')'; + mystr[5] = 0; + pstr = mystr; + if (sensor_number & 0x80) strcat(mystr,"Oops!"); + if (data2 & 0x80) strcat(mystr,"Int!"); + if (data3 & 0x80) strcat(mystr,"NullPtr!"); + break; + case 0x0f: /*Post Errs*/ + switch (data1) + { + case 0x00: /* System firmware errors */ + i = data2; + if (i >= NFWERRS) i = NFWERRS - 1; + pstr = fwerrs[i].msg; + break; + case 0x01: /* System firmware hang */ + i = data2; + if (i >= NFWSTAT) i = NFWSTAT - 1; + sprintf(poststr,"hang, %s",fwstat[i].msg); + pstr = poststr; + break; + case 0x02: /* System firmware progress */ + i = data2; + if (i >= NFWSTAT) i = NFWSTAT - 1; + sprintf(poststr,"prog, %s",fwstat[i].msg); + pstr = poststr; + break; + case 0xa0: /* OEM post codes */ + /* OEM post codes in bytes 2 & 3 (lo-hi) */ + sprintf(poststr,"POST Code %02x%02x", + data3,data2); + pstr = poststr; + break; + default: + pstr = "POST Error"; /*default string*/ + } /*end switch(data1)*/ + break; + case 0x13: /*Crit Int*/ + i = data1 & 0x0f; + if (i >= NCRITS) i = NCRITS - 1; + pstr = crit_int_str[i]; + break; + case 0x21: /*Slot/Con*/ + i = data1 & 0x0f; + if (i >= NSLOTC) i = NSLOTC - 1; + sprintf(mystr,"%s",slot_str[i]); + /* could also decode data2/data3 here if valid */ + pstr = mystr; + break; + default: /* all other sensor types, see sens_desc */ + pstr = get_misc_desc( sensor_type, + sensor_number, gen_id, + event_trigger, data1, data2, data3); + if (pstr == NULL) { + mystr[0] = '-'; mystr[1] = 0; + pstr = mystr; + } + + } /*end switch(sensor_type)*/ + + /* show the Generator ID */ + sprintf(genstr,"%04x",gen_id); + gstr = genstr; /* default */ + for (i = 0; i < NGDESC; i++) + { + if (gen_desc[i].g_id == gen_id) + gstr = (char *)gen_desc[i].desc; + } + + /*firmware timestamp is #seconds since 1/1/1970 localtime*/ + /* timestamp handled by caller in HPI */ + + if ((event_trigger == 0x01) || /*threshold*/ + (event_trigger == 0x81)) { /*threshold ok*/ + sprintf(outbuf, + "%s %02x %s act=%02x thr=%02x", + sensor_types[dtype], sensor_number, pstr, + data2, /*actual reading*/ + data3 ); /*threshold value*/ + } else { + sprintf(outbuf, + "%s %02x %s %02x [%02x %02x %02x]", + sensor_types[dtype] , sensor_number, pstr, + event_trigger, data1, data2, data3 ); + } +} + +/*------------------------------------------------------------------------ + * decode_ipmi_event + * Parse and decode the SEL record into readable format. + * This routine is constructed so that it could be used as a library + * function. + * Input: psel, a pointer to the IPMI SEL record + * Output: outbuf, a description of the event, max 80 chars. + * Called by ReadSEL + *------------------------------------------------------------------------*/ +void decode_ipmi_event( SEL_RECORD *psel, char *outbuf); +void decode_ipmi_event( SEL_RECORD *psel, char *outbuf) +{ + char genstr[10] = "03 "; + int i, j; + + if (psel->record_type >= 0xe0) { /*OEM Record 26.3*/ + char *pc; + pc = (char *)&psel->timestamp; /*bytes 4:16*/ + sprintf(outbuf," OEM Event %02x %02x ", pc[0], pc[1]); + j = strlen(outbuf); + for (i = 2; i < 13; i++) { /* 4:16 = 13 bytes data */ + if (psel->record_type == 0xf0) { + /* panic string will be type 0xf0 */ + if (pc[i] == 0) break; + outbuf[j++] = pc[i]; + } else { + sprintf(&outbuf[j],"%02x ",pc[i]); + j += 3; + } + } + outbuf[j++] = '\n'; + outbuf[j++] = 0; + } else if (psel->record_type == 0x02) { + /* most records are record type 2 */ + decode_sensor_event(psel->sensor_type, + psel->sensor_number, psel->generator_id, + psel->event_trigger, psel->event_data1, + psel->event_data2, psel->event_data3, outbuf); + + } /*endif type 2 */ + else { /* other misc record type */ + uchar *pc; + pc = (uchar *)&psel->record_type; + sprintf(outbuf," Type%02x ", pc[0]); + j = strlen(outbuf); + for (i = 1; i < 14; i++) { + sprintf(genstr,"%02x ",pc[i]); + strcat(outbuf,genstr); + } + } /*endif misc type*/ + return; +} /*end decode_ipmi_event()*/ + +#define IF_IPMI 0 /* other interfaces, like H8, have diff numbers */ + /*Note that OpenHPI 2.0.0 does not yet fill this in*/ + +/*------------------------------------------------------------------------ + * decode_hpi_event + * Parse and decode the SensorEvent record into readable format. + * Input: pevent, a pointer to the HPI SensorEvent record + * Output: outbuf, a description of the event, max 80 chars. + * Called by ReadSEL + *------------------------------------------------------------------------*/ +void decode_hpi_event( SaHpiSensorEventT *pevent, char *outbuf); +void decode_hpi_event( SaHpiSensorEventT *pevent, char *outbuf) +{ + int ec, eci; + int es, esi; + int styp; + uchar data1, data2, data3, if_type; + uchar etrig; + ushort genid; + char estag[8]; + char sbuf[80]; + char *ecstr; + // char *pstr; + + /* decode event category */ + ec = pevent->EventCategory; + for (eci = 0; eci < NUM_EC; eci++) + if (eventcats[eci].val == ec) break; + if (eci >= NUM_EC) eci = 0; + ecstr = eventcats[eci].str; + genid = 0x0020; /* default to BMC */ + etrig = 0x6f; /* default to sensor-specific*/ + /* decode event state */ + es = pevent->EventState; + if (ec == SAHPI_EC_USER) { /*OpenHPI usu returns this (0x7e)*/ + sprintf(estag,"%02x",es); + } else if (eci == SAHPI_EC_THRESHOLD ) { /*0x01*/ + for (esi = 0; esi < NUM_ES; esi++) + if (eventstates[esi].val == es) break; + if (esi >= NUM_ES) esi = 0; + strcpy(estag,eventstates[esi].str); + if (pevent->Assertion) etrig = 0x01; + else etrig = 0x81; + } else { + sprintf(estag,"%02x:%02x",ec,es); + } + + /* decode sensor type */ + styp = pevent->SensorType; + if (styp >= NSTYPES) { styp = 0; } + + /* get if_type from SensorSpecific h.o. byte */ + if_type = (pevent->SensorSpecific & 0xff000000) >> 24; + data3 = (pevent->SensorSpecific & 0x00ff0000) >> 16; + data2 = (pevent->SensorSpecific & 0x0000ff00) >> 8; + data1 = (pevent->SensorSpecific & 0x000000ff); + if (if_type == IF_IPMI) { /* handle IPMI SensorSpecific stuff */ + /* fortunately, HPI & IPMI have the same sensor_type values */ + decode_sensor_event(styp, pevent->SensorNum, genid, + etrig, data1, data2, data3, sbuf); + sprintf(outbuf,"%s %s", estag, sbuf); + } + else { + sprintf(outbuf,"%s, %s %s %x [%02x %02x %02x]", + sensor_types[styp], ecstr, estag, + pevent->SensorNum, data1, data2, data3); + } + + return; +} + +static +char *decode_error(SaErrorT code) +{ + int i; + char *str = NULL; + for (i = 0; i < NECODES; i++) { + if (code == ecodes[i].code) { str = ecodes[i].str; break; } + } + if (str == NULL) { + sprintf(&def_estr[10],"%d",code); + str = &def_estr[0]; + } + return(str); +} + +void ShowSel( SaHpiSelEntryT *sel, SaHpiRdrT *rdr, SaHpiRptEntryT *rptentry); +void ShowSel( SaHpiSelEntryT *sel, SaHpiRdrT *rdr, + SaHpiRptEntryT *rptentry ) +{ + unsigned char evtype; + char timestr[40]; + time_t tt1; + char *srctag; + char *rdrtag; + char *pstr; + unsigned char *pd; + int outlen; + char outbuf[132]; + int styp; + unsigned char data3; + + /*format & print the EventLog entry*/ + if (sel->Event.Timestamp > SAHPI_TIME_MAX_RELATIVE) { /*absolute time*/ + tt1 = sel->Event.Timestamp / 1000000000; + strftime(timestr,sizeof(timestr),"%x %H:%M:%S", localtime(&tt1)); + } else if (sel->Event.Timestamp > SAHPI_TIME_UNSPECIFIED) { /*invalid time*/ + strcpy(timestr,"invalid time "); + } else { /*relative time*/ + tt1 = sel->Event.Timestamp / 1000000000; + sprintf(timestr,"rel(%lx)", (unsigned long)tt1); + } + if (rptentry->ResourceId == sel->Event.Source) + srctag = rptentry->ResourceTag.Data; + else srctag = "unspec "; /* SAHPI_UNSPECIFIED_RESOURCE_ID */ + evtype = sel->Event.EventType; + if (evtype > NEVTYPES) evtype = NEVTYPES - 1; + if (rdr->RdrType == SAHPI_NO_RECORD) rdrtag = "rdr-unkn"; + else { + rdr->IdString.Data[rdr->IdString.DataLength] = 0; + rdrtag = &rdr->IdString.Data[0]; + } + sprintf(outbuf,"%04x %s %s ", sel->EntryId, timestr, evtypes[evtype] ); + outlen = strlen(outbuf); + pstr = ""; +#ifdef HPI_A + pd = &sel->Event.EventDataUnion.UserEvent.UserEventData[0]; +#else + pd = &sel->Event.EventDataUnion.UserEvent.UserEventData.Data[0]; +#endif + + switch(evtype) + { + case SAHPI_ET_SENSOR: /*Sensor*/ + pd = (void *)&(sel->Event.EventDataUnion.SensorEvent); + decode_hpi_event((void *)pd,&outbuf[outlen]); + break; + case SAHPI_ET_USER: /*User, usu 16-byte IPMI SEL record */ + decode_ipmi_event((void *)pd,&outbuf[outlen]); + break; + default: + // decode_ipmi_event((void *)pd,&outbuf[outlen]); + styp = pd[10]; + data3 = pd[15]; + /* *sel->Event.EventDataUnion.SensorEvent.SensorSpecific+1 */ + if (styp >= NSTYPES) { + if (fdebug) printf("sensor type %d >= max %d\n",styp,NSTYPES); + styp = 0; + } + pstr = (char *)sensor_types[styp]; + sprintf(&outbuf[outlen], "%s, %x %x, %02x %02x %02x [%02x %02x %02x/%02x]", + pstr, pd[0], pd[7], pd[10], pd[11], pd[12], + pd[13], pd[14], pd[15], data3); + break; + } + printf("%s\n",outbuf); +} + +static SaErrorT +DoEventLogForResource(SaHpiSessionIdT sessionid, + SaHpiResourceIdT resourceid, + char *tagname) +{ + SaErrorT rv; + SaHpiSelInfoT info; + int free = 50; + SaHpiSelEntryIdT entryid; + SaHpiSelEntryIdT nextentryid; + SaHpiSelEntryIdT preventryid; + SaHpiSelEntryT sel; + SaHpiRdrT rdr; + SaHpiRptEntryT rptentry; + + printf("rptentry[%d] tag: %s\n", resourceid, tagname); + + rv = saHpiEventLogInfoGet(sessionid, resourceid, &info); + if (fdebug) + printf("saHpiEventLogInfoGet %s\n", decode_error(rv)); + if (rv == SA_OK) { + free = info.Size - info.Entries; + printf("EventLog entries=%d, size=%d, enabled=%d, free=%d\n", + info.Entries, info.Size, info.Enabled, free); + } + + entryid = SAHPI_OLDEST_ENTRY; + while ((rv == SA_OK) && (entryid != SAHPI_NO_MORE_ENTRIES)) + { + /* rv = saHpiEventLogEntryGet(sessionid,SAHPI_DOMAIN_CONTROLLER_ID,entryid, */ + rv = saHpiEventLogEntryGet(sessionid, resourceid, entryid, + &preventryid, &nextentryid, &sel, &rdr, &rptentry); + if (fdebug) + printf("saHpiEventLogEntryGet[%x] %s, next=%x\n", + entryid, decode_error(rv), nextentryid); + if (rv == SA_OK) { + ShowSel(&sel, &rdr, &rptentry); + if (entryid == nextentryid) + break; + preventryid = entryid; + entryid = nextentryid; + } + } + + if (free < 6) { + /* + * This test could be more generic if the log info fields above + * were accurate. IPMI SEL logs have a fixed size of 0x10000 + * bytes. New log records are thrown away when it gets full. + * (OLDEST = 0, NO_MORE = fffffffe , so these are ok.) + */ + /* free = (0x10000 - 20) - preventryid; */ + printf( "WARNING: Log free space is very low (%d records)\n" + " Clear log with hpisel -c\n", free); + } + + return SA_OK; +} + +int +main(int argc, char **argv) +{ + int c; + SaErrorT rv; + SaHpiSessionIdT sessionid; +#ifdef HPI_A + SaHpiVersionT hpiVer; + SaHpiRptInfoT rptinfo; +#endif + SaHpiRptEntryT rptentry; + SaHpiEntryIdT rptentryid; + SaHpiEntryIdT nextrptentryid; + SaHpiResourceIdT resourceid; + + printf("%s: version %s\n",argv[0],progver); + +#ifdef HPI_A +#define ARGSTR "cx?" +#else +#define ARGSTR "cdx?" +#endif + + while ( (c = getopt( argc, argv, ARGSTR)) != EOF ) + switch(c) { + case 'c': fclear = 1; break; +#ifndef HPI_A + case 'd': fdomain = 1; break; +#endif + case 'x': fdebug = 1; break; + default: + printf("Usage %s [-cx]\n",argv[0]); + printf("where -c clears the event log\n"); +#ifndef HPI_A + printf(" -d displays the domain event log\n"); +#endif + printf(" -x displays eXtra debug messages\n"); + exit(1); + } +#ifdef HPI_A + rv = saHpiInitialize(&hpiVer); + if (rv != SA_OK) { + printf("saHpiInitialize: %s\n",decode_error(rv)); + exit(-1); + } + rv = saHpiSessionOpen(SAHPI_DEFAULT_DOMAIN_ID,&sessionid,NULL); + if (rv != SA_OK) { + if (rv == SA_ERR_HPI_ERROR) + printf("saHpiSessionOpen: error %d, SpiLibd not running\n",rv); + else + printf("saHpiSessionOpen: %s\n",decode_error(rv)); + exit(-1); + } + rv = saHpiResourcesDiscover(sessionid); + if (fdebug) printf("saHpiResourcesDiscover %s\n",decode_error(rv)); + rv = saHpiRptInfoGet(sessionid,&rptinfo); + if (fdebug) printf("saHpiRptInfoGet %s\n",decode_error(rv)); + printf("RptInfo: UpdateCount = %x, UpdateTime = %lx\n", + rptinfo.UpdateCount, (unsigned long)rptinfo.UpdateTimestamp); +#else + rv = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID,&sessionid,NULL); + if (rv != SA_OK) { + printf("saHpiSessionOpen: %s\n",decode_error(rv)); + exit(-1); + } + rv = saHpiDiscover(sessionid); + if (fdebug) printf("saHpiDiscover %s\n",decode_error(rv)); +#endif + +#ifndef HPI_A + if (fdomain != 0) /* saw option for domain event log */ + { + /* resourceid = 1; * oh_get_default_domain_id() */ + resourceid = SAHPI_UNSPECIFIED_DOMAIN_ID; + if (fclear) { + rv = saHpiEventLogClear(sessionid,resourceid); + if (rv == SA_OK) printf("Domain EventLog successfully cleared\n"); + else printf("Domain EventLog clear, error = %d\n",rv); + } else { + rv = DoEventLogForResource(sessionid, resourceid, "Domain Event Log"); + } + } + else /* walk the RPT list */ +#endif + { + rptentryid = SAHPI_OLDEST_ENTRY; + while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY)) + { + rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry); + if (fdebug) + printf("saHpiRptEntryGet[%d] %s\n",rptentryid,decode_error(rv)); + if (rv != SA_OK) + goto skip_to_next; + resourceid = rptentry.ResourceId; + if (fdebug) printf("RPT %x capabilities = %x\n", resourceid, + rptentry.ResourceCapabilities); + if ((rptentry.ResourceCapabilities & SAHPI_CAPABILITY_SEL) == 0) + goto skip_to_next; + if (fclear) { + rv = saHpiEventLogClear(sessionid,resourceid); + if (rv == SA_OK) printf("EventLog successfully cleared\n"); + else printf("EventLog clear, error = %d\n",rv); + break; + } + // rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0; + + rv = DoEventLogForResource(sessionid, resourceid, + rptentry.ResourceTag.Data); + skip_to_next: + rptentryid = nextrptentryid; + } + } + + rv = saHpiSessionClose(sessionid); +#ifdef HPI_A + rv = saHpiFinalize(); +#endif + + exit(0); +} + +/* end hpisel.c */ -- cgit v1.2.3