diff options
Diffstat (limited to 'lib/ipmi_sel.c')
| -rw-r--r-- | lib/ipmi_sel.c | 3094 |
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; +} |