summaryrefslogtreecommitdiff
path: root/lib/ipmi_sel.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/ipmi_sel.c')
-rw-r--r--lib/ipmi_sel.c3094
1 files changed, 3094 insertions, 0 deletions
diff --git a/lib/ipmi_sel.c b/lib/ipmi_sel.c
new file mode 100644
index 0000000..21ce0c4
--- /dev/null
+++ b/lib/ipmi_sel.c
@@ -0,0 +1,3094 @@
+/* -*-mode: C; indent-tabs-mode: t; -*-
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution 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.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <string.h>
+#include <math.h>
+#define __USE_XOPEN /* glibc2 needs this for strptime */
+#include <time.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include <ipmitool/helper.h>
+#include <ipmitool/log.h>
+#include <ipmitool/ipmi.h>
+#include <ipmitool/ipmi_mc.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_sel.h>
+#include <ipmitool/ipmi_sdr.h>
+#include <ipmitool/ipmi_fru.h>
+#include <ipmitool/ipmi_sensor.h>
+
+extern int verbose;
+static int sel_extended = 0;
+static int sel_oem_nrecs = 0;
+
+static IPMI_OEM sel_iana = IPMI_OEM_UNKNOWN;
+
+struct ipmi_sel_oem_msg_rec {
+ int value[14];
+ char *string[14];
+ char *text;
+} *sel_oem_msg;
+
+#define SEL_BYTE(n) (n-3) /* So we can refer to byte positions in log entries (byte 3 is at index 0, etc) */
+
+// Definiation for the Decoding the SEL OEM Bytes for DELL Platfoms
+#define BIT(x) (1 << x) /* Select the Bit */
+#define SIZE_OF_DESC 128 /* Max Size of the description String to be displyed for the Each sel entry */
+#define MAX_CARDNO_STR 32 /* Max Size of Card number string */
+#define MAX_DIMM_STR 32 /* Max Size of DIMM string */
+#define MAX_CARD_STR 32 /* Max Size of Card string */
+/*
+ * Reads values found in message translation file. XX is a wildcard, R means reserved.
+ * Returns -1 for XX, -2 for R, -3 for non-hex (string), or positive integer from a hex value.
+ */
+static int ipmi_sel_oem_readval(char *str)
+{
+ int ret;
+ if (!strcmp(str, "XX")) {
+ return -1;
+ }
+ if (!strcmp(str, "R")) {
+ return -2;
+ }
+ if (sscanf(str, "0x%x", &ret) != 1) {
+ return -3;
+ }
+ return ret;
+}
+
+/*
+ * This is where the magic happens. SEL_BYTE is a bit ugly, but it allows
+ * reference to byte positions instead of array indexes which (hopefully)
+ * helps make the code easier to read.
+ */
+static int ipmi_sel_oem_match(uint8_t *evt, struct ipmi_sel_oem_msg_rec rec)
+{
+ if (evt[2] == rec.value[SEL_BYTE(3)] &&
+ ((rec.value[SEL_BYTE(4)] < 0) || (evt[3] == rec.value[SEL_BYTE(4)])) &&
+ ((rec.value[SEL_BYTE(5)] < 0) || (evt[4] == rec.value[SEL_BYTE(5)])) &&
+ ((rec.value[SEL_BYTE(6)] < 0) || (evt[5] == rec.value[SEL_BYTE(6)])) &&
+ ((rec.value[SEL_BYTE(7)] < 0) || (evt[6] == rec.value[SEL_BYTE(7)])) &&
+ ((rec.value[SEL_BYTE(11)] < 0) || (evt[10] == rec.value[SEL_BYTE(11)])) &&
+ ((rec.value[SEL_BYTE(12)] < 0) || (evt[11] == rec.value[SEL_BYTE(12)]))) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+int ipmi_sel_oem_init(const char * filename)
+{
+ FILE * fp;
+ int i, j, k, n, byte;
+ char buf[15][150];
+
+ if (filename == NULL) {
+ lprintf(LOG_ERR, "No SEL OEM filename provided");
+ return -1;
+ }
+
+ fp = ipmi_open_file_read(filename);
+ if (fp == NULL) {
+ lprintf(LOG_ERR, "Could not open %s file", filename);
+ return -1;
+ }
+
+ /* count number of records (lines) in input file */
+ sel_oem_nrecs = 0;
+ while (fscanf(fp, "%*[^\n]\n") == 0) {
+ sel_oem_nrecs++;
+ }
+
+ printf("nrecs=%d\n", sel_oem_nrecs);
+
+ rewind(fp);
+ sel_oem_msg = (struct ipmi_sel_oem_msg_rec *)calloc(sel_oem_nrecs,
+ sizeof(struct ipmi_sel_oem_msg_rec));
+
+ for (i=0; i < sel_oem_nrecs; i++) {
+ n=fscanf(fp, "\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",\""
+ "%[^\"]\",\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",\""
+ "%[^\"]\",\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",\""
+ "%[^\"]\",\"%[^\"]\",\"%[^\"]\"\n",
+ buf[0], buf[1], buf[2], buf[3], buf[4], buf[5],
+ buf[6], buf[7], buf[8], buf[9], buf[10], buf[11],
+ buf[12], buf[13], buf[14]);
+
+ if (n != 15) {
+ lprintf (LOG_ERR, "Encountered problems reading line %d of %s",
+ i+1, filename);
+ fclose(fp);
+ fp = NULL;
+ sel_oem_nrecs = 0;
+ /* free all the memory allocated so far */
+ for (j=0; j<i ; j++) {
+ for (k=3; k<17; k++) {
+ if (sel_oem_msg[j].value[SEL_BYTE(k)] == -3) {
+ free(sel_oem_msg[j].string[SEL_BYTE(k)]);
+ sel_oem_msg[j].string[SEL_BYTE(k)] = NULL;
+ }
+ }
+ }
+ free(sel_oem_msg);
+ sel_oem_msg = NULL;
+ return -1;
+ }
+
+ for (byte = 3; byte < 17; byte++) {
+ if ((sel_oem_msg[i].value[SEL_BYTE(byte)] =
+ ipmi_sel_oem_readval(buf[SEL_BYTE(byte)])) == -3) {
+ sel_oem_msg[i].string[SEL_BYTE(byte)] =
+ (char *)malloc(strlen(buf[SEL_BYTE(byte)]) + 1);
+ strcpy(sel_oem_msg[i].string[SEL_BYTE(byte)],
+ buf[SEL_BYTE(byte)]);
+ }
+ }
+ sel_oem_msg[i].text = (char *)malloc(strlen(buf[SEL_BYTE(17)]) + 1);
+ strcpy(sel_oem_msg[i].text, buf[SEL_BYTE(17)]);
+ }
+
+ fclose(fp);
+ fp = NULL;
+ return 0;
+}
+
+static void ipmi_sel_oem_message(struct sel_event_record * evt, int verbose)
+{
+ /*
+ * Note: although we have a verbose argument, currently the output
+ * isn't affected by it.
+ */
+ int i, j;
+
+ for (i=0; i < sel_oem_nrecs; i++) {
+ if (ipmi_sel_oem_match((uint8_t *)evt, sel_oem_msg[i])) {
+ printf (csv_output ? ",\"%s\"" : " | %s", sel_oem_msg[i].text);
+ for (j=4; j<17; j++) {
+ if (sel_oem_msg[i].value[SEL_BYTE(j)] == -3) {
+ printf (csv_output ? ",%s=0x%x" : " %s = 0x%x",
+ sel_oem_msg[i].string[SEL_BYTE(j)],
+ ((uint8_t *)evt)[SEL_BYTE(j)]);
+ }
+ }
+ }
+ }
+}
+
+static const struct valstr event_dir_vals[] = {
+ { 0, "Assertion Event" },
+ { 1, "Deassertion Event" },
+ { 0, NULL },
+};
+
+static const char *
+ipmi_get_event_type(uint8_t code)
+{
+ if (code == 0)
+ return "Unspecified";
+ if (code == 1)
+ return "Threshold";
+ if (code >= 0x02 && code <= 0x0b)
+ return "Generic Discrete";
+ if (code == 0x6f)
+ return "Sensor-specific Discrete";
+ if (code >= 0x70 && code <= 0x7f)
+ return "OEM";
+ return "Reserved";
+}
+
+static char *
+ipmi_sel_timestamp(uint32_t stamp)
+{
+ static char tbuf[40];
+ time_t s = (time_t)stamp;
+ memset(tbuf, 0, 40);
+ strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", gmtime(&s));
+ return tbuf;
+}
+
+static char *
+ipmi_sel_timestamp_date(uint32_t stamp)
+{
+ static char tbuf[11];
+ time_t s = (time_t)stamp;
+ strftime(tbuf, sizeof(tbuf), "%m/%d/%Y", gmtime(&s));
+ return tbuf;
+}
+
+static char *
+ipmi_sel_timestamp_time(uint32_t stamp)
+{
+ static char tbuf[9];
+ time_t s = (time_t)stamp;
+ strftime(tbuf, sizeof(tbuf), "%H:%M:%S", gmtime(&s));
+ return tbuf;
+}
+
+static char *
+hex2ascii (uint8_t * hexChars, uint8_t numBytes)
+{
+ int count;
+ static char hexString[SEL_OEM_NOTS_DATA_LEN+1]; /*Max Size*/
+
+ if(numBytes > SEL_OEM_NOTS_DATA_LEN)
+ numBytes = SEL_OEM_NOTS_DATA_LEN;
+
+ for(count=0;count < numBytes;count++)
+ {
+ if((hexChars[count]<0x40)||(hexChars[count]>0x7e))
+ hexString[count]='.';
+ else
+ hexString[count]=hexChars[count];
+ }
+ hexString[numBytes]='\0';
+ return hexString;
+}
+
+IPMI_OEM
+ipmi_get_oem(struct ipmi_intf * intf)
+{
+ /* Execute a Get Device ID command to determine the OEM */
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ struct ipm_devid_rsp *devid;
+
+ if (intf->fd == 0) {
+ if( sel_iana != IPMI_OEM_UNKNOWN ){
+ return sel_iana;
+ }
+ return IPMI_OEM_UNKNOWN;
+ }
+
+ /*
+ * Return the cached manufacturer id if the device is open and
+ * we got an identified OEM owner. Otherwise just attempt to read
+ * it.
+ */
+ if (intf->opened && intf->manufacturer_id != IPMI_OEM_UNKNOWN) {
+ return intf->manufacturer_id;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_GET_DEVICE_ID;
+ req.msg.data_len = 0;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Get Device ID command failed");
+ return IPMI_OEM_UNKNOWN;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Get Device ID command failed: %#x %s",
+ rsp->ccode, val2str(rsp->ccode, completion_code_vals));
+ return IPMI_OEM_UNKNOWN;
+ }
+
+ devid = (struct ipm_devid_rsp *) rsp->data;
+
+ lprintf(LOG_DEBUG,"Iana: %u",
+ IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id));
+
+ return IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id);
+}
+
+static int
+ipmi_sel_add_entry(struct ipmi_intf * intf, struct sel_event_record * rec)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_ADD_SEL_ENTRY;
+ req.msg.data = (unsigned char *)rec;
+ req.msg.data_len = 16;
+
+ ipmi_sel_print_std_entry(intf, rec);
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Add SEL Entry failed");
+ return -1;
+ }
+ else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Add SEL Entry failed: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int
+ipmi_sel_add_entries_fromfile(struct ipmi_intf * intf, const char * filename)
+{
+ FILE * fp;
+ char buf[1024];
+ char * ptr, * tok;
+ int i, j;
+ int rc = 0;
+ uint8_t rqdata[8];
+ struct sel_event_record sel_event;
+
+ if (filename == NULL)
+ return -1;
+
+ fp = ipmi_open_file_read(filename);
+ if (fp == NULL)
+ return -1;
+
+ while (feof(fp) == 0) {
+ if (fgets(buf, 1024, fp) == NULL)
+ continue;
+
+ /* clip off optional comment tail indicated by # */
+ ptr = strchr(buf, '#');
+ if (ptr)
+ *ptr = '\0';
+ else
+ ptr = buf + strlen(buf);
+
+ /* clip off trailing and leading whitespace */
+ ptr--;
+ while (isspace((int)*ptr) && ptr >= buf)
+ *ptr-- = '\0';
+ ptr = buf;
+ while (isspace((int)*ptr))
+ ptr++;
+ if (strlen(ptr) == 0)
+ continue;
+
+ /* parse the event, 7 bytes with optional comment */
+ /* 0x00 0x00 0x00 0x00 0x00 0x00 0x00 # event */
+ i = 0;
+ tok = strtok(ptr, " ");
+ while (tok) {
+ if (i == 7)
+ break;
+ j = i++;
+ if (str2uchar(tok, &rqdata[j]) != 0) {
+ break;
+ }
+ tok = strtok(NULL, " ");
+ }
+ if (i < 7) {
+ lprintf(LOG_ERR, "Invalid Event: %s",
+ buf2str(rqdata, sizeof(rqdata)));
+ continue;
+ }
+
+ memset(&sel_event, 0, sizeof(struct sel_event_record));
+ sel_event.record_id = 0x0000;
+ sel_event.record_type = 0x02;
+ sel_event.sel_type.standard_type.gen_id = 0x00;
+ sel_event.sel_type.standard_type.evm_rev = rqdata[0];
+ sel_event.sel_type.standard_type.sensor_type = rqdata[1];
+ sel_event.sel_type.standard_type.sensor_num = rqdata[2];
+ sel_event.sel_type.standard_type.event_type = rqdata[3] & 0x7f;
+ sel_event.sel_type.standard_type.event_dir = (rqdata[3] & 0x80) >> 7;
+ sel_event.sel_type.standard_type.event_data[0] = rqdata[4];
+ sel_event.sel_type.standard_type.event_data[1] = rqdata[5];
+ sel_event.sel_type.standard_type.event_data[2] = rqdata[6];
+
+ rc = ipmi_sel_add_entry(intf, &sel_event);
+ if (rc < 0)
+ break;
+ }
+
+ fclose(fp);
+ return rc;
+}
+
+static struct ipmi_event_sensor_types oem_kontron_event_reading_types[] __attribute__((unused)) = {
+ { 0x70 , 0x00 , 0xff, IPMI_EVENT_CLASS_DISCRETE , "OEM Firmware Info 1", "Code Assert" },
+ { 0x71 , 0x00 , 0xff, IPMI_EVENT_CLASS_DISCRETE , "OEM Firmware Info 2", "Code Assert" },
+};
+
+char *
+get_kontron_evt_desc(struct ipmi_intf * intf, struct sel_event_record * rec)
+{
+ char * description = NULL;
+ /*
+ * Kontron OEM events are described in the product's user manual, but are limited in favor of
+ * sensor specific
+ */
+
+ /* Only standard records are defined so far */
+ if( rec->record_type < 0xC0 ){
+ struct ipmi_event_sensor_types *st=NULL;
+ for ( st=oem_kontron_event_reading_types ; st->type != NULL; st++){
+ if (st->code == rec->sel_type.standard_type.event_type ){
+ size_t len =strlen(st->desc);
+ description = (char*)malloc( len + 1 );
+ memcpy(description, st->desc , len);
+ description[len] = 0;;
+ return description;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+char *
+get_newisys_evt_desc(struct ipmi_intf * intf, struct sel_event_record * rec)
+{
+ /*
+ * Newisys OEM event descriptions can be retrieved through an
+ * OEM IPMI command.
+ */
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t msg_data[6];
+ char * description = NULL;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = 0x2E;
+ req.msg.cmd = 0x01;
+ req.msg.data_len = sizeof(msg_data);
+
+ msg_data[0] = 0x15; /* IANA LSB */
+ msg_data[1] = 0x24; /* IANA */
+ msg_data[2] = 0x00; /* IANA MSB */
+ msg_data[3] = 0x01; /* Subcommand */
+ msg_data[4] = rec->record_id & 0x00FF; /* SEL Record ID LSB */
+ msg_data[5] = (rec->record_id & 0xFF00) >> 8; /* SEL Record ID MSB */
+
+ req.msg.data = msg_data;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ if (verbose)
+ lprintf(LOG_ERR, "Error issuing OEM command");
+ return NULL;
+ }
+ if (rsp->ccode > 0) {
+ if (verbose)
+ lprintf(LOG_ERR, "OEM command returned error code: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return NULL;
+ }
+
+ /* Verify our response before we use it */
+ if (rsp->data_len < 5)
+ {
+ lprintf(LOG_ERR, "Newisys OEM response too short");
+ return NULL;
+ }
+ else if (rsp->data_len != (4 + rsp->data[3]))
+ {
+ lprintf(LOG_ERR, "Newisys OEM response has unexpected length");
+ return NULL;
+ }
+ else if (IPM_DEV_MANUFACTURER_ID(rsp->data) != IPMI_OEM_NEWISYS)
+ {
+ lprintf(LOG_ERR, "Newisys OEM response has unexpected length");
+ return NULL;
+ }
+
+ description = (char*)malloc(rsp->data[3] + 1);
+ memcpy(description, rsp->data + 4, rsp->data[3]);
+ description[rsp->data[3]] = 0;;
+
+ return description;
+}
+
+char *
+get_supermicro_evt_desc(struct ipmi_intf *intf, struct sel_event_record *rec)
+{
+ struct ipmi_rs *rsp;
+ struct ipmi_rq req;
+ char *desc = NULL;
+ char *str;
+ int chipset_type = 1;
+ int data1;
+ int data2;
+ int data3;
+ int length;
+ int sensor_type;
+ uint8_t i = 0;
+ uint16_t oem_id = 0;
+ /* Get the OEM event Bytes of the SEL Records byte 13, 14, 15 to
+ * data1,data2,data3
+ */
+ data1 = rec->sel_type.standard_type.event_data[0];
+ data2 = rec->sel_type.standard_type.event_data[1];
+ data3 = rec->sel_type.standard_type.event_data[2];
+ /* Check for the Standard Event type == 0x6F */
+ if (rec->sel_type.standard_type.event_type != 0x6F) {
+ return NULL;
+ }
+ /* Allocate mem for te Description string */
+ desc = (char *)malloc(SIZE_OF_DESC);
+ if (desc == NULL) {
+ lprintf(LOG_ERR, "ipmitool: malloc failure");
+ return NULL;
+ }
+ memset(desc,0,SIZE_OF_DESC);
+ sensor_type = rec->sel_type.standard_type.sensor_type;
+ switch (sensor_type) {
+ case SENSOR_TYPE_MEMORY:
+ memset(&req, 0, sizeof (req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = BMC_GET_DEVICE_ID;
+ req.msg.data = NULL;
+ req.msg.data_len = 0;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, " Error getting system info");
+ if (desc != NULL) {
+ free(desc);
+ desc = NULL;
+ }
+ return NULL;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, " Error getting system info: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ if (desc != NULL) {
+ free(desc);
+ desc = NULL;
+ }
+ return NULL;
+ }
+ /* check the chipset type */
+ oem_id = ipmi_get_oem_id(intf);
+ if (oem_id == 0) {
+ return NULL;
+ }
+ length = sizeof(supermicro_X8);
+ for (i = 0; i < length; i++) {
+ if (oem_id == supermicro_X8[i]) {
+ chipset_type = 0;
+ break;
+ }
+ }
+ length = sizeof(supermicro_x9);
+ for (i = 0; i < length; i++) {
+ if (oem_id == supermicro_x9[i]) {
+ chipset_type = 2;
+ break;
+ }
+ }
+ if (chipset_type == 0) {
+ snprintf(desc, SIZE_OF_DESC, "@DIMM%2X(CPU%x)",
+ data2,
+ (data3 & 0x03) + 1);
+ } else if (chipset_type == 1) {
+ snprintf(desc, SIZE_OF_DESC, "@DIMM%c%c(CPU%x)",
+ (data2 >> 4) + 0x40 + (data3 & 0x3) * 4,
+ (data2 & 0xf) + 0x27, (data3 & 0x03) + 1);
+ } else if (chipset_type == 2) {
+ snprintf(desc, SIZE_OF_DESC, "@DIMM%c%c(CPU%x)",
+ (data2 >> 4) + 0x40 + (data3 & 0x3) * 3,
+ (data2 & 0xf) + 0x27, (data3 & 0x03) + 1);
+ } else {
+ snprintf(desc, SIZE_OF_DESC, "");
+ }
+ break;
+ case SENSOR_TYPE_SUPERMICRO_OEM:
+ if (data1 == 0x80 && data3 == 0xFF) {
+ if (data2 == 0x0) {
+ snprintf(desc, SIZE_OF_DESC, "BMC unexpected reset");
+ } else if (data2 == 0x1) {
+ snprintf(desc, SIZE_OF_DESC, "BMC cold reset");
+ } else if (data2 == 0x2) {
+ snprintf(desc, SIZE_OF_DESC, "BMC warm reset");
+ }
+ }
+ break;
+ }
+ return desc;
+}
+
+/*
+ * Function : Decoding the SEL OEM Bytes for the DELL Platforms.
+ * Description : The below fucntion will decode the SEL Events OEM Bytes for the Dell specific Sensors only.
+ * The below function will append the additional information Strings/description to the normal sel desc.
+ * With this the SEL will display additional information sent via OEM Bytes of the SEL Record.
+ * NOTE : Specific to DELL Platforms only.
+ * Returns : Pointer to the char string.
+ */
+char * get_dell_evt_desc(struct ipmi_intf * intf, struct sel_event_record * rec)
+{
+ int data1, data2, data3;
+ int sensor_type;
+ char *desc = NULL;
+
+ unsigned char count;
+ unsigned char node;
+ unsigned char num;
+ unsigned char dimmNum;
+ unsigned char dimmsPerNode;
+ char dimmStr[MAX_DIMM_STR];
+ char cardStr[MAX_CARD_STR];
+ char numStr[MAX_CARDNO_STR];
+ char tmpdesc[SIZE_OF_DESC];
+ char* str;
+ unsigned char incr = 0;
+ unsigned char i=0,j = 0;
+ unsigned char postCode;
+ struct ipmi_rs *rsp;
+ struct ipmi_rq req;
+ char tmpData;
+ int version;
+ /* Get the OEM event Bytes of the SEL Records byte 13, 14, 15 to Data1,data2,data3 */
+ data1 = rec->sel_type.standard_type.event_data[0];
+ data2 = rec->sel_type.standard_type.event_data[1];
+ data3 = rec->sel_type.standard_type.event_data[2];
+ /* Check for the Standard Event type == 0x6F */
+ if (0x6F == rec->sel_type.standard_type.event_type)
+ {
+ sensor_type = rec->sel_type.standard_type.sensor_type;
+ /* Allocate mem for te Description string */
+ desc = (char*)malloc(SIZE_OF_DESC);
+ if(NULL == desc)
+ return NULL;
+ memset(desc,0,SIZE_OF_DESC);
+ memset(tmpdesc,0,SIZE_OF_DESC);
+ switch (sensor_type) {
+ case SENSOR_TYPE_PROCESSOR: /* Processor/CPU related OEM Sel Byte Decoding for DELL Platforms only */
+ if((OEM_CODE_IN_BYTE2 == (data1 & DATA_BYTE2_SPECIFIED_MASK)))
+ {
+ if(0x00 == (data1 & MASK_LOWER_NIBBLE))
+ snprintf(desc,SIZE_OF_DESC,"CPU Internal Err | ");
+ if(0x06 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc,SIZE_OF_DESC,"CPU Protocol Err | ");
+
+ }
+
+ /* change bit location to a number */
+ for (count= 0; count < 8; count++)
+ {
+ if (BIT(count)& data2)
+ {
+ count++;
+ /* 0x0A - CPU sensor number */
+ if((0x06 == (data1 & MASK_LOWER_NIBBLE)) && (0x0A == rec->sel_type.standard_type.sensor_num))
+ snprintf(desc,SIZE_OF_DESC,"FSB %d ",count); // Which CPU Has generated the FSB
+ else
+ snprintf(desc,SIZE_OF_DESC,"CPU %d | APIC ID %d ",count,data3); /* Specific CPU related info */
+ break;
+ }
+ }
+ }
+ break;
+ case SENSOR_TYPE_MEMORY: /* Memory or DIMM related OEM Sel Byte Decoding for DELL Platforms only */
+ case SENSOR_TYPE_EVT_LOG: /* Events Logging for Memory or DIMM related OEM Sel Byte Decoding for DELL Platforms only */
+
+ /* Get the current version of the IPMI Spec Based on that Decoding of memory info is done.*/
+ memset(&req, 0, sizeof (req));
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = BMC_GET_DEVICE_ID;
+ req.msg.data = NULL;
+ req.msg.data_len = 0;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (NULL == rsp)
+ {
+ lprintf(LOG_ERR, " Error getting system info");
+ if (desc != NULL) {
+ free(desc);
+ desc = NULL;
+ }
+ return NULL;
+ }
+ else if (rsp->ccode > 0)
+ {
+ lprintf(LOG_ERR, " Error getting system info: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ if (desc != NULL) {
+ free(desc);
+ desc = NULL;
+ }
+ return NULL;
+ }
+ version = rsp->data[4];
+ /* Memory DIMMS */
+ if( (data1 & OEM_CODE_IN_BYTE2) || (data1 & OEM_CODE_IN_BYTE3 ) )
+ {
+ /* Memory Redundancy related oem bytes docoding .. */
+ if( (SENSOR_TYPE_MEMORY == sensor_type) && (0x0B == rec->sel_type.standard_type.event_type) )
+ {
+ if(0x00 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc,SIZE_OF_DESC," Redundancy Regained | ");
+ }
+ else if(0x01 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc,SIZE_OF_DESC,"Redundancy Lost | ");
+ }
+ } /* Correctable and uncorrectable ECC Error Decoding */
+ else if(SENSOR_TYPE_MEMORY == sensor_type)
+ {
+ if(0x00 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ /* 0x1C - Memory Sensor Number */
+ if(0x1C == rec->sel_type.standard_type.sensor_num)
+ {
+ /*Add the complete information about the Memory Configs.*/
+ if((data1 & OEM_CODE_IN_BYTE2) && (data1 & OEM_CODE_IN_BYTE3 ))
+ {
+ count = 0;
+ snprintf(desc,SIZE_OF_DESC,"CRC Error on:");
+ for(i=0;i<4;i++)
+ {
+ if((BIT(i))&(data2))
+ {
+ if(count)
+ {
+ str = desc+strlen(desc);
+ *str++ = ',';
+ str = '\0';
+ count = 0;
+ }
+ switch(i) /* Which type of memory config is present.. */
+ {
+ case 0: snprintf(tmpdesc,SIZE_OF_DESC,"South Bound Memory");
+ strcat(desc,tmpdesc);
+ count++;
+ break;
+ case 1: snprintf(tmpdesc,SIZE_OF_DESC,"South Bound Config");
+ strcat(desc,tmpdesc);
+ count++;
+ break;
+ case 2: snprintf(tmpdesc,SIZE_OF_DESC,"North Bound memory");
+ strcat(desc,tmpdesc);
+ count++;
+ break;
+ case 3: snprintf(tmpdesc,SIZE_OF_DESC,"North Bound memory-corr");
+ strcat(desc,tmpdesc);
+ count++;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ if(data3>=0x00 && data3<0xFF)
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"|Failing_Channel:%d",data3);
+ strcat(desc,tmpdesc);
+ }
+ }
+ break;
+ }
+ snprintf(desc,SIZE_OF_DESC,"Correctable ECC | ");
+ }
+ else if(0x01 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc,SIZE_OF_DESC,"UnCorrectable ECC | ");
+ }
+ } /* Corr Memory log disabled */
+ else if(SENSOR_TYPE_EVT_LOG == sensor_type)
+ {
+ if(0x00 == (data1 & MASK_LOWER_NIBBLE))
+ snprintf(desc,SIZE_OF_DESC,"Corr Memory Log Disabled | ");
+ }
+ }
+ else
+ {
+ if(SENSOR_TYPE_SYS_EVENT == sensor_type)
+ {
+ if(0x02 == (data1 & MASK_LOWER_NIBBLE))
+ snprintf(desc,SIZE_OF_DESC,"Unknown System Hardware Failure ");
+ }
+ if(SENSOR_TYPE_EVT_LOG == sensor_type)
+ {
+ if(0x03 == (data1 & MASK_LOWER_NIBBLE))
+ snprintf(desc,SIZE_OF_DESC,"All Even Logging Dissabled");
+ }
+ }
+ /*
+ * Based on the above error, we need to find whcih memory slot or
+ * Card has got the Errors/Sel Generated.
+ */
+ if(data1 & OEM_CODE_IN_BYTE2 )
+ {
+ /* Find the Card Type */
+ if((0x0F != (data2 >> 4)) && ((data2 >> 4) < 0x08))
+ {
+ tmpData = ('A'+ (data2 >> 4));
+ if( (SENSOR_TYPE_MEMORY == sensor_type) && (0x0B == rec->sel_type.standard_type.event_type) )
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "Bad Card %c", tmpData);
+ }
+ else
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "Card %c", tmpData);
+ }
+ strcat(desc, tmpdesc);
+ } /* Find the Bank Number of the DIMM */
+ if (0x0F != (data2 & MASK_LOWER_NIBBLE))
+ {
+ if(0x51 == version)
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "Bank %d", ((data2 & 0x0F)+1));
+ strcat(desc, tmpdesc);
+ }
+ else
+ {
+ incr = (data2 & 0x0f) << 3;
+ }
+ }
+
+ }
+ /* Find the DIMM Number of the Memory which has Generated the Fault or Sel */
+ if(data1 & OEM_CODE_IN_BYTE3 )
+ {
+ // Based on the IPMI Spec Need Identify the DIMM Details.
+ // For the SPEC 1.5 Only the DIMM Number is Valid.
+ if(0x51 == version)
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "DIMM %c", ('A'+ data3));
+ strcat(desc, tmpdesc);
+ }
+ /* For the SPEC 2.0 Decode the DIMM Number as it supports more.*/
+ else if( ((data2 >> 4) > 0x07) && (0x0F != (data2 >> 4) ))
+ {
+ strcpy(dimmStr, " DIMM");
+ str = desc+strlen(desc);
+ dimmsPerNode = 4;
+ if(0x09 == (data2 >> 4)) dimmsPerNode = 6;
+ else if(0x0A == (data2 >> 4)) dimmsPerNode = 8;
+ else if(0x0B == (data2 >> 4)) dimmsPerNode = 9;
+ else if(0x0C == (data2 >> 4)) dimmsPerNode = 12;
+ else if(0x0D == (data2 >> 4)) dimmsPerNode = 24;
+ else if(0x0E == (data2 >> 4)) dimmsPerNode = 3;
+ count = 0;
+ for (i = 0; i < 8; i++)
+ {
+ if (BIT(i) & data3)
+ {
+ if(count)
+ {
+ strcat(str,",");
+ count = 0x00;
+ }
+ node = (incr + i)/dimmsPerNode;
+ dimmNum = ((incr + i)%dimmsPerNode)+1;
+ dimmStr[5] = node + 'A';
+ sprintf(tmpdesc,"%d",dimmNum);
+ for(j = 0; j < strlen(tmpdesc);j++)
+ dimmStr[6+j] = tmpdesc[j];
+ dimmStr[6+j] = '\0';
+ strcat(str,dimmStr); // final DIMM Details.
+ count++;
+ }
+ }
+ }
+ else
+ {
+ strcpy(dimmStr, " DIMM");
+ str = desc+strlen(desc);
+ count = 0;
+ for (i = 0; i < 8; i++)
+ {
+ if (BIT(i) & data3)
+ {
+ // check if more than one DIMM, if so add a comma to the string.
+ sprintf(tmpdesc,"%d",(i + incr + 1));
+ if(count)
+ {
+ strcat(str,",");
+ count = 0x00;
+ }
+ for(j = 0; j < strlen(tmpdesc);j++)
+ dimmStr[5+j] = tmpdesc[j];
+ dimmStr[5+j] = '\0';
+ strcat(str, dimmStr);
+ count++;
+ }
+ }
+ }
+ }
+ break;
+ /* Sensor In system charectorization Error Decoding.
+ Sensor type 0x20*/
+ case SENSOR_TYPE_TXT_CMD_ERROR:
+ if((0x00 == (data1 & MASK_LOWER_NIBBLE))&&((data1 & OEM_CODE_IN_BYTE2) && (data1 & OEM_CODE_IN_BYTE3)))
+ {
+ switch(data3)
+ {
+ case 0x01:
+ snprintf(desc,SIZE_OF_DESC,"BIOS TXT Error");
+ break;
+ case 0x02:
+ snprintf(desc,SIZE_OF_DESC,"Processor/FIT TXT");
+ break;
+ case 0x03:
+ snprintf(desc,SIZE_OF_DESC,"BIOS ACM TXT Error");
+ break;
+ case 0x04:
+ snprintf(desc,SIZE_OF_DESC,"SINIT ACM TXT Error");
+ break;
+ case 0xff:
+ snprintf(desc,SIZE_OF_DESC,"Unrecognized TT Error12");
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ /* OS Watch Dog Timer Sel Events */
+ case SENSOR_TYPE_WTDOG:
+
+ if(SENSOR_TYPE_OEM_SEC_EVENT == data1)
+ {
+ if(0x04 == data2)
+ {
+ snprintf(desc,SIZE_OF_DESC,"Hard Reset|Interrupt type None,SMS/OS Timer used at expiration");
+ }
+ }
+
+ break;
+ /* This Event is for BMC to Othe Hardware or CPU . */
+ case SENSOR_TYPE_VER_CHANGE:
+ if((0x02 == (data1 & MASK_LOWER_NIBBLE))&&((data1 & OEM_CODE_IN_BYTE2) && (data1 & OEM_CODE_IN_BYTE3)))
+ {
+ if(0x02 == data2)
+ {
+ if(0x00 == data3)
+ {
+ snprintf(desc, SIZE_OF_DESC, "between BMC/iDRAC Firmware and other hardware");
+ }
+ else if(0x01 == data3)
+ {
+ snprintf(desc, SIZE_OF_DESC, "between BMC/iDRAC Firmware and CPU");
+ }
+ }
+ }
+ break;
+ /* Flex or Mac tuning OEM Decoding for the DELL. */
+ case SENSOR_TYPE_OEM_SEC_EVENT:
+ /* 0x25 - Virtual MAC sensory number - Dell OEM */
+ if(0x25 == rec->sel_type.standard_type.sensor_num)
+ {
+ if(0x01 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc, SIZE_OF_DESC, "Failed to program Virtual Mac Address");
+ if((data1 & OEM_CODE_IN_BYTE2)&&(data1 & OEM_CODE_IN_BYTE3))
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, " at bus:%.2x device:%.2x function:%x",
+ data3 &0x7F, (data2 >> 3) & 0x1F,
+ data2 & 0x07);
+ strcat(desc,tmpdesc);
+ }
+ }
+ else if(0x02 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc, SIZE_OF_DESC, "Device option ROM failed to support link tuning or flex address");
+ }
+ else if(0x03 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc, SIZE_OF_DESC, "Failed to get link tuning or flex address data from BMC/iDRAC");
+ }
+ }
+ break;
+ case SENSOR_TYPE_CRIT_INTR:
+ case SENSOR_TYPE_OEM_NFATAL_ERROR: /* Non - Fatal PCIe Express Error Decoding */
+ case SENSOR_TYPE_OEM_FATAL_ERROR: /* Fatal IO Error Decoding */
+ /* 0x29 - QPI Linx Error Sensor Dell OEM */
+ if(0x29 == rec->sel_type.standard_type.sensor_num)
+ {
+ if((0x02 == (data1 & MASK_LOWER_NIBBLE))&&((data1 & OEM_CODE_IN_BYTE2) && (data1 & OEM_CODE_IN_BYTE3)))
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "Partner-(LinkId:%d,AgentId:%d)|",(data2 & 0xC0),(data2 & 0x30));
+ strcat(desc,tmpdesc);
+ snprintf(tmpdesc, SIZE_OF_DESC, "ReportingAgent(LinkId:%d,AgentId:%d)|",(data2 & 0x0C),(data2 & 0x03));
+ strcat(desc,tmpdesc);
+ if(0x00 == (data3 & 0xFC))
+ {
+ snprintf(tmpdesc, SIZE_OF_DESC, "LinkWidthDegraded|");
+ strcat(desc,tmpdesc);
+ }
+ if(BIT(1)& data3)
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"PA_Type:IOH|");
+ }
+ else
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"PA-Type:CPU|");
+ }
+ strcat(desc,tmpdesc);
+ if(BIT(0)& data3)
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"RA-Type:IOH");
+ }
+ else
+ {
+ snprintf(tmpdesc,SIZE_OF_DESC,"RA-Type:CPU");
+ }
+ strcat(desc,tmpdesc);
+ }
+ }
+ else
+ {
+
+ if(0x02 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ sprintf(desc,"%s","IO channel Check NMI");
+ }
+ else
+ {
+ if(0x00 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s","PCIe Error |");
+ }
+ else if(0x01 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s","I/O Error |");
+ }
+ else if(0x04 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s","PCI PERR |");
+ }
+ else if(0x05 == (data1 & MASK_LOWER_NIBBLE))
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s","PCI SERR |");
+ }
+ else
+ {
+ snprintf(desc, SIZE_OF_DESC, "%s"," ");
+ }
+ if (data3 & 0x80)
+ snprintf(tmpdesc, SIZE_OF_DESC, "Slot %d", data3 & 0x7F);
+ else
+ snprintf(tmpdesc, SIZE_OF_DESC, "PCI bus:%.2x device:%.2x function:%x",
+ data3 &0x7F, (data2 >> 3) & 0x1F,
+ data2 & 0x07);
+
+ strcat(desc,tmpdesc);
+ }
+ }
+ break;
+ /* POST Fatal Errors generated from the Server with much more info*/
+ case SENSOR_TYPE_FRM_PROG:
+ if((0x0F == (data1 & MASK_LOWER_NIBBLE))&&(data1 & OEM_CODE_IN_BYTE2))
+ {
+ switch(data2)
+ {
+ case 0x80:
+ snprintf(desc, SIZE_OF_DESC, "No memory is detected.");break;
+ case 0x81:
+ snprintf(desc,SIZE_OF_DESC, "Memory is detected but is not configurable.");break;
+ case 0x82:
+ snprintf(desc, SIZE_OF_DESC, "Memory is configured but not usable.");break;
+ case 0x83:
+ snprintf(desc, SIZE_OF_DESC, "System BIOS shadow failed.");break;
+ case 0x84:
+ snprintf(desc, SIZE_OF_DESC, "CMOS failed.");break;
+ case 0x85:
+ snprintf(desc, SIZE_OF_DESC, "DMA controller failed.");break;
+ case 0x86:
+ snprintf(desc, SIZE_OF_DESC, "Interrupt controller failed.");break;
+ case 0x87:
+ snprintf(desc, SIZE_OF_DESC, "Timer refresh failed.");break;
+ case 0x88:
+ snprintf(desc, SIZE_OF_DESC, "Programmable interval timer error.");break;
+ case 0x89:
+ snprintf(desc, SIZE_OF_DESC, "Parity error.");break;
+ case 0x8A:
+ snprintf(desc, SIZE_OF_DESC, "SIO failed.");break;
+ case 0x8B:
+ snprintf(desc, SIZE_OF_DESC, "Keyboard controller failed.");break;
+ case 0x8C:
+ snprintf(desc, SIZE_OF_DESC, "System management interrupt initialization failed.");break;
+ case 0x8D:
+ snprintf(desc, SIZE_OF_DESC, "TXT-SX Error.");break;
+ case 0xC0:
+ snprintf(desc, SIZE_OF_DESC, "Shutdown test failed.");break;
+ case 0xC1:
+ snprintf(desc, SIZE_OF_DESC, "BIOS POST memory test failed.");break;
+ case 0xC2:
+ snprintf(desc, SIZE_OF_DESC, "RAC configuration failed.");break;
+ case 0xC3:
+ snprintf(desc, SIZE_OF_DESC, "CPU configuration failed.");break;
+ case 0xC4:
+ snprintf(desc, SIZE_OF_DESC, "Incorrect memory configuration.");break;
+ case 0xFE:
+ snprintf(desc, SIZE_OF_DESC, "General failure after video.");
+ break;
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ else
+ {
+ sensor_type = rec->sel_type.standard_type.event_type;
+ }
+ return desc;
+}
+
+char *
+ipmi_get_oem_desc(struct ipmi_intf * intf, struct sel_event_record * rec)
+{
+ char * desc = NULL;
+
+ switch (ipmi_get_oem(intf))
+ {
+ case IPMI_OEM_NEWISYS:
+ desc = get_newisys_evt_desc(intf, rec);
+ break;
+ case IPMI_OEM_KONTRON:
+ desc = get_kontron_evt_desc(intf, rec);
+ break;
+ case IPMI_OEM_DELL: // Dell Decoding of the OEM Bytes from SEL Record.
+ desc = get_dell_evt_desc(intf, rec);
+ break;
+ case IPMI_OEM_SUPERMICRO:
+ case IPMI_OEM_SUPERMICRO_47488:
+ desc = get_supermicro_evt_desc(intf, rec);
+ break;
+ case IPMI_OEM_UNKNOWN:
+ default:
+ break;
+ }
+
+ return desc;
+}
+
+
+void
+ipmi_get_event_desc(struct ipmi_intf * intf, struct sel_event_record * rec, char ** desc)
+{
+ uint8_t code, offset;
+ struct ipmi_event_sensor_types *evt = NULL;
+ char *sfx = NULL; /* This will be assigned if the Platform is DELL,
+ additional info is appended to the current Description */
+
+ if (desc == NULL)
+ return;
+ *desc = NULL;
+
+ if ((rec->sel_type.standard_type.event_type >= 0x70) && (rec->sel_type.standard_type.event_type < 0x7F)) {
+ *desc = ipmi_get_oem_desc(intf, rec);
+ return;
+ } else if (rec->sel_type.standard_type.event_type == 0x6f) {
+ if( rec->sel_type.standard_type.sensor_type >= 0xC0 && rec->sel_type.standard_type.sensor_type < 0xF0) {
+ IPMI_OEM iana = ipmi_get_oem(intf);
+
+ switch(iana){
+ case IPMI_OEM_KONTRON:
+ lprintf(LOG_DEBUG, "oem sensor type %x %d using oem type supplied description",
+ rec->sel_type.standard_type.sensor_type , iana);
+
+ evt = oem_kontron_event_types;
+ code = rec->sel_type.standard_type.sensor_type;
+ break;
+ case IPMI_OEM_DELL: /* OEM Bytes Decoding for DELLi */
+ evt = sensor_specific_types;
+ code = rec->sel_type.standard_type.sensor_type;
+ if ( (OEM_CODE_IN_BYTE2 == (rec->sel_type.standard_type.event_data[0] & DATA_BYTE2_SPECIFIED_MASK)) ||
+ (OEM_CODE_IN_BYTE3 == (rec->sel_type.standard_type.event_data[0] & DATA_BYTE3_SPECIFIED_MASK)) )
+ {
+ if(rec->sel_type.standard_type.event_data[0] & DATA_BYTE2_SPECIFIED_MASK)
+ evt->data = rec->sel_type.standard_type.event_data[1];
+
+ sfx = ipmi_get_oem_desc(intf, rec);
+ }
+ break;
+ case IPMI_OEM_SUPERMICRO:
+ case IPMI_OEM_SUPERMICRO_47488:
+ evt = sensor_specific_types;
+ code = rec->sel_type.standard_type.sensor_type;
+ sfx = ipmi_get_oem_desc(intf, rec);
+ break;
+ /* add your oem sensor assignation here */
+ }
+ if( evt == NULL ){
+ lprintf(LOG_DEBUG, "oem sensor type %x using standard type supplied description",
+ rec->sel_type.standard_type.sensor_type );
+ }
+ } else {
+ switch (ipmi_get_oem(intf)) {
+ case IPMI_OEM_SUPERMICRO:
+ case IPMI_OEM_SUPERMICRO_47488:
+ evt = sensor_specific_types;
+ code = rec->sel_type.standard_type.sensor_type;
+ sfx = ipmi_get_oem_desc(intf, rec);
+ break;
+ }
+ }
+ if( evt == NULL ){
+ evt = sensor_specific_types;
+ code = rec->sel_type.standard_type.sensor_type;
+ }
+ /*
+ * Check for the OEM DELL Interface based on the Dell Specific Vendor Code.
+ * If its Dell Platform, do the OEM Byte decode from the SEL Records.
+ * Additional information should be written by the ipmi_get_oem_desc()
+ */
+ if(ipmi_get_oem(intf) == IPMI_OEM_DELL) {
+ code = rec->sel_type.standard_type.sensor_type;
+ if ( (OEM_CODE_IN_BYTE2 == (rec->sel_type.standard_type.event_data[0] & DATA_BYTE2_SPECIFIED_MASK)) ||
+ (OEM_CODE_IN_BYTE3 == (rec->sel_type.standard_type.event_data[0] & DATA_BYTE3_SPECIFIED_MASK)) )
+ {
+ if(rec->sel_type.standard_type.event_data[0] & DATA_BYTE2_SPECIFIED_MASK)
+ evt->data = rec->sel_type.standard_type.event_data[1];
+ sfx = ipmi_get_oem_desc(intf, rec);
+
+ }
+ else if(SENSOR_TYPE_OEM_SEC_EVENT == rec->sel_type.standard_type.event_data[0])
+ {
+ /* 0x23 : Sensor Number.*/
+ if(0x23 == rec->sel_type.standard_type.sensor_num)
+ {
+ evt->data = rec->sel_type.standard_type.event_data[1];
+ sfx = ipmi_get_oem_desc(intf, rec);
+ }
+ }
+ }
+ } else {
+ evt = generic_event_types;
+ code = rec->sel_type.standard_type.event_type;
+ }
+
+ offset = rec->sel_type.standard_type.event_data[0] & 0xf;
+
+ while (evt->type) {
+ if ((evt->code == code && evt->offset == offset && evt->desc != NULL) &&
+ ((evt->data == ALL_OFFSETS_SPECIFIED) ||
+ ((rec->sel_type.standard_type.event_data[0] & DATA_BYTE2_SPECIFIED_MASK) &&
+ (evt->data == rec->sel_type.standard_type.event_data[1]))))
+ {
+ /* Increase the Malloc size to current_size + Dellspecific description size */
+ *desc = (char *)malloc(strlen(evt->desc) + 48 + SIZE_OF_DESC);
+ if (NULL == *desc) {
+ lprintf(LOG_ERR, "ipmitool: malloc failure");
+ return;
+ }
+ memset(*desc, 0, strlen(evt->desc)+ 48 + SIZE_OF_DESC);
+ /*
+ * Additional info is present for the DELL Platforms.
+ * Append the same to the evt->desc string.
+ */
+ if (sfx) {
+ sprintf(*desc, "%s (%s)", evt->desc, sfx);
+ free(sfx);
+ sfx = NULL;
+ } else {
+ sprintf(*desc, "%s", evt->desc);
+ }
+ return;
+ }
+ evt++;
+ }
+ /* The Above while Condition was not met beacouse the below sensor type were Newly defined OEM
+ Secondary Events. 0xC1, 0xC2, 0xC3. */
+ if((sfx) && (0x6F == rec->sel_type.standard_type.event_type))
+ {
+ uint8_t flag = 0x00;
+ switch(code)
+ {
+ case SENSOR_TYPE_FRM_PROG:
+ if(0x0F == offset)
+ flag = 0x01;
+ break;
+ case SENSOR_TYPE_OEM_SEC_EVENT:
+ if((0x01 == offset) || (0x02 == offset) || (0x03 == offset))
+ flag = 0x01;
+ break;
+ case SENSOR_TYPE_OEM_NFATAL_ERROR:
+ if((0x00 == offset) || (0x02 == offset))
+ flag = 0x01;
+ break;
+ case SENSOR_TYPE_OEM_FATAL_ERROR:
+ if(0x01 == offset)
+ flag = 0x01;
+ break;
+ case SENSOR_TYPE_SUPERMICRO_OEM:
+ flag = 0x02;
+ break;
+ default:
+ break;
+ }
+ if(flag)
+ {
+ *desc = (char *)malloc( 48 + SIZE_OF_DESC);
+ if (NULL == *desc)
+ {
+ lprintf(LOG_ERR, "ipmitool: malloc failure");
+ return;
+ }
+ memset(*desc, 0, 48 + SIZE_OF_DESC);
+ if (flag == 0x02) {
+ sprintf(*desc, "%s", sfx);
+ return;
+ }
+ sprintf(*desc, "(%s)",sfx);
+ }
+ free(sfx);
+ sfx = NULL;
+ }
+}
+
+
+const char *
+ipmi_sel_get_oem_sensor_type(IPMI_OEM iana, uint8_t code)
+{
+ struct ipmi_event_sensor_types *st = NULL;
+
+ switch(iana){
+ case IPMI_OEM_KONTRON:
+ st = oem_kontron_event_types;
+ break;
+ /* add you oem sensor type lookup assignement here */
+ default:
+ lprintf(LOG_DEBUG, "ipmitool: missing OEM sensor type for %ul",iana);
+ break;
+ }
+
+ if( st != NULL )
+ for (; st->type != NULL; st++)
+ if (st->code == code)
+ return st->type;
+
+ return ipmi_sel_get_sensor_type(code);
+}
+
+const char *
+ipmi_sel_get_oem_sensor_type_offset(IPMI_OEM iana, uint8_t code, uint8_t offset)
+{
+ struct ipmi_event_sensor_types *st = NULL;
+
+ switch(iana){
+ case IPMI_OEM_KONTRON:
+ st = oem_kontron_event_types;
+ break;
+ /* add you oem sensor type lookup assignement here */
+ default:
+ lprintf(LOG_DEBUG,
+ "ipmitool: missing OEM sensor type offset for %ul",iana);
+ break;
+ }
+
+ if( st != NULL )
+ for (; st->type != NULL; st++)
+ {
+ if (st->code == code && st->offset == (offset&0xf))
+ return st->type;
+ }
+
+ return ipmi_sel_get_oem_sensor_type(iana,code);
+}
+
+const char *
+ipmi_sel_get_sensor_type(uint8_t code)
+{
+ struct ipmi_event_sensor_types *st;
+ for (st = sensor_specific_types; st->type != NULL; st++)
+ if (st->code == code)
+ return st->type;
+ return "Unknown";
+}
+
+const char *
+ipmi_sel_get_sensor_type_offset(uint8_t code, uint8_t offset)
+{
+ struct ipmi_event_sensor_types *st;
+ for (st = sensor_specific_types; st->type != NULL; st++)
+ if (st->code == code && st->offset == (offset&0xf))
+ return st->type;
+
+ return ipmi_sel_get_sensor_type(code);
+}
+
+static int
+ipmi_sel_get_info(struct ipmi_intf * intf)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint16_t e, version;
+ uint32_t f;
+ int pctfull = 0;
+ uint32_t fs = 0xffffffff;
+ uint32_t zeros = 0;
+
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_GET_SEL_INFO;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Get SEL Info command failed");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Get SEL Info command failed: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 2)
+ printbuf(rsp->data, rsp->data_len, "sel_info");
+
+ printf("SEL Information\n");
+ version = rsp->data[0];
+ printf("Version : %d.%d (%s)\n",
+ version & 0xf, (version>>4) & 0xf,
+ (version == 0x51 || version == 0x02) ? "v1.5, v2 compliant" : "Unknown");
+
+ /* save the entry count and free space to determine percent full */
+ e = buf2short(rsp->data + 1);
+ f = buf2short(rsp->data + 3);
+ printf("Entries : %d\n", e);
+ printf("Free Space : %d bytes %s\n", f ,(f==65535 ? "or more" : "" ));
+
+ if (e) {
+ e *= 16; /* each entry takes 16 bytes */
+ f += e; /* this is supposed to give the total size ... */
+ pctfull = (int)(100 * ( (double)e / (double)f ));
+ }
+
+ if( f >= 65535 ) {
+ printf("Percent Used : %s\n", "unknown" );
+ }
+ else {
+ printf("Percent Used : %d%%\n", pctfull);
+ }
+
+
+ if ((!memcmp(rsp->data + 5, &fs, 4)) ||
+ (!memcmp(rsp->data + 5, &zeros, 4)))
+ printf("Last Add Time : Not Available\n");
+ else
+ printf("Last Add Time : %s\n",
+ ipmi_sel_timestamp(buf2long(rsp->data + 5)));
+
+ if ((!memcmp(rsp->data + 9, &fs, 4)) ||
+ (!memcmp(rsp->data + 9, &zeros, 4)))
+ printf("Last Del Time : Not Available\n");
+ else
+ printf("Last Del Time : %s\n",
+ ipmi_sel_timestamp(buf2long(rsp->data + 9)));
+
+
+ printf("Overflow : %s\n",
+ rsp->data[13] & 0x80 ? "true" : "false");
+ printf("Supported Cmds : ");
+ if (rsp->data[13] & 0x0f)
+ {
+ if (rsp->data[13] & 0x08)
+ printf("'Delete' ");
+ if (rsp->data[13] & 0x04)
+ printf("'Partial Add' ");
+ if (rsp->data[13] & 0x02)
+ printf("'Reserve' ");
+ if (rsp->data[13] & 0x01)
+ printf("'Get Alloc Info' ");
+ }
+ else
+ printf("None");
+ printf("\n");
+
+ /* get sel allocation info if supported */
+ if (rsp->data[13] & 1) {
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_GET_SEL_ALLOC_INFO;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR,
+ "Get SEL Allocation Info command failed");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR,
+ "Get SEL Allocation Info command failed: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+
+ printf("# of Alloc Units : %d\n", buf2short(rsp->data));
+ printf("Alloc Unit Size : %d\n", buf2short(rsp->data + 2));
+ printf("# Free Units : %d\n", buf2short(rsp->data + 4));
+ printf("Largest Free Blk : %d\n", buf2short(rsp->data + 6));
+ printf("Max Record Size : %d\n", rsp->data[8]);
+ }
+ return 0;
+}
+
+uint16_t
+ipmi_sel_get_std_entry(struct ipmi_intf * intf, uint16_t id,
+ struct sel_event_record * evt)
+{
+ struct ipmi_rq req;
+ struct ipmi_rs * rsp;
+ uint8_t msg_data[6];
+ uint16_t next;
+ int data_count;
+
+ memset(msg_data, 0, 6);
+ msg_data[0] = 0x00; /* no reserve id, not partial get */
+ msg_data[1] = 0x00;
+ msg_data[2] = id & 0xff;
+ msg_data[3] = (id >> 8) & 0xff;
+ msg_data[4] = 0x00; /* offset */
+ msg_data[5] = 0xff; /* length */
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_GET_SEL_ENTRY;
+ req.msg.data = msg_data;
+ req.msg.data_len = 6;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Get SEL Entry %x command failed", id);
+ return 0;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Get SEL Entry %x command failed: %s",
+ id, val2str(rsp->ccode, completion_code_vals));
+ return 0;
+ }
+
+ /* save next entry id */
+ next = (rsp->data[1] << 8) | rsp->data[0];
+
+ lprintf(LOG_DEBUG, "SEL Entry: %s", buf2str(rsp->data+2, rsp->data_len-2));
+ memset(evt, 0, sizeof(*evt));
+
+ /*Clear SEL Structure*/
+ evt->record_id = 0;
+ evt->record_type = 0;
+ if (evt->record_type < 0xc0)
+ {
+ evt->sel_type.standard_type.timestamp = 0;
+ evt->sel_type.standard_type.gen_id = 0;
+ evt->sel_type.standard_type.evm_rev = 0;
+ evt->sel_type.standard_type.sensor_type = 0;
+ evt->sel_type.standard_type.sensor_num = 0;
+ evt->sel_type.standard_type.event_type = 0;
+ evt->sel_type.standard_type.event_dir = 0;
+ evt->sel_type.standard_type.event_data[0] = 0;
+ evt->sel_type.standard_type.event_data[1] = 0;
+ evt->sel_type.standard_type.event_data[2] = 0;
+ }
+ else if (evt->record_type < 0xe0)
+ {
+ evt->sel_type.oem_ts_type.timestamp = 0;
+ evt->sel_type.oem_ts_type.manf_id[0] = 0;
+ evt->sel_type.oem_ts_type.manf_id[1] = 0;
+ evt->sel_type.oem_ts_type.manf_id[2] = 0;
+ for(data_count=0; data_count < SEL_OEM_TS_DATA_LEN ; data_count++)
+ evt->sel_type.oem_ts_type.oem_defined[data_count] = 0;
+ }
+ else
+ {
+ for(data_count=0; data_count < SEL_OEM_NOTS_DATA_LEN ; data_count++)
+ evt->sel_type.oem_nots_type.oem_defined[data_count] = 0;
+ }
+
+ /* save response into SEL event structure */
+ evt->record_id = (rsp->data[3] << 8) | rsp->data[2];
+ evt->record_type = rsp->data[4];
+ if (evt->record_type < 0xc0)
+ {
+ evt->sel_type.standard_type.timestamp = (rsp->data[8] << 24) | (rsp->data[7] << 16) |
+ (rsp->data[6] << 8) | rsp->data[5];
+ evt->sel_type.standard_type.gen_id = (rsp->data[10] << 8) | rsp->data[9];
+ evt->sel_type.standard_type.evm_rev = rsp->data[11];
+ evt->sel_type.standard_type.sensor_type = rsp->data[12];
+ evt->sel_type.standard_type.sensor_num = rsp->data[13];
+ evt->sel_type.standard_type.event_type = rsp->data[14] & 0x7f;
+ evt->sel_type.standard_type.event_dir = (rsp->data[14] & 0x80) >> 7;
+ evt->sel_type.standard_type.event_data[0] = rsp->data[15];
+ evt->sel_type.standard_type.event_data[1] = rsp->data[16];
+ evt->sel_type.standard_type.event_data[2] = rsp->data[17];
+ }
+ else if (evt->record_type < 0xe0)
+ {
+ evt->sel_type.oem_ts_type.timestamp= (rsp->data[8] << 24) | (rsp->data[7] << 16) |
+ (rsp->data[6] << 8) | rsp->data[5];
+ evt->sel_type.oem_ts_type.manf_id[0]= rsp->data[11];
+ evt->sel_type.oem_ts_type.manf_id[1]= rsp->data[10];
+ evt->sel_type.oem_ts_type.manf_id[2]= rsp->data[9];
+ for(data_count=0; data_count < SEL_OEM_TS_DATA_LEN ; data_count++)
+ evt->sel_type.oem_ts_type.oem_defined[data_count] = rsp->data[(data_count+12)];
+ }
+ else
+ {
+ for(data_count=0; data_count < SEL_OEM_NOTS_DATA_LEN ; data_count++)
+ evt->sel_type.oem_nots_type.oem_defined[data_count] = rsp->data[(data_count+5)];
+ }
+ return next;
+}
+
+static void
+ipmi_sel_print_event_file(struct ipmi_intf * intf, struct sel_event_record * evt, FILE * fp)
+{
+ char * description;
+
+ if (fp == NULL)
+ return;
+
+ ipmi_get_event_desc(intf, evt, &description);
+
+ fprintf(fp, "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x # %s #0x%02x %s\n",
+ evt->sel_type.standard_type.evm_rev,
+ evt->sel_type.standard_type.sensor_type,
+ evt->sel_type.standard_type.sensor_num,
+ evt->sel_type.standard_type.event_type | (evt->sel_type.standard_type.event_dir << 7),
+ evt->sel_type.standard_type.event_data[0],
+ evt->sel_type.standard_type.event_data[1],
+ evt->sel_type.standard_type.event_data[2],
+ (
+ (evt->sel_type.standard_type.sensor_type >=0xC0 && evt->sel_type.standard_type.sensor_type < 0xF0)
+ ?
+ ipmi_sel_get_oem_sensor_type_offset(ipmi_get_oem(intf),evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0])
+ :
+ ipmi_sel_get_sensor_type_offset(evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0])
+ ),
+ evt->sel_type.standard_type.sensor_num,
+ (description != NULL) ? description : "Unknown");
+
+ if (description != NULL) {
+ free(description);
+ description = NULL;
+ }
+}
+
+void
+ipmi_sel_print_extended_entry(struct ipmi_intf * intf, struct sel_event_record * evt)
+{
+ sel_extended++;
+ ipmi_sel_print_std_entry(intf, evt);
+ sel_extended--;
+}
+
+void
+ipmi_sel_print_std_entry(struct ipmi_intf * intf, struct sel_event_record * evt)
+{
+ char * description;
+ struct sdr_record_list * sdr = NULL;
+ int data_count;
+
+ if (sel_extended && (evt->record_type < 0xc0))
+ sdr = ipmi_sdr_find_sdr_bynumtype(intf, evt->sel_type.standard_type.gen_id, evt->sel_type.standard_type.sensor_num, evt->sel_type.standard_type.sensor_type);
+
+
+ if (!evt)
+ return;
+
+ if (csv_output)
+ printf("%x,", evt->record_id);
+ else
+ printf("%4x | ", evt->record_id);
+
+ if (evt->record_type == 0xf0)
+ {
+ if (csv_output)
+ printf(",,");
+
+ printf ("Linux kernel panic: %.11s\n", (char *) evt + 5);
+ return;
+ }
+
+ if (evt->record_type < 0xe0)
+ {
+ if ((evt->sel_type.standard_type.timestamp < 0x20000000)||(evt->sel_type.oem_ts_type.timestamp < 0x20000000)){
+ printf(" Pre-Init ");
+
+ if (csv_output)
+ printf(",");
+ else
+ printf(" |");
+
+ printf("%010d", evt->sel_type.standard_type.timestamp );
+ if (csv_output)
+ printf(",");
+ else
+ printf("| ");
+ }
+ else {
+ if (evt->record_type < 0xc0)
+ printf("%s", ipmi_sel_timestamp_date(evt->sel_type.standard_type.timestamp));
+ else
+ printf("%s", ipmi_sel_timestamp_date(evt->sel_type.oem_ts_type.timestamp));
+ if (csv_output)
+ printf(",");
+ else
+ printf(" | ");
+
+ if (evt->record_type < 0xc0)
+ printf("%s", ipmi_sel_timestamp_time(evt->sel_type.standard_type.timestamp));
+ else
+ printf("%s", ipmi_sel_timestamp_time(evt->sel_type.oem_ts_type.timestamp));
+
+ if (csv_output)
+ printf(",");
+ else
+ printf(" | ");
+ }
+
+ }
+ else
+ {
+ if (csv_output)
+ printf(",,");
+ }
+
+ if (evt->record_type >= 0xc0)
+ {
+ printf ("OEM record %02x", evt->record_type);
+ if (csv_output)
+ printf(",");
+ else
+ printf(" | ");
+
+ if(evt->record_type < 0xdf)
+ {
+ printf ("%02x%02x%02x", evt->sel_type.oem_ts_type.manf_id[0], evt->sel_type.oem_ts_type.manf_id[1], evt->sel_type.oem_ts_type.manf_id[2]);
+ if (csv_output)
+ printf(",");
+ else
+ printf(" | ");
+ for(data_count=0;data_count < SEL_OEM_TS_DATA_LEN;data_count++)
+ printf("%02x", evt->sel_type.oem_ts_type.oem_defined[data_count]);
+ }
+ else
+ {
+ for(data_count=0;data_count < SEL_OEM_NOTS_DATA_LEN;data_count++)
+ printf("%02x", evt->sel_type.oem_nots_type.oem_defined[data_count]);
+ }
+ ipmi_sel_oem_message(evt, 0);
+ printf ("\n");
+ return;
+ }
+
+ /* lookup SDR entry based on sensor number and type */
+ if (sdr != NULL) {
+ printf("%s ",
+ (
+ (evt->sel_type.standard_type.sensor_type >=0xC0 && evt->sel_type.standard_type.sensor_type < 0xF0)
+ ?
+ ipmi_sel_get_oem_sensor_type_offset(ipmi_get_oem(intf),evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0])
+ :
+ ipmi_sel_get_sensor_type_offset(evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0])
+ )
+ );
+ switch (sdr->type) {
+ case SDR_RECORD_TYPE_FULL_SENSOR:
+ printf("%s", sdr->record.full->id_string);
+ break;
+ case SDR_RECORD_TYPE_COMPACT_SENSOR:
+ printf("%s", sdr->record.compact->id_string);
+ break;
+ case SDR_RECORD_TYPE_EVENTONLY_SENSOR:
+ printf("%s", sdr->record.eventonly->id_string);
+ break;
+ case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR:
+ printf("%s", sdr->record.fruloc->id_string);
+ break;
+ case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR:
+ printf("%s", sdr->record.mcloc->id_string);
+ break;
+ case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR:
+ printf("%s", sdr->record.genloc->id_string);
+ break;
+ default:
+ printf("#%02x", evt->sel_type.standard_type.sensor_num);
+ break;
+ }
+ } else {
+ printf("%s",(
+ (evt->sel_type.standard_type.sensor_type >=0xC0 && evt->sel_type.standard_type.sensor_type < 0xF0)
+ ?
+ ipmi_sel_get_oem_sensor_type_offset(ipmi_get_oem(intf),evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0])
+ :
+ ipmi_sel_get_sensor_type_offset(evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0])
+ ));
+ if (evt->sel_type.standard_type.sensor_num != 0)
+ printf(" #0x%02x", evt->sel_type.standard_type.sensor_num);
+ }
+
+ if (csv_output)
+ printf(",");
+ else
+ printf(" | ");
+
+ ipmi_get_event_desc(intf, evt, &description);
+ if (description) {
+ printf("%s", description);
+ free(description);
+ description = NULL;
+ }
+
+ if (csv_output) {
+ printf(",");
+ } else {
+ printf(" | ");
+ }
+
+ if (evt->sel_type.standard_type.event_dir) {
+ printf("Deasserted");
+ } else {
+ printf("Asserted");
+ }
+
+ if (sdr != NULL && evt->sel_type.standard_type.event_type == 1) {
+ /*
+ * Threshold Event
+ */
+ float trigger_reading = 0.0;
+ float threshold_reading = 0.0;
+ uint8_t threshold_reading_provided = 0;
+
+ /* trigger reading in event data byte 2 */
+ if (((evt->sel_type.standard_type.event_data[0] >> 6) & 3) == 1) {
+ trigger_reading = sdr_convert_sensor_reading(
+ sdr->record.full, evt->sel_type.standard_type.event_data[1]);
+ }
+
+ /* trigger threshold in event data byte 3 */
+ if (((evt->sel_type.standard_type.event_data[0] >> 4) & 3) == 1) {
+ threshold_reading = sdr_convert_sensor_reading(
+ sdr->record.full, evt->sel_type.standard_type.event_data[2]);
+ threshold_reading_provided = 1;
+ }
+
+ if (csv_output)
+ printf(",");
+ else
+ printf(" | ");
+
+ printf("Reading %.*f",
+ (trigger_reading==(int)trigger_reading) ? 0 : 2,
+ trigger_reading);
+ if (threshold_reading_provided) {
+ printf(" %s Threshold %.*f %s",
+ ((evt->sel_type.standard_type.event_data[0] & 0xf) % 2) ? ">" : "<",
+ (threshold_reading==(int)threshold_reading) ? 0 : 2,
+ threshold_reading,
+ ipmi_sdr_get_unit_string(sdr->record.common->unit.pct,
+ sdr->record.common->unit.modifier,
+ sdr->record.common->unit.type.base,
+ sdr->record.common->unit.type.modifier));
+ }
+ }
+ else if (evt->sel_type.standard_type.event_type == 0x6f) {
+ int print_sensor = 1;
+ switch (ipmi_get_oem(intf)) {
+ case IPMI_OEM_SUPERMICRO:
+ case IPMI_OEM_SUPERMICRO_47488:
+ print_sensor = 0;
+ break;
+ }
+ /*
+ * Sensor-Specific Discrete
+ */
+ if (print_sensor && evt->sel_type.standard_type.sensor_type == 0xC && /*TODO*/
+ evt->sel_type.standard_type.sensor_num == 0 &&
+ (evt->sel_type.standard_type.event_data[0] & 0x30) == 0x20) {
+ /* break down memory ECC reporting if we can */
+ if (csv_output)
+ printf(",");
+ else
+ printf(" | ");
+
+ printf("CPU %d DIMM %d",
+ evt->sel_type.standard_type.event_data[2] & 0x0f,
+ (evt->sel_type.standard_type.event_data[2] & 0xf0) >> 4);
+ }
+ }
+
+ printf("\n");
+}
+
+void
+ipmi_sel_print_std_entry_verbose(struct ipmi_intf * intf, struct sel_event_record * evt)
+{
+ char * description;
+ int data_count;
+
+ if (!evt)
+ return;
+
+ printf("SEL Record ID : %04x\n", evt->record_id);
+
+ if (evt->record_type == 0xf0)
+ {
+ printf (" Record Type : Linux kernel panic (OEM record %02x)\n", evt->record_type);
+ printf (" Panic string : %.11s\n\n", (char *) evt + 5);
+ return;
+ }
+
+ printf(" Record Type : %02x", evt->record_type);
+ if (evt->record_type >= 0xc0)
+ {
+ if (evt->record_type < 0xe0)
+ printf(" (OEM timestamped)");
+ else
+ printf(" (OEM non-timestamped)");
+ }
+ printf("\n");
+
+ if (evt->record_type < 0xe0)
+ {
+ printf(" Timestamp : ");
+ if (evt->record_type < 0xc0)
+ printf("%s %s", ipmi_sel_timestamp_date(evt->sel_type.standard_type.timestamp),
+ ipmi_sel_timestamp_time(evt->sel_type.standard_type.timestamp));
+ else
+ printf("%s %s", ipmi_sel_timestamp_date(evt->sel_type.oem_ts_type.timestamp),
+ ipmi_sel_timestamp_time(evt->sel_type.oem_ts_type.timestamp));
+ printf("\n");
+ }
+
+ if (evt->record_type >= 0xc0)
+ {
+ if(evt->record_type < 0xdf)
+ {
+ printf (" Manufactacturer ID : %02x%02x%02x\n", evt->sel_type.oem_ts_type.manf_id[0],
+ evt->sel_type.oem_ts_type.manf_id[1], evt->sel_type.oem_ts_type.manf_id[2]);
+ printf (" OEM Defined : ");
+ for(data_count=0;data_count < SEL_OEM_TS_DATA_LEN;data_count++)
+ printf("%02x", evt->sel_type.oem_ts_type.oem_defined[data_count]);
+ printf(" [%s]\n\n",hex2ascii (evt->sel_type.oem_ts_type.oem_defined, SEL_OEM_TS_DATA_LEN));
+ }
+ else
+ {
+ printf (" OEM Defined : ");
+ for(data_count=0;data_count < SEL_OEM_NOTS_DATA_LEN;data_count++)
+ printf("%02x", evt->sel_type.oem_nots_type.oem_defined[data_count]);
+ printf(" [%s]\n\n",hex2ascii (evt->sel_type.oem_nots_type.oem_defined, SEL_OEM_NOTS_DATA_LEN));
+ ipmi_sel_oem_message(evt, 1);
+ }
+ return;
+ }
+
+ printf(" Generator ID : %04x\n",
+ evt->sel_type.standard_type.gen_id);
+ printf(" EvM Revision : %02x\n",
+ evt->sel_type.standard_type.evm_rev);
+ printf(" Sensor Type : %s\n",
+ (
+ (evt->sel_type.standard_type.sensor_type >=0xC0 && evt->sel_type.standard_type.sensor_type < 0xF0)
+ ?
+ ipmi_sel_get_oem_sensor_type_offset(ipmi_get_oem(intf),evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0])
+ :
+ ipmi_sel_get_sensor_type_offset(evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0])
+ )
+ );
+ printf(" Sensor Number : %02x\n",
+ evt->sel_type.standard_type.sensor_num);
+ printf(" Event Type : %s\n",
+ ipmi_get_event_type(evt->sel_type.standard_type.event_type));
+ printf(" Event Direction : %s\n",
+ val2str(evt->sel_type.standard_type.event_dir, event_dir_vals));
+ printf(" Event Data : %02x%02x%02x\n",
+ evt->sel_type.standard_type.event_data[0], evt->sel_type.standard_type.event_data[1], evt->sel_type.standard_type.event_data[2]);
+ ipmi_get_event_desc(intf, evt, &description);
+ printf(" Description : %s\n",
+ description ? description : "");
+ free(description);
+ description = NULL;
+
+ printf("\n");
+}
+
+
+void
+ipmi_sel_print_extended_entry_verbose(struct ipmi_intf * intf, struct sel_event_record * evt)
+{
+ struct sdr_record_list * sdr;
+ char * description;
+
+ if (!evt)
+ return;
+
+ sdr = ipmi_sdr_find_sdr_bynumtype(intf,
+ evt->sel_type.standard_type.gen_id,
+ evt->sel_type.standard_type.sensor_num,
+ evt->sel_type.standard_type.sensor_type);
+ if (sdr == NULL)
+ {
+ ipmi_sel_print_std_entry_verbose(intf, evt);
+ return;
+ }
+
+ printf("SEL Record ID : %04x\n", evt->record_id);
+
+ if (evt->record_type == 0xf0)
+ {
+ printf (" Record Type : "
+ "Linux kernel panic (OEM record %02x)\n",
+ evt->record_type);
+ printf (" Panic string : %.11s\n\n",
+ (char *) evt + 5);
+ return;
+ }
+
+ printf(" Record Type : %02x\n", evt->record_type);
+ if (evt->record_type < 0xe0)
+ {
+ printf(" Timestamp : ");
+ printf("%s %s\n", ipmi_sel_timestamp_date(evt->sel_type.standard_type.timestamp),
+ ipmi_sel_timestamp_time(evt->sel_type.standard_type.timestamp));
+ }
+
+
+ printf(" Generator ID : %04x\n",
+ evt->sel_type.standard_type.gen_id);
+ printf(" EvM Revision : %02x\n",
+ evt->sel_type.standard_type.evm_rev);
+ printf(" Sensor Type : %s\n",
+ ipmi_sel_get_sensor_type_offset(evt->sel_type.standard_type.sensor_type, evt->sel_type.standard_type.event_data[0]));
+ printf(" Sensor Number : %02x\n",
+ evt->sel_type.standard_type.sensor_num);
+ printf(" Event Type : %s\n",
+ ipmi_get_event_type(evt->sel_type.standard_type.event_type));
+ printf(" Event Direction : %s\n",
+ val2str(evt->sel_type.standard_type.event_dir, event_dir_vals));
+ printf(" Event Data (RAW) : %02x%02x%02x\n",
+ evt->sel_type.standard_type.event_data[0], evt->sel_type.standard_type.event_data[1], evt->sel_type.standard_type.event_data[2]);
+
+ /* break down event data field
+ * as per IPMI Spec 2.0 Table 29-6 */
+ if (evt->sel_type.standard_type.event_type == 1 && sdr->type == SDR_RECORD_TYPE_FULL_SENSOR) {
+ /* Threshold */
+ switch ((evt->sel_type.standard_type.event_data[0] >> 6) & 3) { /* EV1[7:6] */
+ case 0:
+ /* unspecified byte 2 */
+ break;
+ case 1:
+ /* trigger reading in byte 2 */
+ printf(" Trigger Reading : %.3f",
+ sdr_convert_sensor_reading(sdr->record.full,
+ evt->sel_type.standard_type.event_data[1]));
+ /* determine units with possible modifiers */
+ printf ("%s\n", ipmi_sdr_get_unit_string(sdr->record.common->unit.pct,
+ sdr->record.common->unit.modifier,
+ sdr->record.common->unit.type.base,
+ sdr->record.common->unit.type.modifier));
+ break;
+ case 2:
+ /* oem code in byte 2 */
+ printf(" OEM Data : %02x\n",
+ evt->sel_type.standard_type.event_data[1]);
+ break;
+ case 3:
+ /* sensor-specific extension code in byte 2 */
+ printf(" Sensor Extension Code : %02x\n",
+ evt->sel_type.standard_type.event_data[1]);
+ break;
+ }
+ switch ((evt->sel_type.standard_type.event_data[0] >> 4) & 3) { /* EV1[5:4] */
+ case 0:
+ /* unspecified byte 3 */
+ break;
+ case 1:
+ /* trigger threshold value in byte 3 */
+ printf(" Trigger Threshold : %.3f",
+ sdr_convert_sensor_reading(sdr->record.full,
+ evt->sel_type.standard_type.event_data[2]));
+ /* determine units with possible modifiers */
+ printf ("%s\n", ipmi_sdr_get_unit_string(sdr->record.common->unit.pct,
+ sdr->record.common->unit.modifier,
+ sdr->record.common->unit.type.base,
+ sdr->record.common->unit.type.modifier));
+ break;
+ case 2:
+ /* OEM code in byte 3 */
+ printf(" OEM Data : %02x\n",
+ evt->sel_type.standard_type.event_data[2]);
+ break;
+ case 3:
+ /* sensor-specific extension code in byte 3 */
+ printf(" Sensor Extension Code : %02x\n",
+ evt->sel_type.standard_type.event_data[2]);
+ break;
+ }
+ } else if (evt->sel_type.standard_type.event_type >= 0x2 && evt->sel_type.standard_type.event_type <= 0xc) {
+ /* Generic Discrete */
+ } else if (evt->sel_type.standard_type.event_type == 0x6f) {
+
+ /* Sensor-Specific Discrete */
+ if (evt->sel_type.standard_type.sensor_type == 0xC &&
+ evt->sel_type.standard_type.sensor_num == 0 && /**** THIS LOOK TO BE OEM ****/
+ (evt->sel_type.standard_type.event_data[0] & 0x30) == 0x20)
+ {
+ /* break down memory ECC reporting if we can */
+ printf(" Event Data : CPU %d DIMM %d\n",
+ evt->sel_type.standard_type.event_data[2] & 0x0f,
+ (evt->sel_type.standard_type.event_data[2] & 0xf0) >> 4);
+ }
+ else if(
+ evt->sel_type.standard_type.sensor_type == 0x2b && /* Version change */
+ evt->sel_type.standard_type.event_data[0] == 0xC1 /* Data in Data 2 */
+ )
+
+ {
+ //evt->sel_type.standard_type.event_data[1]
+ }
+ else
+ {
+ /* FIXME : Add sensor specific discrete types */
+ printf(" Event Interpretation : Missing\n");
+ }
+ } else if (evt->sel_type.standard_type.event_type >= 0x70 && evt->sel_type.standard_type.event_type <= 0x7f) {
+ /* OEM */
+ } else {
+ printf(" Event Data : %02x%02x%02x\n",
+ evt->sel_type.standard_type.event_data[0], evt->sel_type.standard_type.event_data[1], evt->sel_type.standard_type.event_data[2]);
+ }
+
+ ipmi_get_event_desc(intf, evt, &description);
+ printf(" Description : %s\n",
+ description ? description : "");
+ free(description);
+ description = NULL;
+
+ printf("\n");
+}
+
+static int
+__ipmi_sel_savelist_entries(struct ipmi_intf * intf, int count, const char * savefile,
+ int binary)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint16_t next_id = 0, curr_id = 0;
+ struct sel_event_record evt;
+ int n=0;
+ FILE * fp = NULL;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_GET_SEL_INFO;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Get SEL Info command failed");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Get SEL Info command failed: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 2)
+ printbuf(rsp->data, rsp->data_len, "sel_info");
+
+ if (rsp->data[1] == 0 && rsp->data[2] == 0) {
+ lprintf(LOG_ERR, "SEL has no entries");
+ return 0;
+ }
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_RESERVE_SEL;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Reserve SEL command failed");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Reserve SEL command failed: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+
+ if (count < 0) {
+ /** Show only the most recent 'count' records. */
+ int delta;
+ uint16_t entries;
+
+ req.msg.cmd = IPMI_CMD_GET_SEL_INFO;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Get SEL Info command failed");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Get SEL Info command failed: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ entries = buf2short(rsp->data + 1);
+ if (-count > entries)
+ count = -entries;
+
+ /* Get first record. */
+ next_id = ipmi_sel_get_std_entry(intf, 0, &evt);
+
+ delta = next_id - evt.record_id;
+
+ /* Get last record. */
+ next_id = ipmi_sel_get_std_entry(intf, 0xffff, &evt);
+
+ next_id = evt.record_id + count * delta + delta;
+ }
+
+ if (savefile != NULL) {
+ fp = ipmi_open_file_write(savefile);
+ }
+
+ while (next_id != 0xffff) {
+ curr_id = next_id;
+ lprintf(LOG_DEBUG, "SEL Next ID: %04x", curr_id);
+
+ next_id = ipmi_sel_get_std_entry(intf, curr_id, &evt);
+ if (next_id == 0) {
+ /*
+ * usually next_id of zero means end but
+ * retry because some hardware has quirks
+ * and will return 0 randomly.
+ */
+ next_id = ipmi_sel_get_std_entry(intf, curr_id, &evt);
+ if (next_id == 0)
+ break;
+ }
+
+ if (verbose)
+ ipmi_sel_print_std_entry_verbose(intf, &evt);
+ else
+ ipmi_sel_print_std_entry(intf, &evt);
+
+ if (fp != NULL) {
+ if (binary)
+ fwrite(&evt, 1, 16, fp);
+ else
+ ipmi_sel_print_event_file(intf, &evt, fp);
+ }
+
+ if (++n == count) {
+ break;
+ }
+ }
+
+ if (fp != NULL)
+ fclose(fp);
+
+ return 0;
+}
+
+static int
+ipmi_sel_list_entries(struct ipmi_intf * intf, int count)
+{
+ return __ipmi_sel_savelist_entries(intf, count, NULL, 0);
+}
+
+static int
+ipmi_sel_save_entries(struct ipmi_intf * intf, int count, const char * savefile)
+{
+ return __ipmi_sel_savelist_entries(intf, count, savefile, 0);
+}
+
+/*
+ * ipmi_sel_interpret
+ *
+ * return 0 on success,
+ * -1 on error
+ */
+static int
+ipmi_sel_interpret(struct ipmi_intf *intf, unsigned long iana,
+ const char *readfile, const char *format)
+{
+ FILE *fp = 0;
+ struct sel_event_record evt;
+ char *buffer = NULL;
+ char *cursor = NULL;
+ int status = 0;
+ /* since the interface is not used, iana is taken from
+ * the command line
+ */
+ sel_iana = iana;
+ if (strncmp("pps", format, 3) == 0) {
+ /* Parser for the following format */
+ /* 0x001F: Event: at Mar 27 06:41:10 2007;from:(0x9a,0,7);
+ * sensor:(0xc3,119); event:0x6f(asserted): 0xA3 0x00 0x88
+ * commonly found in PPS shelf managers
+ * Supports a tweak for hotswap events that are already interpreted.
+ */
+ fp = ipmi_open_file(readfile, 0);
+ if (fp == NULL) {
+ lprintf(LOG_ERR, "Failed to open file '%s' for reading.",
+ readfile);
+ return (-1);
+ }
+ buffer = (char *)malloc((size_t)256);
+ if (buffer == NULL) {
+ lprintf(LOG_ERR, "ipmitool: malloc failure");
+ fclose(fp);
+ return (-1);
+ }
+ do {
+ /* Only allow complete lines to be parsed,
+ * hardcoded maximum line length
+ */
+ if (fgets(buffer, 256, fp) == NULL) {
+ status = (-1);
+ break;
+ }
+ if (strlen(buffer) > 255) {
+ lprintf(LOG_ERR, "ipmitool: invalid entry found in file.");
+ continue;
+ }
+ cursor = buffer;
+ /* assume normal "System" event */
+ evt.record_type = 2;
+ errno = 0;
+ evt.record_id = strtol((const char *)cursor, (char **)NULL, 16);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid record ID.");
+ status = (-1);
+ break;
+ }
+ evt.sel_type.standard_type.evm_rev = 4;
+
+ /* FIXME: convert*/
+ evt.sel_type.standard_type.timestamp;
+
+ /* skip timestamp */
+ cursor = index((const char *)cursor, ';');
+ cursor++;
+
+ /* FIXME: parse originator */
+ evt.sel_type.standard_type.gen_id = 0x0020;
+
+ /* skip originator info */
+ cursor = index((const char *)cursor, ';');
+ cursor++;
+
+ /* Get sensor type */
+ cursor = index((const char *)cursor, '(');
+ cursor++;
+
+ errno = 0;
+ evt.sel_type.standard_type.sensor_type =
+ strtol((const char *)cursor, (char **)NULL, 16);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Sensor Type.");
+ status = (-1);
+ break;
+ }
+ cursor = index((const char *)cursor, ',');
+ cursor++;
+
+ errno = 0;
+ evt.sel_type.standard_type.sensor_num =
+ strtol((const char *)cursor, (char **)NULL, 10);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Sensor Number.");
+ status = (-1);
+ break;
+ }
+
+ /* skip to event type info */
+ cursor = index((const char *)cursor, ':');
+ cursor++;
+
+ errno = 0;
+ evt.sel_type.standard_type.event_type=
+ strtol((const char *)cursor, (char **)NULL, 16);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Event Type.");
+ status = (-1);
+ break;
+ }
+
+ /* skip to event dir info */
+ cursor = index((const char *)cursor, '(');
+ cursor++;
+ if (*cursor == 'a') {
+ evt.sel_type.standard_type.event_dir = 0;
+ } else {
+ evt.sel_type.standard_type.event_dir = 1;
+ }
+ /* skip to data info */
+ cursor = index((const char *)cursor, ' ');
+ cursor++;
+
+ if (evt.sel_type.standard_type.sensor_type == 0xF0) {
+ /* got to FRU id */
+ while (!isdigit(*cursor)) {
+ cursor++;
+ }
+ /* store FRUid */
+ errno = 0;
+ evt.sel_type.standard_type.event_data[2] =
+ strtol(cursor, (char **)NULL, 10);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Event Data#2.");
+ status = (-1);
+ break;
+ }
+
+ /* Get to previous state */
+ cursor = index((const char *)cursor, 'M');
+ cursor++;
+
+ /* Set previous state */
+ errno = 0;
+ evt.sel_type.standard_type.event_data[1] =
+ strtol(cursor, (char **)NULL, 10);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Event Data#1.");
+ status = (-1);
+ break;
+ }
+
+ /* Get to current state */
+ cursor = index((const char *)cursor, 'M');
+ cursor++;
+
+ /* Set current state */
+ errno = 0;
+ evt.sel_type.standard_type.event_data[0] =
+ 0xA0 | strtol(cursor, (char **)NULL, 10);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Event Data#0.");
+ status = (-1);
+ break;
+ }
+
+ /* skip to cause */
+ cursor = index((const char *)cursor, '=');
+ cursor++;
+ errno = 0;
+ evt.sel_type.standard_type.event_data[1] |=
+ (strtol(cursor, (char **)NULL, 16)) << 4;
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Event Data#1.");
+ status = (-1);
+ break;
+ }
+ } else if (*cursor == '0') {
+ errno = 0;
+ evt.sel_type.standard_type.event_data[0] =
+ strtol((const char *)cursor, (char **)NULL, 16);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Event Data#0.");
+ status = (-1);
+ break;
+ }
+ cursor = index((const char *)cursor, ' ');
+ cursor++;
+
+ errno = 0;
+ evt.sel_type.standard_type.event_data[1] =
+ strtol((const char *)cursor, (char **)NULL, 16);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Event Data#1.");
+ status = (-1);
+ break;
+ }
+
+ cursor = index((const char *)cursor, ' ');
+ cursor++;
+
+ errno = 0;
+ evt.sel_type.standard_type.event_data[2] =
+ strtol((const char *)cursor, (char **)NULL, 16);
+ if (errno != 0) {
+ lprintf(LOG_ERR, "Invalid Event Data#2.");
+ status = (-1);
+ break;
+ }
+ } else {
+ lprintf(LOG_ERR, "ipmitool: can't guess format.");
+ }
+ /* parse the PPS line into a sel_event_record */
+ if (verbose) {
+ ipmi_sel_print_std_entry_verbose(intf, &evt);
+ } else {
+ ipmi_sel_print_std_entry(intf, &evt);
+ }
+ cursor = NULL;
+ } while (status == 0); /* until file is completely read */
+ cursor = NULL;
+ free(buffer);
+ buffer = NULL;
+ fclose(fp);
+ } else {
+ lprintf(LOG_ERR, "Given format '%s' is unknown.", format);
+ status = (-1);
+ }
+ return status;
+}
+
+
+static int
+ipmi_sel_writeraw(struct ipmi_intf * intf, const char * savefile)
+{
+ return __ipmi_sel_savelist_entries(intf, 0, savefile, 1);
+}
+
+
+static int
+ipmi_sel_readraw(struct ipmi_intf * intf, const char * inputfile)
+{
+ struct sel_event_record evt;
+ int ret = 0;
+ FILE* fp = 0;
+
+ fp = ipmi_open_file(inputfile, 0);
+ if (fp)
+ {
+ size_t bytesRead;
+
+ do {
+ if ((bytesRead = fread(&evt, 1, 16, fp)) == 16)
+ {
+ if (verbose)
+ ipmi_sel_print_std_entry_verbose(intf, &evt);
+ else
+ ipmi_sel_print_std_entry(intf, &evt);
+ }
+ else
+ {
+ if (bytesRead != 0)
+ {
+ lprintf(LOG_ERR, "ipmitool: incomplete record found in file.");
+ ret = -1;
+ }
+
+ break;
+ }
+
+ } while (1);
+ fclose(fp);
+ }
+ else
+ {
+ lprintf(LOG_ERR, "ipmitool: could not open input file.");
+ ret = -1;
+ }
+ return ret;
+}
+
+
+
+static uint16_t
+ipmi_sel_reserve(struct ipmi_intf * intf)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_RESERVE_SEL;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_WARN, "Unable to reserve SEL");
+ return 0;
+ }
+ if (rsp->ccode > 0) {
+ printf("Unable to reserve SEL: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return 0;
+ }
+
+ return (rsp->data[0] | (rsp->data[1] << 8));
+}
+
+
+
+/*
+ * ipmi_sel_get_time
+ *
+ * return 0 on success,
+ * -1 on error
+ */
+static int
+ipmi_sel_get_time(struct ipmi_intf * intf)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ static char tbuf[40];
+ uint32_t timei;
+ time_t time;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_GET_SEL_TIME;
+
+ rsp = intf->sendrecv(intf, &req);
+
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Get SEL Time command failed");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Get SEL Time command failed: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ if (rsp->data_len != 4) {
+ lprintf(LOG_ERR, "Get SEL Time command failed: "
+ "Invalid data length %d", rsp->data_len);
+ return -1;
+ }
+
+ memcpy(&timei, rsp->data, 4);
+#if WORDS_BIGENDIAN
+ time = (time_t)(BSWAP_32(timei));
+#else
+ time = (time_t)timei;
+#endif
+
+ strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", gmtime(&time));
+ printf("%s\n", tbuf);
+
+ return 0;
+}
+
+
+
+/*
+ * ipmi_sel_set_time
+ *
+ * return 0 on success,
+ * -1 on error
+ */
+static int
+ipmi_sel_set_time(struct ipmi_intf * intf, const char * time_string)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ struct tm tm = {0};
+ time_t t;
+ uint32_t timei;
+ const char * time_format = "%m/%d/%Y %H:%M:%S";
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_SET_SEL_TIME;
+
+ /* See if user requested set to current client system time */
+ if (strncasecmp(time_string, "now", 3) == 0) {
+ t = time(NULL);
+ }
+ else {
+ /* Now how do we get our time_t from our ascii version? */
+ if (strptime(time_string, time_format, &tm) == 0) {
+ lprintf(LOG_ERR, "Specified time could not be parsed");
+ return -1;
+ }
+ tm.tm_isdst = (-1); /* look up DST information */
+ t = mktime(&tm);
+ if (t < 0) {
+ lprintf(LOG_ERR, "Specified time could not be parsed");
+ return -1;
+ }
+ }
+
+ {
+ //modify UTC time to local time expressed in number of seconds from 1/1/70 0:0:0 1970 GMT
+ struct tm * tm_tmp = {0};
+ int gt_year,gt_yday,gt_hour,lt_year,lt_yday,lt_hour;
+ int delta_hour;
+ tm_tmp=gmtime(&t);
+ gt_year=tm_tmp->tm_year;
+ gt_yday=tm_tmp->tm_yday;
+ gt_hour=tm_tmp->tm_hour;
+ memset(&*tm_tmp, 0, sizeof(struct tm));
+ tm_tmp=localtime(&t);
+ lt_year=tm_tmp->tm_year;
+ lt_yday=tm_tmp->tm_yday;
+ lt_hour=tm_tmp->tm_hour;
+ delta_hour=lt_hour - gt_hour;
+ if ( (lt_year > gt_year) || ((lt_year == gt_year) && (lt_yday > gt_yday)) )
+ delta_hour += 24;
+ if ( (lt_year < gt_year) || ((lt_year == gt_year) && (lt_yday < gt_yday)) )
+ delta_hour -= 24;
+
+ t += (delta_hour * 60 * 60);
+ }
+
+ timei = (uint32_t)t;
+ req.msg.data = (uint8_t *)&timei;
+ req.msg.data_len = 4;
+
+#if WORDS_BIGENDIAN
+ timei = BSWAP_32(timei);
+#endif
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Set SEL Time command failed");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Set SEL Time command failed: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+
+ ipmi_sel_get_time(intf);
+
+ return 0;
+}
+
+
+
+static int
+ipmi_sel_clear(struct ipmi_intf * intf)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint16_t reserve_id;
+ uint8_t msg_data[6];
+
+ reserve_id = ipmi_sel_reserve(intf);
+ if (reserve_id == 0)
+ return -1;
+
+ memset(msg_data, 0, 6);
+ msg_data[0] = reserve_id & 0xff;
+ msg_data[1] = reserve_id >> 8;
+ msg_data[2] = 'C';
+ msg_data[3] = 'L';
+ msg_data[4] = 'R';
+ msg_data[5] = 0xaa;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_CLEAR_SEL;
+ req.msg.data = msg_data;
+ req.msg.data_len = 6;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Unable to clear SEL");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Unable to clear SEL: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+
+ printf("Clearing SEL. Please allow a few seconds to erase.\n");
+ return 0;
+}
+
+static int
+ipmi_sel_delete(struct ipmi_intf * intf, int argc, char ** argv)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint16_t id;
+ uint8_t msg_data[4];
+ int rc = 0;
+
+ if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {
+ lprintf(LOG_ERR, "usage: delete <id>...<id>\n");
+ return -1;
+ }
+
+ id = ipmi_sel_reserve(intf);
+ if (id == 0)
+ return -1;
+
+ memset(msg_data, 0, 4);
+ msg_data[0] = id & 0xff;
+ msg_data[1] = id >> 8;
+
+ for (; argc != 0; argc--)
+ {
+ id = (uint16_t) strtoul(argv[argc-1], NULL, 0);
+ if (str2ushort(argv[argc-1], &id) != 0) {
+ lprintf(LOG_ERR, "Given SEL ID '%s' is invalid.",
+ argv[argc-1]);
+ rc = (-1);
+ continue;
+ }
+ msg_data[2] = id & 0xff;
+ msg_data[3] = id >> 8;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.cmd = IPMI_CMD_DELETE_SEL_ENTRY;
+ req.msg.data = msg_data;
+ req.msg.data_len = 4;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Unable to delete entry %d", id);
+ rc = -1;
+ }
+ else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Unable to delete entry %d: %s", id,
+ val2str(rsp->ccode, completion_code_vals));
+ rc = -1;
+ }
+ else {
+ printf("Deleted entry %d\n", id);
+ }
+ }
+
+ return rc;
+}
+
+static int
+ipmi_sel_show_entry(struct ipmi_intf * intf, int argc, char ** argv)
+{
+ uint16_t id;
+ int i, oldv;
+ struct sel_event_record evt;
+ struct sdr_record_list * sdr;
+ struct entity_id entity;
+ struct sdr_record_list * list, * entry;
+ int rc = 0;
+
+ if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {
+ lprintf(LOG_ERR, "usage: sel get <id>...<id>");
+ return -1;
+ }
+
+ if (ipmi_sel_reserve(intf) == 0) {
+ lprintf(LOG_ERR, "Unable to reserve SEL");
+ return -1;
+ }
+
+ for (i=0; i<argc; i++) {
+ if (str2ushort(argv[i], &id) != 0) {
+ lprintf(LOG_ERR, "Given SEL ID '%s' is invalid.",
+ argv[i]);
+ rc = (-1);
+ continue;
+ }
+
+ lprintf(LOG_DEBUG, "Looking up SEL entry 0x%x", id);
+
+ /* lookup SEL entry based on ID */
+ if (!ipmi_sel_get_std_entry(intf, id, &evt)) {
+ lprintf(LOG_DEBUG, "SEL Entry 0x%x not found.", id);
+ rc = (-1);
+ continue;
+ }
+ if (evt.sel_type.standard_type.sensor_num == 0 && evt.sel_type.standard_type.sensor_type == 0 && evt.record_type == 0) {
+ lprintf(LOG_WARN, "SEL Entry 0x%x not found", id);
+ rc = -1;
+ continue;
+ }
+
+ /* lookup SDR entry based on sensor number and type */
+ ipmi_sel_print_extended_entry_verbose(intf, &evt);
+
+ sdr = ipmi_sdr_find_sdr_bynumtype(intf, evt.sel_type.standard_type.gen_id, evt.sel_type.standard_type.sensor_num, evt.sel_type.standard_type.sensor_type);
+ if (sdr == NULL) {
+ continue;
+ }
+
+ /* print SDR entry */
+ oldv = verbose;
+ verbose = verbose ? : 1;
+ switch (sdr->type) {
+ case SDR_RECORD_TYPE_FULL_SENSOR:
+ case SDR_RECORD_TYPE_COMPACT_SENSOR:
+ ipmi_sensor_print_fc(intf, sdr->record.common,
+ sdr->type);
+ entity.id = sdr->record.common->entity.id;
+ entity.instance = sdr->record.common->entity.instance;
+ break;
+ case SDR_RECORD_TYPE_EVENTONLY_SENSOR:
+ ipmi_sdr_print_sensor_eventonly(intf, sdr->record.eventonly);
+ entity.id = sdr->record.eventonly->entity.id;
+ entity.instance = sdr->record.eventonly->entity.instance;
+ break;
+ default:
+ verbose = oldv;
+ continue;
+ }
+ verbose = oldv;
+
+ /* lookup SDR entry based on entity id */
+ list = ipmi_sdr_find_sdr_byentity(intf, &entity);
+ for (entry=list; entry; entry=entry->next) {
+ /* print FRU devices we find for this entity */
+ if (entry->type == SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR)
+ ipmi_fru_print(intf, entry->record.fruloc);
+ }
+
+ if ((argc > 1) && (i<(argc-1)))
+ printf("----------------------\n\n");
+ }
+
+ return rc;
+}
+
+int ipmi_sel_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+ int rc = 0;
+
+ if (argc == 0)
+ rc = ipmi_sel_get_info(intf);
+ else if (strncmp(argv[0], "help", 4) == 0)
+ lprintf(LOG_ERR, "SEL Commands: "
+ "info clear delete list elist get add time save readraw writeraw interpret");
+ else if (strncmp(argv[0], "interpret", 9) == 0) {
+ uint32_t iana = 0;
+ if (argc < 4) {
+ lprintf(LOG_NOTICE, "usage: sel interpret iana filename format(pps)");
+ return 0;
+ }
+ if (str2uint(argv[1], &iana) != 0) {
+ lprintf(LOG_ERR, "Given IANA '%s' is invalid.",
+ argv[1]);
+ return (-1);
+ }
+ rc = ipmi_sel_interpret(intf, iana, argv[2], argv[3]);
+ }
+ else if (strncmp(argv[0], "info", 4) == 0)
+ rc = ipmi_sel_get_info(intf);
+ else if (strncmp(argv[0], "save", 4) == 0) {
+ if (argc < 2) {
+ lprintf(LOG_NOTICE, "usage: sel save <filename>");
+ return 0;
+ }
+ rc = ipmi_sel_save_entries(intf, 0, argv[1]);
+ }
+ else if (strncmp(argv[0], "add", 3) == 0) {
+ if (argc < 2) {
+ lprintf(LOG_NOTICE, "usage: sel add <filename>");
+ return 0;
+ }
+ rc = ipmi_sel_add_entries_fromfile(intf, argv[1]);
+ }
+ else if (strncmp(argv[0], "writeraw", 8) == 0) {
+ if (argc < 2) {
+ lprintf(LOG_NOTICE, "usage: sel writeraw <filename>");
+ return 0;
+ }
+ rc = ipmi_sel_writeraw(intf, argv[1]);
+ }
+ else if (strncmp(argv[0], "readraw", 7) == 0) {
+ if (argc < 2) {
+ lprintf(LOG_NOTICE, "usage: sel readraw <filename>");
+ return 0;
+ }
+ rc = ipmi_sel_readraw(intf, argv[1]);
+ }
+ else if (strncmp(argv[0], "ereadraw", 8) == 0) {
+ if (argc < 2) {
+ lprintf(LOG_NOTICE, "usage: sel ereadraw <filename>");
+ return 0;
+ }
+ sel_extended = 1;
+ rc = ipmi_sel_readraw(intf, argv[1]);
+ }
+ else if (strncmp(argv[0], "list", 4) == 0 ||
+ strncmp(argv[0], "elist", 5) == 0) {
+ /*
+ * Usage:
+ * list - show all SEL entries
+ * list first <n> - show the first (oldest) <n> SEL entries
+ * list last <n> - show the last (newsest) <n> SEL entries
+ */
+ int count = 0;
+ int sign = 1;
+ char *countstr = NULL;
+
+ if (strncmp(argv[0], "elist", 5) == 0)
+ sel_extended = 1;
+ else
+ sel_extended = 0;
+
+ if (argc == 2) {
+ countstr = argv[1];
+ }
+ else if (argc == 3) {
+ countstr = argv[2];
+
+ if (strncmp(argv[1], "last", 4) == 0) {
+ sign = -1;
+ }
+ else if (strncmp(argv[1], "first", 5) != 0) {
+ lprintf(LOG_ERR, "Unknown sel list option");
+ return -1;
+ }
+ }
+
+ if (countstr) {
+ if (str2int(countstr, &count) != 0) {
+ lprintf(LOG_ERR, "Numeric argument required; got '%s'",
+ countstr);
+ return -1;
+ }
+ }
+ count *= sign;
+
+ rc = ipmi_sel_list_entries(intf,count);
+ }
+ else if (strncmp(argv[0], "clear", 5) == 0)
+ rc = ipmi_sel_clear(intf);
+ else if (strncmp(argv[0], "delete", 6) == 0) {
+ if (argc < 2)
+ lprintf(LOG_ERR, "usage: sel delete <id>...<id>");
+ else
+ rc = ipmi_sel_delete(intf, argc-1, &argv[1]);
+ }
+ else if (strncmp(argv[0], "get", 3) == 0) {
+ if (argc < 2)
+ lprintf(LOG_ERR, "usage: sel get <entry>");
+ else
+ rc = ipmi_sel_show_entry(intf, argc-1, &argv[1]);
+ }
+ else if (strncmp(argv[0], "time", 4) == 0) {
+ if (argc < 2)
+ lprintf(LOG_ERR, "sel time commands: get set");
+ else if (strncmp(argv[1], "get", 3) == 0)
+ ipmi_sel_get_time(intf);
+ else if (strncmp(argv[1], "set", 3) == 0) {
+ if (argc < 3)
+ lprintf(LOG_ERR, "usage: sel time set \"mm/dd/yyyy hh:mm:ss\"");
+ else
+ rc = ipmi_sel_set_time(intf, argv[2]);
+ } else {
+ lprintf(LOG_ERR, "sel time commands: get set");
+ }
+ }
+ else {
+ lprintf(LOG_ERR, "Invalid SEL command: %s", argv[0]);
+ rc = -1;
+ }
+
+ return rc;
+}