1 /* -*-mode: C; indent-tabs-mode: t; -*-
2 * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * Redistribution of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * Redistribution in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * Neither the name of Sun Microsystems, Inc. or the names of
16 * contributors may be used to endorse or promote products derived
17 * from this software without specific prior written permission.
18 *
19 * This software is provided "AS IS," without a warranty of any kind.
20 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
21 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
22 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
23 * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
24 * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
25 * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL
26 * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
27 * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
28 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
29 * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
30 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
31 */
32 #define _BSD_SOURCE
33
34 #include <string.h>
35 #include <strings.h>
36 #include <math.h>
37 #define __USE_XOPEN /* glibc2 needs this for strptime */
38 #include <time.h>
39 #include <ctype.h>
40 #include <errno.h>
41
42 #include <ipmitool/helper.h>
43 #include <ipmitool/log.h>
44 #include <ipmitool/ipmi.h>
45 #include <ipmitool/ipmi_mc.h>
46 #include <ipmitool/ipmi_intf.h>
47 #include <ipmitool/ipmi_sel.h>
48 #include <ipmitool/ipmi_sel_supermicro.h>
49 #include <ipmitool/ipmi_sdr.h>
50 #include <ipmitool/ipmi_fru.h>
51 #include <ipmitool/ipmi_sensor.h>
52 #include <ipmitool/ipmi_strings.h>
53
54 extern int verbose;
55 static int sel_extended = 0;
56 static int sel_oem_nrecs = 0;
57
58 static IPMI_OEM sel_iana = IPMI_OEM_UNKNOWN;
59
60 struct ipmi_sel_oem_msg_rec {
61 int value[14];
62 char *string[14];
63 char *text;
64 } *sel_oem_msg;
65
66 #define SEL_BYTE(n) (n-3) /* So we can refer to byte positions in log entries (byte 3 is at index 0, etc) */
67
68 // Definiation for the Decoding the SEL OEM Bytes for DELL Platfoms
69 #define BIT(x) (1 << x) /* Select the Bit */
70 #define SIZE_OF_DESC 128 /* Max Size of the description String to be displyed for the Each sel entry */
71 #define MAX_CARDNO_STR 32 /* Max Size of Card number string */
72 #define MAX_DIMM_STR 32 /* Max Size of DIMM string */
73 #define MAX_CARD_STR 32 /* Max Size of Card string */
74 /*
75 * Reads values found in message translation file. XX is a wildcard, R means reserved.
76 * Returns -1 for XX, -2 for R, -3 for non-hex (string), or positive integer from a hex value.
77 */
ipmi_sel_oem_readval(char * str)78 static int ipmi_sel_oem_readval(char *str)
79 {
80 int ret;
81 if (!strcmp(str, "XX")) {
82 return -1;
83 }
84 if (!strcmp(str, "R")) {
85 return -2;
86 }
87 if (sscanf(str, "0x%x", &ret) != 1) {
88 return -3;
89 }
90 return ret;
91 }
92
93 /*
94 * This is where the magic happens. SEL_BYTE is a bit ugly, but it allows
95 * reference to byte positions instead of array indexes which (hopefully)
96 * helps make the code easier to read.
97 */
98 static int
ipmi_sel_oem_match(uint8_t * evt,const struct ipmi_sel_oem_msg_rec * rec)99 ipmi_sel_oem_match(uint8_t *evt, const struct ipmi_sel_oem_msg_rec *rec)
100 {
101 if (evt[2] == rec->value[SEL_BYTE(3)]
102 && ((rec->value[SEL_BYTE(4)] < 0)
103 || (evt[3] == rec->value[SEL_BYTE(4)]))
104 && ((rec->value[SEL_BYTE(5)] < 0)
105 || (evt[4] == rec->value[SEL_BYTE(5)]))
106 && ((rec->value[SEL_BYTE(6)] < 0)
107 || (evt[5] == rec->value[SEL_BYTE(6)]))
108 && ((rec->value[SEL_BYTE(7)] < 0)
109 || (evt[6] == rec->value[SEL_BYTE(7)]))
110 && ((rec->value[SEL_BYTE(11)] < 0)
111 || (evt[10] == rec->value[SEL_BYTE(11)]))
112 && ((rec->value[SEL_BYTE(12)] < 0)
113 || (evt[11] == rec->value[SEL_BYTE(12)]))) {
114 return 1;
115 } else {
116 return 0;
117 }
118 }
119
ipmi_sel_oem_init(const char * filename)120 int ipmi_sel_oem_init(const char * filename)
121 {
122 FILE * fp;
123 int i, j, k, n, byte;
124 char buf[15][150];
125
126 if (filename == NULL) {
127 lprintf(LOG_ERR, "No SEL OEM filename provided");
128 return -1;
129 }
130
131 fp = ipmi_open_file_read(filename);
132 if (fp == NULL) {
133 lprintf(LOG_ERR, "Could not open %s file", filename);
134 return -1;
135 }
136
137 /* count number of records (lines) in input file */
138 sel_oem_nrecs = 0;
139 while (fscanf(fp, "%*[^\n]\n") == 0) {
140 sel_oem_nrecs++;
141 }
142
143 printf("nrecs=%d\n", sel_oem_nrecs);
144
145 rewind(fp);
146 sel_oem_msg = (struct ipmi_sel_oem_msg_rec *)calloc(sel_oem_nrecs,
147 sizeof(struct ipmi_sel_oem_msg_rec));
148
149 for (i=0; i < sel_oem_nrecs; i++) {
150 n=fscanf(fp, "\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",\""
151 "%[^\"]\",\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",\""
152 "%[^\"]\",\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",\""
153 "%[^\"]\",\"%[^\"]\",\"%[^\"]\"\n",
154 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5],
155 buf[6], buf[7], buf[8], buf[9], buf[10], buf[11],
156 buf[12], buf[13], buf[14]);
157
158 if (n != 15) {
159 lprintf (LOG_ERR, "Encountered problems reading line %d of %s",
160 i+1, filename);
161 fclose(fp);
162 fp = NULL;
163 sel_oem_nrecs = 0;
164 /* free all the memory allocated so far */
165 for (j=0; j<i ; j++) {
166 for (k=3; k<17; k++) {
167 if (sel_oem_msg[j].value[SEL_BYTE(k)] == -3) {
168 free(sel_oem_msg[j].string[SEL_BYTE(k)]);
169 sel_oem_msg[j].string[SEL_BYTE(k)] = NULL;
170 }
171 }
172 }
173 free(sel_oem_msg);
174 sel_oem_msg = NULL;
175 return -1;
176 }
177
178 for (byte = 3; byte < 17; byte++) {
179 if ((sel_oem_msg[i].value[SEL_BYTE(byte)] =
180 ipmi_sel_oem_readval(buf[SEL_BYTE(byte)])) == -3) {
181 sel_oem_msg[i].string[SEL_BYTE(byte)] =
182 (char *)malloc(strlen(buf[SEL_BYTE(byte)]) + 1);
183 strcpy(sel_oem_msg[i].string[SEL_BYTE(byte)],
184 buf[SEL_BYTE(byte)]);
185 }
186 }
187 sel_oem_msg[i].text = (char *)malloc(strlen(buf[SEL_BYTE(17)]) + 1);
188 strcpy(sel_oem_msg[i].text, buf[SEL_BYTE(17)]);
189 }
190
191 fclose(fp);
192 fp = NULL;
193 return 0;
194 }
195
ipmi_sel_oem_message(struct sel_event_record * evt,int verbose)196 static void ipmi_sel_oem_message(struct sel_event_record * evt, int verbose)
197 {
198 /*
199 * Note: although we have a verbose argument, currently the output
200 * isn't affected by it.
201 */
202 int i, j;
203
204 for (i=0; i < sel_oem_nrecs; i++) {
205 if (ipmi_sel_oem_match((uint8_t *)evt, &sel_oem_msg[i])) {
206 printf (csv_output ? ",\"%s\"" : " | %s", sel_oem_msg[i].text);
207 for (j=4; j<17; j++) {
208 if (sel_oem_msg[i].value[SEL_BYTE(j)] == -3) {
209 printf (csv_output ? ",%s=0x%x" : " %s = 0x%x",
210 sel_oem_msg[i].string[SEL_BYTE(j)],
211 ((uint8_t *)evt)[SEL_BYTE(j)]);
212 }
213 }
214 }
215 }
216 }
217
218 static const struct valstr event_dir_vals[] = {
219 { 0, "Assertion Event" },
220 { 1, "Deassertion Event" },
221 { 0, NULL },
222 };
223
224 static const char *
ipmi_get_event_type(uint8_t code)225 ipmi_get_event_type(uint8_t code)
226 {
227 if (code == 0)
228 return "Unspecified";
229 if (code == 1)
230 return "Threshold";
231 if (code >= 0x02 && code <= 0x0b)
232 return "Generic Discrete";
233 if (code == 0x6f)
234 return "Sensor-specific Discrete";
235 if (code >= 0x70 && code <= 0x7f)
236 return "OEM";
237 return "Reserved";
238 }
239
240 static char *
ipmi_sel_timestamp(uint32_t stamp)241 ipmi_sel_timestamp(uint32_t stamp)
242 {
243 static char tbuf[40];
244 time_t s = (time_t)stamp;
245 memset(tbuf, 0, 40);
246 strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", gmtime(&s));
247 return tbuf;
248 }
249
250 static char *
ipmi_sel_timestamp_date(uint32_t stamp)251 ipmi_sel_timestamp_date(uint32_t stamp)
252 {
253 static char tbuf[11];
254 time_t s = (time_t)stamp;
255 strftime(tbuf, sizeof(tbuf), "%m/%d/%Y", gmtime(&s));
256 return tbuf;
257 }
258
259 static char *
ipmi_sel_timestamp_time(uint32_t stamp)260 ipmi_sel_timestamp_time(uint32_t stamp)
261 {
262 static char tbuf[9];
263 time_t s = (time_t)stamp;
264 strftime(tbuf, sizeof(tbuf), "%H:%M:%S", gmtime(&s));
265 return tbuf;
266 }
267
268 static char *
hex2ascii(uint8_t * hexChars,uint8_t numBytes)269 hex2ascii (uint8_t * hexChars, uint8_t numBytes)
270 {
271 int count;
272 static char hexString[SEL_OEM_NOTS_DATA_LEN+1]; /*Max Size*/
273
274 if(numBytes > SEL_OEM_NOTS_DATA_LEN)
275 numBytes = SEL_OEM_NOTS_DATA_LEN;
276
277 for(count=0;count < numBytes;count++)
278 {
279 if((hexChars[count]<0x40)||(hexChars[count]>0x7e))
280 hexString[count]='.';
281 else
282 hexString[count]=hexChars[count];
283 }
284 hexString[numBytes]='\0';
285 return hexString;
286 }
287
288 IPMI_OEM
ipmi_get_oem(struct ipmi_intf * intf)289 ipmi_get_oem(struct ipmi_intf * intf)
290 {
291 /* Execute a Get Device ID command to determine the OEM */
292 struct ipmi_rs * rsp;
293 struct ipmi_rq req;
294 struct ipm_devid_rsp *devid;
295
296 if (intf->fd == 0) {
297 if( sel_iana != IPMI_OEM_UNKNOWN ){
298 return sel_iana;
299 }
300 return IPMI_OEM_UNKNOWN;
301 }
302
303 /*
304 * Return the cached manufacturer id if the device is open and
305 * we got an identified OEM owner. Otherwise just attempt to read
306 * it.
307 */
308 if (intf->opened && intf->manufacturer_id != IPMI_OEM_UNKNOWN) {
309 return intf->manufacturer_id;
310 }
311
312 memset(&req, 0, sizeof(req));
313 req.msg.netfn = IPMI_NETFN_APP;
314 req.msg.cmd = BMC_GET_DEVICE_ID;
315 req.msg.data_len = 0;
316
317 rsp = intf->sendrecv(intf, &req);
318 if (rsp == NULL) {
319 lprintf(LOG_ERR, "Get Device ID command failed");
320 return IPMI_OEM_UNKNOWN;
321 }
322 if (rsp->ccode > 0) {
323 lprintf(LOG_ERR, "Get Device ID command failed: %#x %s",
324 rsp->ccode, val2str(rsp->ccode, completion_code_vals));
325 return IPMI_OEM_UNKNOWN;
326 }
327
328 devid = (struct ipm_devid_rsp *) rsp->data;
329
330 lprintf(LOG_DEBUG,"Iana: %u",
331 IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id));
332
333 return IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id);
334 }
335
336 static int
ipmi_sel_add_entry(struct ipmi_intf * intf,struct sel_event_record * rec)337 ipmi_sel_add_entry(struct ipmi_intf * intf, struct sel_event_record * rec)
338 {
339 struct ipmi_rs * rsp;
340 struct ipmi_rq req;
341
342 memset(&req, 0, sizeof(req));
343 req.msg.netfn = IPMI_NETFN_STORAGE;
344 req.msg.cmd = IPMI_CMD_ADD_SEL_ENTRY;
345 req.msg.data = (unsigned char *)rec;
346 req.msg.data_len = 16;
347
348 ipmi_sel_print_std_entry(intf, rec);
349
350 rsp = intf->sendrecv(intf, &req);
351 if (rsp == NULL) {
352 lprintf(LOG_ERR, "Add SEL Entry failed");
353 return -1;
354 }
355 else if (rsp->ccode > 0) {
356 lprintf(LOG_ERR, "Add SEL Entry failed: %s",
357 val2str(rsp->ccode, completion_code_vals));
358 return -1;
359 }
360
361 return 0;
362 }
363
364
365 static int
ipmi_sel_add_entries_fromfile(struct ipmi_intf * intf,const char * filename)366 ipmi_sel_add_entries_fromfile(struct ipmi_intf * intf, const char * filename)
367 {
368 FILE * fp;
369 char buf[1024];
370 char * ptr, * tok;
371 int i, j;
372 int rc = 0;
373 uint8_t rqdata[8];
374 struct sel_event_record sel_event;
375
376 if (filename == NULL)
377 return -1;
378
379 fp = ipmi_open_file_read(filename);
380 if (fp == NULL)
381 return -1;
382
383 while (feof(fp) == 0) {
384 if (fgets(buf, 1024, fp) == NULL)
385 continue;
386
387 /* clip off optional comment tail indicated by # */
388 ptr = strchr(buf, '#');
389 if (ptr)
390 *ptr = '\0';
391 else
392 ptr = buf + strlen(buf);
393
394 /* clip off trailing and leading whitespace */
395 ptr--;
396 while (isspace((int)*ptr) && ptr >= buf)
397 *ptr-- = '\0';
398 ptr = buf;
399 while (isspace((int)*ptr))
400 ptr++;
401 if (strlen(ptr) == 0)
402 continue;
403
404 /* parse the event, 7 bytes with optional comment */
405 /* 0x00 0x00 0x00 0x00 0x00 0x00 0x00 # event */
406 i = 0;
407 tok = strtok(ptr, " ");
408 while (tok) {
409 if (i == 7)
410 break;
411 j = i++;
412 if (str2uchar(tok, &rqdata[j]) != 0) {
413 break;
414 }
415 tok = strtok(NULL, " ");
416 }
417 if (i < 7) {
418 lprintf(LOG_ERR, "Invalid Event: %s",
419 buf2str(rqdata, sizeof(rqdata)));
420 continue;
421 }
422
423 memset(&sel_event, 0, sizeof(struct sel_event_record));
424 sel_event.record_id = 0x0000;
425 sel_event.record_type = 0x02;
426 /*
427 * IPMI spec §32.1 generator ID
428 * Bit 0 = 1 "Software defined"
429 * Bit 1-7: SWID (IPMI spec §5.5), using 2 = "System management software"
430 */
431 sel_event.sel_type.standard_type.gen_id = 0x41;
432 sel_event.sel_type.standard_type.evm_rev = rqdata[0];
433 sel_event.sel_type.standard_type.sensor_type = rqdata[1];
434 sel_event.sel_type.standard_type.sensor_num = rqdata[2];
435 sel_event.sel_type.standard_type.event_type = rqdata[3] & 0x7f;
436 sel_event.sel_type.standard_type.event_dir = (rqdata[3] & 0x80) >> 7;
437 sel_event.sel_type.standard_type.event_data[0] = rqdata[4];
438 sel_event.sel_type.standard_type.event_data[1] = rqdata[5];
439 sel_event.sel_type.standard_type.event_data[2] = rqdata[6];
440
441 rc = ipmi_sel_add_entry(intf, &sel_event);
442 if (rc < 0)
443 break;
444 }
445
446 fclose(fp);
447 return rc;
448 }
449
450 static struct ipmi_event_sensor_types oem_kontron_event_reading_types[] __attribute__((unused)) = {
451 { 0x70 , 0x00 , 0xff, "Code Assert" },
452 { 0x71 , 0x00 , 0xff, "Code Assert" },
453 { 0, 0, 0xFF, NULL }
454 };
455
456 char *
get_kontron_evt_desc(struct ipmi_intf * intf,struct sel_event_record * rec)457 get_kontron_evt_desc(struct ipmi_intf *intf, struct sel_event_record * rec)
458 {
459 char * description = NULL;
460 /*
461 * Kontron OEM events are described in the product's user manual, but are limited in favor of
462 * sensor specific
463 */
464
465 /* Only standard records are defined so far */
466 if( rec->record_type < 0xC0 ){
467 const struct ipmi_event_sensor_types *st=NULL;
468 for ( st=oem_kontron_event_types ; st->desc != NULL; st++){
469 if (st->code == rec->sel_type.standard_type.event_type ){
470 size_t len =strlen(st->desc);
471 description = (char*)malloc( len + 1 );
472 memcpy(description, st->desc , len);
473 description[len] = 0;;
474 return description;
475 }
476 }
477 }
478
479 return NULL;
480 }
481
482 char *
get_newisys_evt_desc(struct ipmi_intf * intf,struct sel_event_record * rec)483 get_newisys_evt_desc(struct ipmi_intf * intf, struct sel_event_record * rec)
484 {
485 /*
486 * Newisys OEM event descriptions can be retrieved through an
487 * OEM IPMI command.
488 */
489 struct ipmi_rs * rsp;
490 struct ipmi_rq req;
491 uint8_t msg_data[6];
492 char * description = NULL;
493
494 memset(&req, 0, sizeof(req));
495 req.msg.netfn = 0x2E;
496 req.msg.cmd = 0x01;
497 req.msg.data_len = sizeof(msg_data);
498
499 msg_data[0] = 0x15; /* IANA LSB */
500 msg_data[1] = 0x24; /* IANA */
501 msg_data[2] = 0x00; /* IANA MSB */
502 msg_data[3] = 0x01; /* Subcommand */
503 msg_data[4] = rec->record_id & 0x00FF; /* SEL Record ID LSB */
504 msg_data[5] = (rec->record_id & 0xFF00) >> 8; /* SEL Record ID MSB */
505
506 req.msg.data = msg_data;
507
508 rsp = intf->sendrecv(intf, &req);
509 if (rsp == NULL) {
510 if (verbose)
511 lprintf(LOG_ERR, "Error issuing OEM command");
512 return NULL;
513 }
514 if (rsp->ccode > 0) {
515 if (verbose)
516 lprintf(LOG_ERR, "OEM command returned error code: %s",
517 val2str(rsp->ccode, completion_code_vals));
518 return NULL;
519 }
520
521 /* Verify our response before we use it */
522 if (rsp->data_len < 5)
523 {
524 lprintf(LOG_ERR, "Newisys OEM response too short");
525 return NULL;
526 }
527 else if (rsp->data_len != (4 + rsp->data[3]))
528 {
529 lprintf(LOG_ERR, "Newisys OEM response has unexpected length");
530 return NULL;
531 }
532 else if (IPM_DEV_MANUFACTURER_ID(rsp->data) != IPMI_OEM_NEWISYS)
533 {
534 lprintf(LOG_ERR, "Newisys OEM response has unexpected length");
535 return NULL;
536 }
537
538 description = (char*)malloc(rsp->data[3] + 1);
539 memcpy(description, rsp->data + 4, rsp->data[3]);
540 description[rsp->data[3]] = 0;;
541
542 return description;
543 }
544
545 char *
get_supermicro_evt_desc(struct ipmi_intf * intf,struct sel_event_record * rec)546 get_supermicro_evt_desc(struct ipmi_intf *intf, struct sel_event_record *rec)
547 {
548 struct ipmi_rs *rsp;
549 struct ipmi_rq req;
550 char *desc = NULL;
551 int chipset_type = 4;
552 int data1;
553 int data2;
554 int data3;
555 int sensor_type;
556 uint8_t i = 0;
557 uint16_t oem_id = 0;
558 /* Get the OEM event Bytes of the SEL Records byte 13, 14, 15 to
559 * data1,data2,data3
560 */
561 data1 = rec->sel_type.standard_type.event_data[0];
562 data2 = rec->sel_type.standard_type.event_data[1];
563 data3 = rec->sel_type.standard_type.event_data[2];
564 /* Check for the Standard Event type == 0x6F */
565 if (rec->sel_type.standard_type.event_type != 0x6F) {
566 return NULL;
567 }
568 /* Allocate mem for te Description string */
569 desc = malloc(sizeof(char) * SIZE_OF_DESC);
570 if (desc == NULL) {
571 lprintf(LOG_ERR, "ipmitool: malloc failure");
572 return NULL;
573 }
574 memset(desc, '\0', SIZE_OF_DESC);
575 sensor_type = rec->sel_type.standard_type.sensor_type;
576 switch (sensor_type) {
577 case SENSOR_TYPE_MEMORY:
578 memset(&req, 0, sizeof (req));
579 req.msg.netfn = IPMI_NETFN_APP;
580 req.msg.lun = 0;
581 req.msg.cmd = BMC_GET_DEVICE_ID;
582 req.msg.data = NULL;
583 req.msg.data_len = 0;
584
585 rsp = intf->sendrecv(intf, &req);
586 if (rsp == NULL) {
587 lprintf(LOG_ERR, " Error getting system info");
588 if (desc != NULL) {
589 free(desc);
590 desc = NULL;
591 }
592 return NULL;
593 } else if (rsp->ccode > 0) {
594 lprintf(LOG_ERR, " Error getting system info: %s",
595 val2str(rsp->ccode, completion_code_vals));
596 if (desc != NULL) {
597 free(desc);
598 desc = NULL;
599 }
600 return NULL;
601 }
602 /* check the chipset type */
603 oem_id = ipmi_get_oem_id(intf);
604 if (oem_id == 0) {
605 if (desc != NULL) {
606 free(desc);
607 desc = NULL;
608 }
609 return NULL;
610 }
611 for (i = 0; supermicro_X8[i] != 0xFFFF; i++) {
612 if (oem_id == supermicro_X8[i]) {
613 chipset_type = 0;
614 break;
615 }
616 }
617 for (i = 0; supermicro_older[i] != 0xFFFF; i++) {
618 if (oem_id == supermicro_older[i]) {
619 chipset_type = 0;
620 break;
621 }
622 }
623 for (i = 0; supermicro_romely[i] != 0xFFFF; i++) {
624 if (oem_id == supermicro_romely[i]) {
625 chipset_type = 1;
626 break;
627 }
628 }
629 for (i = 0; supermicro_x9[i] != 0xFFFF; i++) {
630 if (oem_id == supermicro_x9[i]) {
631 chipset_type = 2;
632 break;
633 }
634 }
635 for (i = 0; supermicro_brickland[i] != 0xFFFF; i++) {
636 if (oem_id == supermicro_brickland[i]) {
637 chipset_type = 3;
638 break;
639 }
640 }
641 for (i = 0; supermicro_x10QRH[i] != 0xFFFF; i++) {
642 if (oem_id == supermicro_x10QRH[i]) {
643 chipset_type = 4;
644 break;
645 }
646 }
647 for (i = 0; supermicro_x10QBL[i] != 0xFFFF; i++) {
648 if (oem_id == supermicro_x10QBL[i]) {
649 chipset_type = 4;
650 break;
651 }
652 }
653 for (i = 0; supermicro_x10OBi[i] != 0xFFFF; i++) {
654 if (oem_id == supermicro_x10OBi[i]) {
655 chipset_type = 5;
656 break;
657 }
658 }
659 if (chipset_type == 0) {
660 snprintf(desc, SIZE_OF_DESC, "@DIMM%2X(CPU%x)",
661 data2,
662 (data3 & 0x03) + 1);
663 } else if (chipset_type == 1) {
664 snprintf(desc, SIZE_OF_DESC, "@DIMM%c%c(CPU%x)",
665 (data2 >> 4) + 0x40 + (data3 & 0x3) * 4,
666 (data2 & 0xf) + 0x27, (data3 & 0x03) + 1);
667 } else if (chipset_type == 2) {
668 snprintf(desc, SIZE_OF_DESC, "@DIMM%c%c(CPU%x)",
669 (data2 >> 4) + 0x40 + (data3 & 0x3) * 3,
670 (data2 & 0xf) + 0x27, (data3 & 0x03) + 1);
671 } else if (chipset_type == 3) {
672 snprintf(desc, SIZE_OF_DESC, "@DIMM%c%d(P%dM%d)",
673 ((data2 & 0xf) >> 4) > 4
674 ? '@' - 4 + ((data2 & 0xff) >> 4)
675 : '@' + ((data2 & 0xff) >> 4),
676 (data2 & 0xf) - 0x09, (data3 & 0x0f) + 1,
677 (data2 & 0xff) >> 4 > 4 ? 2 : 1);
678 } else if (chipset_type == 4) {
679 snprintf(desc, SIZE_OF_DESC, "@DIMM%c%c(CPU%x)",
680 (data2 >> 4) + 0x40,
681 (data2 & 0xf) + 0x27, (data3 & 0x03) + 1);
682 } else if (chipset_type == 5) {
683 snprintf(desc, SIZE_OF_DESC, "@DIMM%c%c(CPU%x)",
684 (data2 >> 4) + 0x40,
685 (data2 & 0xf) + 0x27, (data3 & 0x07) + 1);
686 } else {
687 /* No description. */
688 desc[0] = '\0';
689 }
690 break;
691 case SENSOR_TYPE_SUPERMICRO_OEM:
692 if (data1 == 0x80 && data3 == 0xFF) {
693 if (data2 == 0x0) {
694 snprintf(desc, SIZE_OF_DESC, "BMC unexpected reset");
695 } else if (data2 == 0x1) {
696 snprintf(desc, SIZE_OF_DESC, "BMC cold reset");
697 } else if (data2 == 0x2) {
698 snprintf(desc, SIZE_OF_DESC, "BMC warm reset");
699 }
700 }
701 break;
702 }
703 return desc;
704 }
705
706 /*
707 * Function : Decoding the SEL OEM Bytes for the DELL Platforms.
708 * Description : The below fucntion will decode the SEL Events OEM Bytes for the Dell specific Sensors only.
709 * The below function will append the additional information Strings/description to the normal sel desc.
710 * With this the SEL will display additional information sent via OEM Bytes of the SEL Record.
711 * NOTE : Specific to DELL Platforms only.
712 * Returns : Pointer to the char string.
713 */
get_dell_evt_desc(struct ipmi_intf * intf,struct sel_event_record * rec)714 char * get_dell_evt_desc(struct ipmi_intf * intf, struct sel_event_record * rec)
715 {
716 int data1, data2, data3;
717 int sensor_type;
718 char *desc = NULL;
719
720 unsigned char count;
721 unsigned char node;
722 unsigned char dimmNum;
723 unsigned char dimmsPerNode;
724 char dimmStr[MAX_DIMM_STR];
725 char tmpdesc[SIZE_OF_DESC];
726 char* str;
727 unsigned char incr = 0;
728 unsigned char i=0,j = 0;
729 struct ipmi_rs *rsp;
730 struct ipmi_rq req;
731 char tmpData;
732 int version;
733 /* Get the OEM event Bytes of the SEL Records byte 13, 14, 15 to Data1,data2,data3 */
734 data1 = rec->sel_type.standard_type.event_data[0];
735 data2 = rec->sel_type.standard_type.event_data[1];
736 data3 = rec->sel_type.standard_type.event_data[2];
737 /* Check for the Standard Event type == 0x6F */
738 if (0x6F == rec->sel_type.standard_type.event_type)
739 {
740 sensor_type = rec->sel_type.standard_type.sensor_type;
741 /* Allocate mem for te Description string */
742 desc = (char*)malloc(SIZE_OF_DESC);
743 if(NULL == desc)
744 return NULL;
745 memset(desc,0,SIZE_OF_DESC);
746 memset(tmpdesc,0,SIZE_OF_DESC);
747 switch (sensor_type) {
748 case SENSOR_TYPE_PROCESSOR: /* Processor/CPU related OEM Sel Byte Decoding for DELL Platforms only */
749 if((OEM_CODE_IN_BYTE2 == (data1 & DATA_BYTE2_SPECIFIED_MASK)))
750 {
751 if(0x00 == (data1 & MASK_LOWER_NIBBLE))
752 snprintf(desc,SIZE_OF_DESC,"CPU Internal Err | ");
753 if(0x06 == (data1 & MASK_LOWER_NIBBLE))
754 {
755 snprintf(desc,SIZE_OF_DESC,"CPU Protocol Err | ");
756
757 }
758
759 /* change bit location to a number */
760 for (count= 0; count < 8; count++)
761 {
762 if (BIT(count)& data2)
763 {
764 count++;
765 /* 0x0A - CPU sensor number */
766 if((0x06 == (data1 & MASK_LOWER_NIBBLE)) && (0x0A == rec->sel_type.standard_type.sensor_num))
767 snprintf(desc,SIZE_OF_DESC,"FSB %d ",count); // Which CPU Has generated the FSB
768 else
769 snprintf(desc,SIZE_OF_DESC,"CPU %d | APIC ID %d ",count,data3); /* Specific CPU related info */
770 break;
771 }
772 }
773 }
774 break;
775 case SENSOR_TYPE_MEMORY: /* Memory or DIMM related OEM Sel Byte Decoding for DELL Platforms only */
776 case SENSOR_TYPE_EVT_LOG: /* Events Logging for Memory or DIMM related OEM Sel Byte Decoding for DELL Platforms only */
777
778 /* Get the current version of the IPMI Spec Based on that Decoding of memory info is done.*/
779 memset(&req, 0, sizeof (req));
780 req.msg.netfn = IPMI_NETFN_APP;
781 req.msg.lun = 0;
782 req.msg.cmd = BMC_GET_DEVICE_ID;
783 req.msg.data = NULL;
784 req.msg.data_len = 0;
785
786 rsp = intf->sendrecv(intf, &req);
787 if (NULL == rsp)
788 {
789 lprintf(LOG_ERR, " Error getting system info");
790 if (desc != NULL) {
791 free(desc);
792 desc = NULL;
793 }
794 return NULL;
795 }
796 else if (rsp->ccode > 0)
797 {
798 lprintf(LOG_ERR, " Error getting system info: %s",
799 val2str(rsp->ccode, completion_code_vals));
800 if (desc != NULL) {
801 free(desc);
802 desc = NULL;
803 }
804 return NULL;
805 }
806 version = rsp->data[4];
807 /* Memory DIMMS */
808 if( (data1 & OEM_CODE_IN_BYTE2) || (data1 & OEM_CODE_IN_BYTE3 ) )
809 {
810 /* Memory Redundancy related oem bytes docoding .. */
811 if( (SENSOR_TYPE_MEMORY == sensor_type) && (0x0B == rec->sel_type.standard_type.event_type) )
812 {
813 if(0x00 == (data1 & MASK_LOWER_NIBBLE))
814 {
815 snprintf(desc,SIZE_OF_DESC," Redundancy Regained | ");
816 }
817 else if(0x01 == (data1 & MASK_LOWER_NIBBLE))
818 {
819 snprintf(desc,SIZE_OF_DESC,"Redundancy Lost | ");
820 }
821 } /* Correctable and uncorrectable ECC Error Decoding */
822 else if(SENSOR_TYPE_MEMORY == sensor_type)
823 {
824 if(0x00 == (data1 & MASK_LOWER_NIBBLE))
825 {
826 /* 0x1C - Memory Sensor Number */
827 if(0x1C == rec->sel_type.standard_type.sensor_num)
828 {
829 /*Add the complete information about the Memory Configs.*/
830 if((data1 & OEM_CODE_IN_BYTE2) && (data1 & OEM_CODE_IN_BYTE3 ))
831 {
832 count = 0;
833 snprintf(desc,SIZE_OF_DESC,"CRC Error on:");
834 for(i=0;i<4;i++)
835 {
836 if((BIT(i))&(data2))
837 {
838 if(count)
839 {
840 str = desc+strlen(desc);
841 *str++ = ',';
842 str = '\0';
843 count = 0;
844 }
845 switch(i) /* Which type of memory config is present.. */
846 {
847 case 0: snprintf(tmpdesc,SIZE_OF_DESC,"South Bound Memory");
848 strcat(desc,tmpdesc);
849 count++;
850 break;
851 case 1: snprintf(tmpdesc,SIZE_OF_DESC,"South Bound Config");
852 strcat(desc,tmpdesc);
853 count++;
854 break;
855 case 2: snprintf(tmpdesc,SIZE_OF_DESC,"North Bound memory");
856 strcat(desc,tmpdesc);
857 count++;
858 break;
859 case 3: snprintf(tmpdesc,SIZE_OF_DESC,"North Bound memory-corr");
860 strcat(desc,tmpdesc);
861 count++;
862 break;
863 default:
864 break;
865 }
866 }
867 }
868 if(data3>=0x00 && data3<0xFF)
869 {
870 snprintf(tmpdesc,SIZE_OF_DESC,"|Failing_Channel:%d",data3);
871 strcat(desc,tmpdesc);
872 }
873 }
874 break;
875 }
876 snprintf(desc,SIZE_OF_DESC,"Correctable ECC | ");
877 }
878 else if(0x01 == (data1 & MASK_LOWER_NIBBLE))
879 {
880 snprintf(desc,SIZE_OF_DESC,"UnCorrectable ECC | ");
881 }
882 } /* Corr Memory log disabled */
883 else if(SENSOR_TYPE_EVT_LOG == sensor_type)
884 {
885 if(0x00 == (data1 & MASK_LOWER_NIBBLE))
886 snprintf(desc,SIZE_OF_DESC,"Corr Memory Log Disabled | ");
887 }
888 }
889 else
890 {
891 if(SENSOR_TYPE_SYS_EVENT == sensor_type)
892 {
893 if(0x02 == (data1 & MASK_LOWER_NIBBLE))
894 snprintf(desc,SIZE_OF_DESC,"Unknown System Hardware Failure ");
895 }
896 if(SENSOR_TYPE_EVT_LOG == sensor_type)
897 {
898 if(0x03 == (data1 & MASK_LOWER_NIBBLE))
899 snprintf(desc,SIZE_OF_DESC,"All Even Logging Dissabled");
900 }
901 }
902 /*
903 * Based on the above error, we need to find whcih memory slot or
904 * Card has got the Errors/Sel Generated.
905 */
906 if(data1 & OEM_CODE_IN_BYTE2 )
907 {
908 /* Find the Card Type */
909 if((0x0F != (data2 >> 4)) && ((data2 >> 4) < 0x08))
910 {
911 tmpData = ('A'+ (data2 >> 4));
912 if( (SENSOR_TYPE_MEMORY == sensor_type) && (0x0B == rec->sel_type.standard_type.event_type) )
913 {
914 snprintf(tmpdesc, SIZE_OF_DESC, "Bad Card %c", tmpData);
915 }
916 else
917 {
918 snprintf(tmpdesc, SIZE_OF_DESC, "Card %c", tmpData);
919 }
920 strcat(desc, tmpdesc);
921 } /* Find the Bank Number of the DIMM */
922 if (0x0F != (data2 & MASK_LOWER_NIBBLE))
923 {
924 if(0x51 == version)
925 {
926 snprintf(tmpdesc, SIZE_OF_DESC, "Bank %d", ((data2 & 0x0F)+1));
927 strcat(desc, tmpdesc);
928 }
929 else
930 {
931 incr = (data2 & 0x0f) << 3;
932 }
933 }
934
935 }
936 /* Find the DIMM Number of the Memory which has Generated the Fault or Sel */
937 if(data1 & OEM_CODE_IN_BYTE3 )
938 {
939 // Based on the IPMI Spec Need Identify the DIMM Details.
940 // For the SPEC 1.5 Only the DIMM Number is Valid.
941 if(0x51 == version)
942 {
943 snprintf(tmpdesc, SIZE_OF_DESC, "DIMM %c", ('A'+ data3));
944 strcat(desc, tmpdesc);
945 }
946 /* For the SPEC 2.0 Decode the DIMM Number as it supports more.*/
947 else if( ((data2 >> 4) > 0x07) && (0x0F != (data2 >> 4) ))
948 {
949 strcpy(dimmStr, " DIMM");
950 str = desc+strlen(desc);
951 dimmsPerNode = 4;
952 if(0x09 == (data2 >> 4)) dimmsPerNode = 6;
953 else if(0x0A == (data2 >> 4)) dimmsPerNode = 8;
954 else if(0x0B == (data2 >> 4)) dimmsPerNode = 9;
955 else if(0x0C == (data2 >> 4)) dimmsPerNode = 12;
956 else if(0x0D == (data2 >> 4)) dimmsPerNode = 24;
957 else if(0x0E == (data2 >> 4)) dimmsPerNode = 3;
958 count = 0;
959 for (i = 0; i < 8; i++)
960 {
961 if (BIT(i) & data3)
962 {
963 if(count)
964 {
965 strcat(str,",");
966 count = 0x00;
967 }
968 node = (incr + i)/dimmsPerNode;
969 dimmNum = ((incr + i)%dimmsPerNode)+1;
970 dimmStr[5] = node + 'A';
971 sprintf(tmpdesc,"%d",dimmNum);
972 for(j = 0; j < strlen(tmpdesc);j++)
973 dimmStr[6+j] = tmpdesc[j];
974 dimmStr[6+j] = '\0';
975 strcat(str,dimmStr); // final DIMM Details.
976 count++;
977 }
978 }
979 }
980 else
981 {
982 strcpy(dimmStr, " DIMM");
983 str = desc+strlen(desc);
984 count = 0;
985 for (i = 0; i < 8; i++)
986 {
987 if (BIT(i) & data3)
988 {
989 // check if more than one DIMM, if so add a comma to the string.
990 sprintf(tmpdesc,"%d",(i + incr + 1));
991 if(count)
992 {
993 strcat(str,",");
994 count = 0x00;
995 }
996 for(j = 0; j < strlen(tmpdesc);j++)
997 dimmStr[5+j] = tmpdesc[j];
998 dimmStr[5+j] = '\0';
999 strcat(str, dimmStr);
1000 count++;
1001 }
1002 }
1003 }
1004 }
1005 break;
1006 /* Sensor In system charectorization Error Decoding.
1007 Sensor type 0x20*/
1008 case SENSOR_TYPE_TXT_CMD_ERROR:
1009 if((0x00 == (data1 & MASK_LOWER_NIBBLE))&&((data1 & OEM_CODE_IN_BYTE2) && (data1 & OEM_CODE_IN_BYTE3)))
1010 {
1011 switch(data3)
1012 {
1013 case 0x01:
1014 snprintf(desc,SIZE_OF_DESC,"BIOS TXT Error");
1015 break;
1016 case 0x02:
1017 snprintf(desc,SIZE_OF_DESC,"Processor/FIT TXT");
1018 break;
1019 case 0x03:
1020 snprintf(desc,SIZE_OF_DESC,"BIOS ACM TXT Error");
1021 break;
1022 case 0x04:
1023 snprintf(desc,SIZE_OF_DESC,"SINIT ACM TXT Error");
1024 break;
1025 case 0xff:
1026 snprintf(desc,SIZE_OF_DESC,"Unrecognized TT Error12");
1027 break;
1028 default:
1029 break;
1030 }
1031 }
1032 break;
1033 /* OS Watch Dog Timer Sel Events */
1034 case SENSOR_TYPE_WTDOG:
1035
1036 if(SENSOR_TYPE_OEM_SEC_EVENT == data1)
1037 {
1038 if(0x04 == data2)
1039 {
1040 snprintf(desc,SIZE_OF_DESC,"Hard Reset|Interrupt type None,SMS/OS Timer used at expiration");
1041 }
1042 }
1043
1044 break;
1045 /* This Event is for BMC to Othe Hardware or CPU . */
1046 case SENSOR_TYPE_VER_CHANGE:
1047 if((0x02 == (data1 & MASK_LOWER_NIBBLE))&&((data1 & OEM_CODE_IN_BYTE2) && (data1 & OEM_CODE_IN_BYTE3)))
1048 {
1049 if(0x02 == data2)
1050 {
1051 if(0x00 == data3)
1052 {
1053 snprintf(desc, SIZE_OF_DESC, "between BMC/iDRAC Firmware and other hardware");
1054 }
1055 else if(0x01 == data3)
1056 {
1057 snprintf(desc, SIZE_OF_DESC, "between BMC/iDRAC Firmware and CPU");
1058 }
1059 }
1060 }
1061 break;
1062 /* Flex or Mac tuning OEM Decoding for the DELL. */
1063 case SENSOR_TYPE_OEM_SEC_EVENT:
1064 /* 0x25 - Virtual MAC sensory number - Dell OEM */
1065 if(0x25 == rec->sel_type.standard_type.sensor_num)
1066 {
1067 if(0x01 == (data1 & MASK_LOWER_NIBBLE))
1068 {
1069 snprintf(desc, SIZE_OF_DESC, "Failed to program Virtual Mac Address");
1070 if((data1 & OEM_CODE_IN_BYTE2)&&(data1 & OEM_CODE_IN_BYTE3))
1071 {
1072 snprintf(tmpdesc, SIZE_OF_DESC, " at bus:%.2x device:%.2x function:%x",
1073 data3 &0x7F, (data2 >> 3) & 0x1F,
1074 data2 & 0x07);
1075 strcat(desc,tmpdesc);
1076 }
1077 }
1078 else if(0x02 == (data1 & MASK_LOWER_NIBBLE))
1079 {
1080 snprintf(desc, SIZE_OF_DESC, "Device option ROM failed to support link tuning or flex address");
1081 }
1082 else if(0x03 == (data1 & MASK_LOWER_NIBBLE))
1083 {
1084 snprintf(desc, SIZE_OF_DESC, "Failed to get link tuning or flex address data from BMC/iDRAC");
1085 }
1086 }
1087 break;
1088 case SENSOR_TYPE_CRIT_INTR:
1089 case SENSOR_TYPE_OEM_NFATAL_ERROR: /* Non - Fatal PCIe Express Error Decoding */
1090 case SENSOR_TYPE_OEM_FATAL_ERROR: /* Fatal IO Error Decoding */
1091 /* 0x29 - QPI Linx Error Sensor Dell OEM */
1092 if(0x29 == rec->sel_type.standard_type.sensor_num)
1093 {
1094 if((0x02 == (data1 & MASK_LOWER_NIBBLE))&&((data1 & OEM_CODE_IN_BYTE2) && (data1 & OEM_CODE_IN_BYTE3)))
1095 {
1096 snprintf(tmpdesc, SIZE_OF_DESC, "Partner-(LinkId:%d,AgentId:%d)|",(data2 & 0xC0),(data2 & 0x30));
1097 strcat(desc,tmpdesc);
1098 snprintf(tmpdesc, SIZE_OF_DESC, "ReportingAgent(LinkId:%d,AgentId:%d)|",(data2 & 0x0C),(data2 & 0x03));
1099 strcat(desc,tmpdesc);
1100 if(0x00 == (data3 & 0xFC))
1101 {
1102 snprintf(tmpdesc, SIZE_OF_DESC, "LinkWidthDegraded|");
1103 strcat(desc,tmpdesc);
1104 }
1105 if(BIT(1)& data3)
1106 {
1107 snprintf(tmpdesc,SIZE_OF_DESC,"PA_Type:IOH|");
1108 }
1109 else
1110 {
1111 snprintf(tmpdesc,SIZE_OF_DESC,"PA-Type:CPU|");
1112 }
1113 strcat(desc,tmpdesc);
1114 if(BIT(0)& data3)
1115 {
1116 snprintf(tmpdesc,SIZE_OF_DESC,"RA-Type:IOH");
1117 }
1118 else
1119 {
1120 snprintf(tmpdesc,SIZE_OF_DESC,"RA-Type:CPU");
1121 }
1122 strcat(desc,tmpdesc);
1123 }
1124 }
1125 else
1126 {
1127
1128 if(0x02 == (data1 & MASK_LOWER_NIBBLE))
1129 {
1130 sprintf(desc,"%s","IO channel Check NMI");
1131 }
1132 else
1133 {
1134 if(0x00 == (data1 & MASK_LOWER_NIBBLE))
1135 {
1136 snprintf(desc, SIZE_OF_DESC, "%s","PCIe Error |");
1137 }
1138 else if(0x01 == (data1 & MASK_LOWER_NIBBLE))
1139 {
1140 snprintf(desc, SIZE_OF_DESC, "%s","I/O Error |");
1141 }
1142 else if(0x04 == (data1 & MASK_LOWER_NIBBLE))
1143 {
1144 snprintf(desc, SIZE_OF_DESC, "%s","PCI PERR |");
1145 }
1146 else if(0x05 == (data1 & MASK_LOWER_NIBBLE))
1147 {
1148 snprintf(desc, SIZE_OF_DESC, "%s","PCI SERR |");
1149 }
1150 else
1151 {
1152 snprintf(desc, SIZE_OF_DESC, "%s"," ");
1153 }
1154 if (data3 & 0x80)
1155 snprintf(tmpdesc, SIZE_OF_DESC, "Slot %d", data3 & 0x7F);
1156 else
1157 snprintf(tmpdesc, SIZE_OF_DESC, "PCI bus:%.2x device:%.2x function:%x",
1158 data3 &0x7F, (data2 >> 3) & 0x1F,
1159 data2 & 0x07);
1160
1161 strcat(desc,tmpdesc);
1162 }
1163 }
1164 break;
1165 /* POST Fatal Errors generated from the Server with much more info*/
1166 case SENSOR_TYPE_FRM_PROG:
1167 if((0x0F == (data1 & MASK_LOWER_NIBBLE))&&(data1 & OEM_CODE_IN_BYTE2))
1168 {
1169 switch(data2)
1170 {
1171 case 0x80:
1172 snprintf(desc, SIZE_OF_DESC, "No memory is detected.");break;
1173 case 0x81:
1174 snprintf(desc,SIZE_OF_DESC, "Memory is detected but is not configurable.");break;
1175 case 0x82:
1176 snprintf(desc, SIZE_OF_DESC, "Memory is configured but not usable.");break;
1177 case 0x83:
1178 snprintf(desc, SIZE_OF_DESC, "System BIOS shadow failed.");break;
1179 case 0x84:
1180 snprintf(desc, SIZE_OF_DESC, "CMOS failed.");break;
1181 case 0x85:
1182 snprintf(desc, SIZE_OF_DESC, "DMA controller failed.");break;
1183 case 0x86:
1184 snprintf(desc, SIZE_OF_DESC, "Interrupt controller failed.");break;
1185 case 0x87:
1186 snprintf(desc, SIZE_OF_DESC, "Timer refresh failed.");break;
1187 case 0x88:
1188 snprintf(desc, SIZE_OF_DESC, "Programmable interval timer error.");break;
1189 case 0x89:
1190 snprintf(desc, SIZE_OF_DESC, "Parity error.");break;
1191 case 0x8A:
1192 snprintf(desc, SIZE_OF_DESC, "SIO failed.");break;
1193 case 0x8B:
1194 snprintf(desc, SIZE_OF_DESC, "Keyboard controller failed.");break;
1195 case 0x8C:
1196 snprintf(desc, SIZE_OF_DESC, "System management interrupt initialization failed.");break;
1197 case 0x8D:
1198 snprintf(desc, SIZE_OF_DESC, "TXT-SX Error.");break;
1199 case 0xC0:
1200 snprintf(desc, SIZE_OF_DESC, "Shutdown test failed.");break;
1201 case 0xC1:
1202 snprintf(desc, SIZE_OF_DESC, "BIOS POST memory test failed.");break;
1203 case 0xC2:
1204 snprintf(desc, SIZE_OF_DESC, "RAC configuration failed.");break;
1205 case 0xC3:
1206 snprintf(desc, SIZE_OF_DESC, "CPU configuration failed.");break;
1207 case 0xC4:
1208 snprintf(desc, SIZE_OF_DESC, "Incorrect memory configuration.");break;
1209 case 0xFE:
1210 snprintf(desc, SIZE_OF_DESC, "General failure after video.");
1211 break;
1212 }
1213 }
1214 break;
1215
1216 default:
1217 break;
1218 }
1219 }
1220 else
1221 {
1222 sensor_type = rec->sel_type.standard_type.event_type;
1223 }
1224 return desc;
1225 }
1226
1227 char *
ipmi_get_oem_desc(struct ipmi_intf * intf,struct sel_event_record * rec)1228 ipmi_get_oem_desc(struct ipmi_intf * intf, struct sel_event_record * rec)
1229 {
1230 char * desc = NULL;
1231
1232 switch (ipmi_get_oem(intf))
1233 {
1234 case IPMI_OEM_NEWISYS:
1235 desc = get_newisys_evt_desc(intf, rec);
1236 break;
1237 case IPMI_OEM_KONTRON:
1238 desc = get_kontron_evt_desc(intf, rec);
1239 break;
1240 case IPMI_OEM_DELL: // Dell Decoding of the OEM Bytes from SEL Record.
1241 desc = get_dell_evt_desc(intf, rec);
1242 break;
1243 case IPMI_OEM_SUPERMICRO:
1244 case IPMI_OEM_SUPERMICRO_47488:
1245 desc = get_supermicro_evt_desc(intf, rec);
1246 break;
1247 case IPMI_OEM_UNKNOWN:
1248 default:
1249 break;
1250 }
1251
1252 return desc;
1253 }
1254
1255
1256 const struct ipmi_event_sensor_types *
ipmi_get_first_event_sensor_type(struct ipmi_intf * intf,uint8_t sensor_type,uint8_t event_type)1257 ipmi_get_first_event_sensor_type(struct ipmi_intf *intf,
1258 uint8_t sensor_type, uint8_t event_type)
1259 {
1260 const struct ipmi_event_sensor_types *evt, *start, *next = NULL;
1261 uint8_t code;
1262
1263 if (event_type == 0x6f) {
1264 if (sensor_type >= 0xC0
1265 && sensor_type < 0xF0
1266 && ipmi_get_oem(intf) == IPMI_OEM_KONTRON) {
1267 /* check Kontron OEM sensor event types */
1268 start = oem_kontron_event_types;
1269 } else if (intf->vita_avail) {
1270 /* check VITA sensor event types first */
1271 start = vita_sensor_event_types;
1272
1273 /* then check generic sensor types */
1274 next = sensor_specific_event_types;
1275 } else {
1276 /* check generic sensor types */
1277 start = sensor_specific_event_types;
1278 }
1279 code = sensor_type;
1280 } else {
1281 start = generic_event_types;
1282 code = event_type;
1283 }
1284
1285 for (evt = start; evt->desc != NULL || next != NULL; evt++) {
1286 /* check if VITA sensor event types has finished */
1287 if (evt->desc == NULL) {
1288 /* proceed with next table */
1289 evt = next;
1290 next = NULL;
1291 }
1292
1293 if (code == evt->code)
1294 return evt;
1295 }
1296
1297 return NULL;
1298 }
1299
1300
1301 const struct ipmi_event_sensor_types *
ipmi_get_next_event_sensor_type(const struct ipmi_event_sensor_types * evt)1302 ipmi_get_next_event_sensor_type(const struct ipmi_event_sensor_types *evt)
1303 {
1304 const struct ipmi_event_sensor_types *start = evt;
1305
1306 for (evt = start + 1; evt->desc != NULL; evt++) {
1307 if (evt->code == start->code) {
1308 return evt;
1309 }
1310 }
1311
1312 return NULL;
1313 }
1314
1315
1316 void
ipmi_get_event_desc(struct ipmi_intf * intf,struct sel_event_record * rec,char ** desc)1317 ipmi_get_event_desc(struct ipmi_intf * intf, struct sel_event_record * rec, char ** desc)
1318 {
1319 uint8_t offset;
1320 const struct ipmi_event_sensor_types *evt = NULL;
1321 char *sfx = NULL; /* This will be assigned if the Platform is DELL,
1322 additional info is appended to the current Description */
1323
1324 if (desc == NULL)
1325 return;
1326 *desc = NULL;
1327
1328 if ((rec->sel_type.standard_type.event_type >= 0x70) && (rec->sel_type.standard_type.event_type < 0x7F)) {
1329 *desc = ipmi_get_oem_desc(intf, rec);
1330 return;
1331 } else if (rec->sel_type.standard_type.event_type == 0x6f) {
1332 if( rec->sel_type.standard_type.sensor_type >= 0xC0 && rec->sel_type.standard_type.sensor_type < 0xF0) {
1333 IPMI_OEM iana = ipmi_get_oem(intf);
1334
1335 switch(iana){
1336 case IPMI_OEM_KONTRON:
1337 lprintf(LOG_DEBUG, "oem sensor type %x %d using oem type supplied description",
1338 rec->sel_type.standard_type.sensor_type , iana);
1339 break;
1340 case IPMI_OEM_DELL: /* OEM Bytes Decoding for DELLi */
1341 if ( (OEM_CODE_IN_BYTE2 == (rec->sel_type.standard_type.event_data[0] & DATA_BYTE2_SPECIFIED_MASK)) ||
1342 (OEM_CODE_IN_BYTE3 == (rec->sel_type.standard_type.event_data[0] & DATA_BYTE3_SPECIFIED_MASK)) )
1343 {
1344 sfx = ipmi_get_oem_desc(intf, rec);
1345 }
1346 break;
1347 case IPMI_OEM_SUPERMICRO:
1348 case IPMI_OEM_SUPERMICRO_47488:
1349 sfx = ipmi_get_oem_desc(intf, rec);
1350 break;
1351 /* add your oem sensor assignation here */
1352 default:
1353 lprintf(LOG_DEBUG, "oem sensor type %x using standard type supplied description",
1354 rec->sel_type.standard_type.sensor_type );
1355 break;
1356 }
1357 } else {
1358 switch (ipmi_get_oem(intf)) {
1359 case IPMI_OEM_SUPERMICRO:
1360 case IPMI_OEM_SUPERMICRO_47488:
1361 sfx = ipmi_get_oem_desc(intf, rec);
1362 break;
1363 default:
1364 break;
1365 }
1366 }
1367 /*
1368 * Check for the OEM DELL Interface based on the Dell Specific Vendor Code.
1369 * If its Dell Platform, do the OEM Byte decode from the SEL Records.
1370 * Additional information should be written by the ipmi_get_oem_desc()
1371 */
1372 if(ipmi_get_oem(intf) == IPMI_OEM_DELL) {
1373 if ( (OEM_CODE_IN_BYTE2 == (rec->sel_type.standard_type.event_data[0] & DATA_BYTE2_SPECIFIED_MASK)) ||
1374 (OEM_CODE_IN_BYTE3 == (rec->sel_type.standard_type.event_data[0] & DATA_BYTE3_SPECIFIED_MASK)) )
1375 {
1376 sfx = ipmi_get_oem_desc(intf, rec);
1377 }
1378 else if(SENSOR_TYPE_OEM_SEC_EVENT == rec->sel_type.standard_type.event_data[0])
1379 {
1380 /* 0x23 : Sensor Number.*/
1381 if(0x23 == rec->sel_type.standard_type.sensor_num)
1382 sfx = ipmi_get_oem_desc(intf, rec);
1383 }
1384 }
1385 }
1386
1387 offset = rec->sel_type.standard_type.event_data[0] & 0xf;
1388
1389 for (evt = ipmi_get_first_event_sensor_type(intf,
1390 rec->sel_type.standard_type.sensor_type,
1391 rec->sel_type.standard_type.event_type);
1392 evt != NULL; evt = ipmi_get_next_event_sensor_type(evt)) {
1393 if ((evt->offset == offset && evt->desc != NULL) &&
1394 ((evt->data == ALL_OFFSETS_SPECIFIED) ||
1395 ((rec->sel_type.standard_type.event_data[0] & DATA_BYTE2_SPECIFIED_MASK) &&
1396 (evt->data == rec->sel_type.standard_type.event_data[1]))))
1397 {
1398 /* Increase the Malloc size to current_size + Dellspecific description size */
1399 *desc = (char *)malloc(strlen(evt->desc) + 48 + SIZE_OF_DESC);
1400 if (NULL == *desc) {
1401 lprintf(LOG_ERR, "ipmitool: malloc failure");
1402 return;
1403 }
1404 memset(*desc, 0, strlen(evt->desc)+ 48 + SIZE_OF_DESC);
1405 /*
1406 * Additional info is present for the DELL Platforms.
1407 * Append the same to the evt->desc string.
1408 */
1409 if (sfx) {
1410 sprintf(*desc, "%s (%s)", evt->desc, sfx);
1411 free(sfx);
1412 sfx = NULL;
1413 } else {
1414 sprintf(*desc, "%s", evt->desc);
1415 }
1416 return;
1417 }
1418 }
1419 /* The Above while Condition was not met beacouse the below sensor type were Newly defined OEM
1420 Secondary Events. 0xC1, 0xC2, 0xC3. */
1421 if((sfx) && (0x6F == rec->sel_type.standard_type.event_type))
1422 {
1423 uint8_t flag = 0x00;
1424 switch(rec->sel_type.standard_type.sensor_type)
1425 {
1426 case SENSOR_TYPE_FRM_PROG:
1427 if(0x0F == offset)
1428 flag = 0x01;
1429 break;
1430 case SENSOR_TYPE_OEM_SEC_EVENT:
1431 if((0x01 == offset) || (0x02 == offset) || (0x03 == offset))
1432 flag = 0x01;
1433 break;
1434 case SENSOR_TYPE_OEM_NFATAL_ERROR:
1435 if((0x00 == offset) || (0x02 == offset))
1436 flag = 0x01;
1437 break;
1438 case SENSOR_TYPE_OEM_FATAL_ERROR:
1439 if(0x01 == offset)
1440 flag = 0x01;
1441 break;
1442 case SENSOR_TYPE_SUPERMICRO_OEM:
1443 flag = 0x02;
1444 break;
1445 default:
1446 break;
1447 }
1448 if(flag)
1449 {
1450 *desc = (char *)malloc( 48 + SIZE_OF_DESC);
1451 if (NULL == *desc)
1452 {
1453 lprintf(LOG_ERR, "ipmitool: malloc failure");
1454 return;
1455 }
1456 memset(*desc, 0, 48 + SIZE_OF_DESC);
1457 if (flag == 0x02) {
1458 sprintf(*desc, "%s", sfx);
1459 return;
1460 }
1461 sprintf(*desc, "(%s)",sfx);
1462 }
1463 free(sfx);
1464 sfx = NULL;
1465 }
1466 }
1467
1468
1469 const char*
ipmi_get_generic_sensor_type(uint8_t code)1470 ipmi_get_generic_sensor_type(uint8_t code)
1471 {
1472 if (code <= SENSOR_TYPE_MAX) {
1473 return ipmi_generic_sensor_type_vals[code];
1474 }
1475
1476 return NULL;
1477 }
1478
1479
1480 const char *
ipmi_get_oem_sensor_type(struct ipmi_intf * intf,uint8_t code)1481 ipmi_get_oem_sensor_type(struct ipmi_intf *intf, uint8_t code)
1482 {
1483 const struct oemvalstr *v, *found = NULL;
1484 uint32_t iana = ipmi_get_oem(intf);
1485
1486 for (v = ipmi_oem_sensor_type_vals; v->str; v++) {
1487 if (v->oem == iana && v->val == code) {
1488 return v->str;
1489 }
1490
1491 if ((intf->picmg_avail
1492 && v->oem == IPMI_OEM_PICMG
1493 && v->val == code)
1494 || (intf->vita_avail
1495 && v->oem == IPMI_OEM_VITA
1496 && v->val == code)) {
1497 found = v;
1498 }
1499 }
1500
1501 return found ? found->str : NULL;
1502 }
1503
1504
1505 const char *
ipmi_get_sensor_type(struct ipmi_intf * intf,uint8_t code)1506 ipmi_get_sensor_type(struct ipmi_intf *intf, uint8_t code)
1507 {
1508 const char *type;
1509
1510 if (code >= 0xC0) {
1511 type = ipmi_get_oem_sensor_type(intf, code);
1512 } else {
1513 type = ipmi_get_generic_sensor_type(code);
1514 }
1515
1516 if (type == NULL) {
1517 type = "Unknown";
1518 }
1519
1520 return type;
1521 }
1522
1523 static int
ipmi_sel_get_info(struct ipmi_intf * intf)1524 ipmi_sel_get_info(struct ipmi_intf * intf)
1525 {
1526 struct ipmi_rs * rsp;
1527 struct ipmi_rq req;
1528 uint16_t e, version;
1529 uint32_t f;
1530 int pctfull = 0;
1531 uint32_t fs = 0xffffffff;
1532 uint32_t zeros = 0;
1533
1534
1535 memset(&req, 0, sizeof(req));
1536 req.msg.netfn = IPMI_NETFN_STORAGE;
1537 req.msg.cmd = IPMI_CMD_GET_SEL_INFO;
1538
1539 rsp = intf->sendrecv(intf, &req);
1540 if (rsp == NULL) {
1541 lprintf(LOG_ERR, "Get SEL Info command failed");
1542 return -1;
1543 } else if (rsp->ccode > 0) {
1544 lprintf(LOG_ERR, "Get SEL Info command failed: %s",
1545 val2str(rsp->ccode, completion_code_vals));
1546 return -1;
1547 } else if (rsp->data_len != 14) {
1548 lprintf(LOG_ERR, "Get SEL Info command failed: "
1549 "Invalid data length %d", rsp->data_len);
1550 return (-1);
1551 }
1552 if (verbose > 2)
1553 printbuf(rsp->data, rsp->data_len, "sel_info");
1554
1555 printf("SEL Information\n");
1556 version = rsp->data[0];
1557 printf("Version : %d.%d (%s)\n",
1558 version & 0xf, (version>>4) & 0xf,
1559 (version == 0x51 || version == 0x02) ? "v1.5, v2 compliant" : "Unknown");
1560
1561 /* save the entry count and free space to determine percent full */
1562 e = buf2short(rsp->data + 1);
1563 f = buf2short(rsp->data + 3);
1564 printf("Entries : %d\n", e);
1565 printf("Free Space : %d bytes %s\n", f ,(f==65535 ? "or more" : "" ));
1566
1567 if (e) {
1568 e *= 16; /* each entry takes 16 bytes */
1569 f += e; /* this is supposed to give the total size ... */
1570 pctfull = (int)(100 * ( (double)e / (double)f ));
1571 }
1572
1573 if( f >= 65535 ) {
1574 printf("Percent Used : %s\n", "unknown" );
1575 }
1576 else {
1577 printf("Percent Used : %d%%\n", pctfull);
1578 }
1579
1580
1581 if ((!memcmp(rsp->data + 5, &fs, 4)) ||
1582 (!memcmp(rsp->data + 5, &zeros, 4)))
1583 printf("Last Add Time : Not Available\n");
1584 else
1585 printf("Last Add Time : %s\n",
1586 ipmi_sel_timestamp(buf2long(rsp->data + 5)));
1587
1588 if ((!memcmp(rsp->data + 9, &fs, 4)) ||
1589 (!memcmp(rsp->data + 9, &zeros, 4)))
1590 printf("Last Del Time : Not Available\n");
1591 else
1592 printf("Last Del Time : %s\n",
1593 ipmi_sel_timestamp(buf2long(rsp->data + 9)));
1594
1595
1596 printf("Overflow : %s\n",
1597 rsp->data[13] & 0x80 ? "true" : "false");
1598 printf("Supported Cmds : ");
1599 if (rsp->data[13] & 0x0f)
1600 {
1601 if (rsp->data[13] & 0x08)
1602 printf("'Delete' ");
1603 if (rsp->data[13] & 0x04)
1604 printf("'Partial Add' ");
1605 if (rsp->data[13] & 0x02)
1606 printf("'Reserve' ");
1607 if (rsp->data[13] & 0x01)
1608 printf("'Get Alloc Info' ");
1609 }
1610 else
1611 printf("None");
1612 printf("\n");
1613
1614 /* get sel allocation info if supported */
1615 if (rsp->data[13] & 1) {
1616 memset(&req, 0, sizeof(req));
1617 req.msg.netfn = IPMI_NETFN_STORAGE;
1618 req.msg.cmd = IPMI_CMD_GET_SEL_ALLOC_INFO;
1619
1620 rsp = intf->sendrecv(intf, &req);
1621 if (rsp == NULL) {
1622 lprintf(LOG_ERR,
1623 "Get SEL Allocation Info command failed");
1624 return -1;
1625 }
1626 if (rsp->ccode > 0) {
1627 lprintf(LOG_ERR,
1628 "Get SEL Allocation Info command failed: %s",
1629 val2str(rsp->ccode, completion_code_vals));
1630 return -1;
1631 }
1632
1633 printf("# of Alloc Units : %d\n", buf2short(rsp->data));
1634 printf("Alloc Unit Size : %d\n", buf2short(rsp->data + 2));
1635 printf("# Free Units : %d\n", buf2short(rsp->data + 4));
1636 printf("Largest Free Blk : %d\n", buf2short(rsp->data + 6));
1637 printf("Max Record Size : %d\n", rsp->data[8]);
1638 }
1639 return 0;
1640 }
1641
1642 uint16_t
ipmi_sel_get_std_entry(struct ipmi_intf * intf,uint16_t id,struct sel_event_record * evt)1643 ipmi_sel_get_std_entry(struct ipmi_intf * intf, uint16_t id,
1644 struct sel_event_record * evt)
1645 {
1646 struct ipmi_rq req;
1647 struct ipmi_rs * rsp;
1648 uint8_t msg_data[6];
1649 uint16_t next;
1650 int data_count;
1651
1652 memset(msg_data, 0, 6);
1653 msg_data[0] = 0x00; /* no reserve id, not partial get */
1654 msg_data[1] = 0x00;
1655 msg_data[2] = id & 0xff;
1656 msg_data[3] = (id >> 8) & 0xff;
1657 msg_data[4] = 0x00; /* offset */
1658 msg_data[5] = 0xff; /* length */
1659
1660 memset(&req, 0, sizeof(req));
1661 req.msg.netfn = IPMI_NETFN_STORAGE;
1662 req.msg.cmd = IPMI_CMD_GET_SEL_ENTRY;
1663 req.msg.data = msg_data;
1664 req.msg.data_len = 6;
1665
1666 rsp = intf->sendrecv(intf, &req);
1667 if (rsp == NULL) {
1668 lprintf(LOG_ERR, "Get SEL Entry %x command failed", id);
1669 return 0;
1670 }
1671 if (rsp->ccode > 0) {
1672 lprintf(LOG_ERR, "Get SEL Entry %x command failed: %s",
1673 id, val2str(rsp->ccode, completion_code_vals));
1674 return 0;
1675 }
1676
1677 /* save next entry id */
1678 next = (rsp->data[1] << 8) | rsp->data[0];
1679
1680 lprintf(LOG_DEBUG, "SEL Entry: %s", buf2str(rsp->data+2, rsp->data_len-2));
1681 memset(evt, 0, sizeof(*evt));
1682
1683 /*Clear SEL Structure*/
1684 evt->record_id = 0;
1685 evt->record_type = 0;
1686 if (evt->record_type < 0xc0)
1687 {
1688 evt->sel_type.standard_type.timestamp = 0;
1689 evt->sel_type.standard_type.gen_id = 0;
1690 evt->sel_type.standard_type.evm_rev = 0;
1691 evt->sel_type.standard_type.sensor_type = 0;
1692 evt->sel_type.standard_type.sensor_num = 0;
1693 evt->sel_type.standard_type.event_type = 0;
1694 evt->sel_type.standard_type.event_dir = 0;
1695 evt->sel_type.standard_type.event_data[0] = 0;
1696 evt->sel_type.standard_type.event_data[1] = 0;
1697 evt->sel_type.standard_type.event_data[2] = 0;
1698 }
1699 else if (evt->record_type < 0xe0)
1700 {
1701 evt->sel_type.oem_ts_type.timestamp = 0;
1702 evt->sel_type.oem_ts_type.manf_id[0] = 0;
1703 evt->sel_type.oem_ts_type.manf_id[1] = 0;
1704 evt->sel_type.oem_ts_type.manf_id[2] = 0;
1705 for(data_count=0; data_count < SEL_OEM_TS_DATA_LEN ; data_count++)
1706 evt->sel_type.oem_ts_type.oem_defined[data_count] = 0;
1707 }
1708 else
1709 {
1710 for(data_count=0; data_count < SEL_OEM_NOTS_DATA_LEN ; data_count++)
1711 evt->sel_type.oem_nots_type.oem_defined[data_count] = 0;
1712 }
1713
1714 /* save response into SEL event structure */
1715 evt->record_id = (rsp->data[3] << 8) | rsp->data[2];
1716 evt->record_type = rsp->data[4];
1717 if (evt->record_type < 0xc0)
1718 {
1719 evt->sel_type.standard_type.timestamp = (rsp->data[8] << 24) | (rsp->data[7] << 16) |
1720 (rsp->data[6] << 8) | rsp->data[5];
1721 evt->sel_type.standard_type.gen_id = (rsp->data[10] << 8) | rsp->data[9];
1722 evt->sel_type.standard_type.evm_rev = rsp->data[11];
1723 evt->sel_type.standard_type.sensor_type = rsp->data[12];
1724 evt->sel_type.standard_type.sensor_num = rsp->data[13];
1725 evt->sel_type.standard_type.event_type = rsp->data[14] & 0x7f;
1726 evt->sel_type.standard_type.event_dir = (rsp->data[14] & 0x80) >> 7;
1727 evt->sel_type.standard_type.event_data[0] = rsp->data[15];
1728 evt->sel_type.standard_type.event_data[1] = rsp->data[16];
1729 evt->sel_type.standard_type.event_data[2] = rsp->data[17];
1730 }
1731 else if (evt->record_type < 0xe0)
1732 {
1733 evt->sel_type.oem_ts_type.timestamp= (rsp->data[8] << 24) | (rsp->data[7] << 16) |
1734 (rsp->data[6] << 8) | rsp->data[5];
1735 evt->sel_type.oem_ts_type.manf_id[0]= rsp->data[11];
1736 evt->sel_type.oem_ts_type.manf_id[1]= rsp->data[10];
1737 evt->sel_type.oem_ts_type.manf_id[2]= rsp->data[9];
1738 for(data_count=0; data_count < SEL_OEM_TS_DATA_LEN ; data_count++)
1739 evt->sel_type.oem_ts_type.oem_defined[data_count] = rsp->data[(data_count+12)];
1740 }
1741 else
1742 {
1743 for(data_count=0; data_count < SEL_OEM_NOTS_DATA_LEN ; data_count++)
1744 evt->sel_type.oem_nots_type.oem_defined[data_count] = rsp->data[(data_count+5)];
1745 }
1746 return next;
1747 }
1748
1749 static void
ipmi_sel_print_event_file(struct ipmi_intf * intf,struct sel_event_record * evt,FILE * fp)1750 ipmi_sel_print_event_file(struct ipmi_intf * intf, struct sel_event_record * evt, FILE * fp)
1751 {
1752 char * description;
1753
1754 if (fp == NULL)
1755 return;
1756
1757 ipmi_get_event_desc(intf, evt, &description);
1758
1759 fprintf(fp, "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x # %s #0x%02x %s\n",
1760 evt->sel_type.standard_type.evm_rev,
1761 evt->sel_type.standard_type.sensor_type,
1762 evt->sel_type.standard_type.sensor_num,
1763 evt->sel_type.standard_type.event_type | (evt->sel_type.standard_type.event_dir << 7),
1764 evt->sel_type.standard_type.event_data[0],
1765 evt->sel_type.standard_type.event_data[1],
1766 evt->sel_type.standard_type.event_data[2],
1767 ipmi_get_sensor_type(intf, evt->sel_type.standard_type.sensor_type),
1768 evt->sel_type.standard_type.sensor_num,
1769 (description != NULL) ? description : "Unknown");
1770
1771 if (description != NULL) {
1772 free(description);
1773 description = NULL;
1774 }
1775 }
1776
1777 void
ipmi_sel_print_extended_entry(struct ipmi_intf * intf,struct sel_event_record * evt)1778 ipmi_sel_print_extended_entry(struct ipmi_intf * intf, struct sel_event_record * evt)
1779 {
1780 sel_extended++;
1781 ipmi_sel_print_std_entry(intf, evt);
1782 sel_extended--;
1783 }
1784
1785 void
ipmi_sel_print_std_entry(struct ipmi_intf * intf,struct sel_event_record * evt)1786 ipmi_sel_print_std_entry(struct ipmi_intf * intf, struct sel_event_record * evt)
1787 {
1788 char * description;
1789 struct sdr_record_list * sdr = NULL;
1790 int data_count;
1791
1792 if (sel_extended && (evt->record_type < 0xc0))
1793 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);
1794
1795
1796 if (!evt)
1797 return;
1798
1799 if (csv_output)
1800 printf("%x,", evt->record_id);
1801 else
1802 printf("%4x | ", evt->record_id);
1803
1804 if (evt->record_type == 0xf0)
1805 {
1806 if (csv_output)
1807 printf(",,");
1808
1809 printf ("Linux kernel panic: %.11s\n", (char *) evt + 5);
1810 return;
1811 }
1812
1813 if (evt->record_type < 0xe0)
1814 {
1815 if ((evt->sel_type.standard_type.timestamp < 0x20000000)||(evt->sel_type.oem_ts_type.timestamp < 0x20000000)){
1816 printf(" Pre-Init ");
1817
1818 if (csv_output)
1819 printf(",");
1820 else
1821 printf(" |");
1822
1823 printf("%010d", evt->sel_type.standard_type.timestamp );
1824 if (csv_output)
1825 printf(",");
1826 else
1827 printf("| ");
1828 }
1829 else {
1830 if (evt->record_type < 0xc0)
1831 printf("%s", ipmi_sel_timestamp_date(evt->sel_type.standard_type.timestamp));
1832 else
1833 printf("%s", ipmi_sel_timestamp_date(evt->sel_type.oem_ts_type.timestamp));
1834 if (csv_output)
1835 printf(",");
1836 else
1837 printf(" | ");
1838
1839 if (evt->record_type < 0xc0)
1840 printf("%s", ipmi_sel_timestamp_time(evt->sel_type.standard_type.timestamp));
1841 else
1842 printf("%s", ipmi_sel_timestamp_time(evt->sel_type.oem_ts_type.timestamp));
1843
1844 if (csv_output)
1845 printf(",");
1846 else
1847 printf(" | ");
1848 }
1849
1850 }
1851 else
1852 {
1853 if (csv_output)
1854 printf(",,");
1855 }
1856
1857 if (evt->record_type >= 0xc0)
1858 {
1859 printf ("OEM record %02x", evt->record_type);
1860 if (csv_output)
1861 printf(",");
1862 else
1863 printf(" | ");
1864
1865 if(evt->record_type <= 0xdf)
1866 {
1867 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]);
1868 if (csv_output)
1869 printf(",");
1870 else
1871 printf(" | ");
1872 for(data_count=0;data_count < SEL_OEM_TS_DATA_LEN;data_count++)
1873 printf("%02x", evt->sel_type.oem_ts_type.oem_defined[data_count]);
1874 }
1875 else
1876 {
1877 for(data_count=0;data_count < SEL_OEM_NOTS_DATA_LEN;data_count++)
1878 printf("%02x", evt->sel_type.oem_nots_type.oem_defined[data_count]);
1879 }
1880 ipmi_sel_oem_message(evt, 0);
1881 printf ("\n");
1882 return;
1883 }
1884
1885 /* lookup SDR entry based on sensor number and type */
1886 if (sdr != NULL) {
1887 printf("%s ", ipmi_get_sensor_type(intf,
1888 evt->sel_type.standard_type.sensor_type));
1889 switch (sdr->type) {
1890 case SDR_RECORD_TYPE_FULL_SENSOR:
1891 printf("%s", sdr->record.full->id_string);
1892 break;
1893 case SDR_RECORD_TYPE_COMPACT_SENSOR:
1894 printf("%s", sdr->record.compact->id_string);
1895 break;
1896 case SDR_RECORD_TYPE_EVENTONLY_SENSOR:
1897 printf("%s", sdr->record.eventonly->id_string);
1898 break;
1899 case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR:
1900 printf("%s", sdr->record.fruloc->id_string);
1901 break;
1902 case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR:
1903 printf("%s", sdr->record.mcloc->id_string);
1904 break;
1905 case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR:
1906 printf("%s", sdr->record.genloc->id_string);
1907 break;
1908 default:
1909 printf("#%02x", evt->sel_type.standard_type.sensor_num);
1910 break;
1911 }
1912 } else {
1913 printf("%s", ipmi_get_sensor_type(intf,
1914 evt->sel_type.standard_type.sensor_type));
1915 if (evt->sel_type.standard_type.sensor_num != 0)
1916 printf(" #0x%02x", evt->sel_type.standard_type.sensor_num);
1917 }
1918
1919 if (csv_output)
1920 printf(",");
1921 else
1922 printf(" | ");
1923
1924 ipmi_get_event_desc(intf, evt, &description);
1925 if (description) {
1926 printf("%s", description);
1927 free(description);
1928 description = NULL;
1929 }
1930
1931 if (csv_output) {
1932 printf(",");
1933 } else {
1934 printf(" | ");
1935 }
1936
1937 if (evt->sel_type.standard_type.event_dir) {
1938 printf("Deasserted");
1939 } else {
1940 printf("Asserted");
1941 }
1942
1943 if (sdr != NULL && evt->sel_type.standard_type.event_type == 1) {
1944 /*
1945 * Threshold Event
1946 */
1947 float trigger_reading = 0.0;
1948 float threshold_reading = 0.0;
1949 uint8_t threshold_reading_provided = 0;
1950
1951 /* trigger reading in event data byte 2 */
1952 if (((evt->sel_type.standard_type.event_data[0] >> 6) & 3) == 1) {
1953 trigger_reading = sdr_convert_sensor_reading(
1954 sdr->record.full, evt->sel_type.standard_type.event_data[1]);
1955 }
1956
1957 /* trigger threshold in event data byte 3 */
1958 if (((evt->sel_type.standard_type.event_data[0] >> 4) & 3) == 1) {
1959 threshold_reading = sdr_convert_sensor_reading(
1960 sdr->record.full, evt->sel_type.standard_type.event_data[2]);
1961 threshold_reading_provided = 1;
1962 }
1963
1964 if (csv_output)
1965 printf(",");
1966 else
1967 printf(" | ");
1968
1969 printf("Reading %.*f",
1970 (trigger_reading==(int)trigger_reading) ? 0 : 2,
1971 trigger_reading);
1972 if (threshold_reading_provided) {
1973 printf(" %s Threshold %.*f %s",
1974 ((evt->sel_type.standard_type.event_data[0] & 0xf) % 2) ? ">" : "<",
1975 (threshold_reading==(int)threshold_reading) ? 0 : 2,
1976 threshold_reading,
1977 ipmi_sdr_get_unit_string(sdr->record.common->unit.pct,
1978 sdr->record.common->unit.modifier,
1979 sdr->record.common->unit.type.base,
1980 sdr->record.common->unit.type.modifier));
1981 }
1982 }
1983 else if (evt->sel_type.standard_type.event_type == 0x6f) {
1984 int print_sensor = 1;
1985 switch (ipmi_get_oem(intf)) {
1986 case IPMI_OEM_SUPERMICRO:
1987 case IPMI_OEM_SUPERMICRO_47488:
1988 print_sensor = 0;
1989 break;
1990 default:
1991 break;
1992 }
1993 /*
1994 * Sensor-Specific Discrete
1995 */
1996 if (print_sensor && evt->sel_type.standard_type.sensor_type == 0xC && /*TODO*/
1997 evt->sel_type.standard_type.sensor_num == 0 &&
1998 (evt->sel_type.standard_type.event_data[0] & 0x30) == 0x20) {
1999 /* break down memory ECC reporting if we can */
2000 if (csv_output)
2001 printf(",");
2002 else
2003 printf(" | ");
2004
2005 printf("CPU %d DIMM %d",
2006 evt->sel_type.standard_type.event_data[2] & 0x0f,
2007 (evt->sel_type.standard_type.event_data[2] & 0xf0) >> 4);
2008 }
2009 }
2010
2011 printf("\n");
2012 }
2013
2014 void
ipmi_sel_print_std_entry_verbose(struct ipmi_intf * intf,struct sel_event_record * evt)2015 ipmi_sel_print_std_entry_verbose(struct ipmi_intf * intf, struct sel_event_record * evt)
2016 {
2017 char * description;
2018 int data_count;
2019
2020 if (!evt)
2021 return;
2022
2023 printf("SEL Record ID : %04x\n", evt->record_id);
2024
2025 if (evt->record_type == 0xf0)
2026 {
2027 printf (" Record Type : Linux kernel panic (OEM record %02x)\n", evt->record_type);
2028 printf (" Panic string : %.11s\n\n", (char *) evt + 5);
2029 return;
2030 }
2031
2032 printf(" Record Type : %02x", evt->record_type);
2033 if (evt->record_type >= 0xc0)
2034 {
2035 if (evt->record_type < 0xe0)
2036 printf(" (OEM timestamped)");
2037 else
2038 printf(" (OEM non-timestamped)");
2039 }
2040 printf("\n");
2041
2042 if (evt->record_type < 0xe0)
2043 {
2044 printf(" Timestamp : ");
2045 if (evt->record_type < 0xc0)
2046 printf("%s %s", ipmi_sel_timestamp_date(evt->sel_type.standard_type.timestamp),
2047 ipmi_sel_timestamp_time(evt->sel_type.standard_type.timestamp));
2048 else
2049 printf("%s %s", ipmi_sel_timestamp_date(evt->sel_type.oem_ts_type.timestamp),
2050 ipmi_sel_timestamp_time(evt->sel_type.oem_ts_type.timestamp));
2051 printf("\n");
2052 }
2053
2054 if (evt->record_type >= 0xc0)
2055 {
2056 if(evt->record_type <= 0xdf)
2057 {
2058 printf (" Manufactacturer ID : %02x%02x%02x\n", evt->sel_type.oem_ts_type.manf_id[0],
2059 evt->sel_type.oem_ts_type.manf_id[1], evt->sel_type.oem_ts_type.manf_id[2]);
2060 printf (" OEM Defined : ");
2061 for(data_count=0;data_count < SEL_OEM_TS_DATA_LEN;data_count++)
2062 printf("%02x", evt->sel_type.oem_ts_type.oem_defined[data_count]);
2063 printf(" [%s]\n\n",hex2ascii (evt->sel_type.oem_ts_type.oem_defined, SEL_OEM_TS_DATA_LEN));
2064 }
2065 else
2066 {
2067 printf (" OEM Defined : ");
2068 for(data_count=0;data_count < SEL_OEM_NOTS_DATA_LEN;data_count++)
2069 printf("%02x", evt->sel_type.oem_nots_type.oem_defined[data_count]);
2070 printf(" [%s]\n\n",hex2ascii (evt->sel_type.oem_nots_type.oem_defined, SEL_OEM_NOTS_DATA_LEN));
2071 ipmi_sel_oem_message(evt, 1);
2072 }
2073 return;
2074 }
2075
2076 printf(" Generator ID : %04x\n",
2077 evt->sel_type.standard_type.gen_id);
2078 printf(" EvM Revision : %02x\n",
2079 evt->sel_type.standard_type.evm_rev);
2080 printf(" Sensor Type : %s\n",
2081 ipmi_get_sensor_type(intf,
2082 evt->sel_type.standard_type.sensor_type));
2083 printf(" Sensor Number : %02x\n",
2084 evt->sel_type.standard_type.sensor_num);
2085 printf(" Event Type : %s\n",
2086 ipmi_get_event_type(evt->sel_type.standard_type.event_type));
2087 printf(" Event Direction : %s\n",
2088 val2str(evt->sel_type.standard_type.event_dir, event_dir_vals));
2089 printf(" Event Data : %02x%02x%02x\n",
2090 evt->sel_type.standard_type.event_data[0], evt->sel_type.standard_type.event_data[1], evt->sel_type.standard_type.event_data[2]);
2091 ipmi_get_event_desc(intf, evt, &description);
2092 printf(" Description : %s\n",
2093 description ? description : "");
2094 free(description);
2095 description = NULL;
2096
2097 printf("\n");
2098 }
2099
2100
2101 void
ipmi_sel_print_extended_entry_verbose(struct ipmi_intf * intf,struct sel_event_record * evt)2102 ipmi_sel_print_extended_entry_verbose(struct ipmi_intf * intf, struct sel_event_record * evt)
2103 {
2104 struct sdr_record_list * sdr;
2105 char * description;
2106
2107 if (!evt)
2108 return;
2109
2110 sdr = ipmi_sdr_find_sdr_bynumtype(intf,
2111 evt->sel_type.standard_type.gen_id,
2112 evt->sel_type.standard_type.sensor_num,
2113 evt->sel_type.standard_type.sensor_type);
2114 if (sdr == NULL)
2115 {
2116 ipmi_sel_print_std_entry_verbose(intf, evt);
2117 return;
2118 }
2119
2120 printf("SEL Record ID : %04x\n", evt->record_id);
2121
2122 if (evt->record_type == 0xf0)
2123 {
2124 printf (" Record Type : "
2125 "Linux kernel panic (OEM record %02x)\n",
2126 evt->record_type);
2127 printf (" Panic string : %.11s\n\n",
2128 (char *) evt + 5);
2129 return;
2130 }
2131
2132 printf(" Record Type : %02x\n", evt->record_type);
2133 if (evt->record_type < 0xe0)
2134 {
2135 printf(" Timestamp : ");
2136 printf("%s %s\n", ipmi_sel_timestamp_date(evt->sel_type.standard_type.timestamp),
2137 ipmi_sel_timestamp_time(evt->sel_type.standard_type.timestamp));
2138 }
2139
2140
2141 printf(" Generator ID : %04x\n",
2142 evt->sel_type.standard_type.gen_id);
2143 printf(" EvM Revision : %02x\n",
2144 evt->sel_type.standard_type.evm_rev);
2145 printf(" Sensor Type : %s\n",
2146 ipmi_get_sensor_type(intf, evt->sel_type.standard_type.sensor_type));
2147 printf(" Sensor Number : %02x\n",
2148 evt->sel_type.standard_type.sensor_num);
2149 printf(" Event Type : %s\n",
2150 ipmi_get_event_type(evt->sel_type.standard_type.event_type));
2151 printf(" Event Direction : %s\n",
2152 val2str(evt->sel_type.standard_type.event_dir, event_dir_vals));
2153 printf(" Event Data (RAW) : %02x%02x%02x\n",
2154 evt->sel_type.standard_type.event_data[0], evt->sel_type.standard_type.event_data[1], evt->sel_type.standard_type.event_data[2]);
2155
2156 /* break down event data field
2157 * as per IPMI Spec 2.0 Table 29-6 */
2158 if (evt->sel_type.standard_type.event_type == 1 && sdr->type == SDR_RECORD_TYPE_FULL_SENSOR) {
2159 /* Threshold */
2160 switch ((evt->sel_type.standard_type.event_data[0] >> 6) & 3) { /* EV1[7:6] */
2161 case 0:
2162 /* unspecified byte 2 */
2163 break;
2164 case 1:
2165 /* trigger reading in byte 2 */
2166 printf(" Trigger Reading : %.3f",
2167 sdr_convert_sensor_reading(sdr->record.full,
2168 evt->sel_type.standard_type.event_data[1]));
2169 /* determine units with possible modifiers */
2170 printf ("%s\n", ipmi_sdr_get_unit_string(sdr->record.common->unit.pct,
2171 sdr->record.common->unit.modifier,
2172 sdr->record.common->unit.type.base,
2173 sdr->record.common->unit.type.modifier));
2174 break;
2175 case 2:
2176 /* oem code in byte 2 */
2177 printf(" OEM Data : %02x\n",
2178 evt->sel_type.standard_type.event_data[1]);
2179 break;
2180 case 3:
2181 /* sensor-specific extension code in byte 2 */
2182 printf(" Sensor Extension Code : %02x\n",
2183 evt->sel_type.standard_type.event_data[1]);
2184 break;
2185 }
2186 switch ((evt->sel_type.standard_type.event_data[0] >> 4) & 3) { /* EV1[5:4] */
2187 case 0:
2188 /* unspecified byte 3 */
2189 break;
2190 case 1:
2191 /* trigger threshold value in byte 3 */
2192 printf(" Trigger Threshold : %.3f",
2193 sdr_convert_sensor_reading(sdr->record.full,
2194 evt->sel_type.standard_type.event_data[2]));
2195 /* determine units with possible modifiers */
2196 printf ("%s\n", ipmi_sdr_get_unit_string(sdr->record.common->unit.pct,
2197 sdr->record.common->unit.modifier,
2198 sdr->record.common->unit.type.base,
2199 sdr->record.common->unit.type.modifier));
2200 break;
2201 case 2:
2202 /* OEM code in byte 3 */
2203 printf(" OEM Data : %02x\n",
2204 evt->sel_type.standard_type.event_data[2]);
2205 break;
2206 case 3:
2207 /* sensor-specific extension code in byte 3 */
2208 printf(" Sensor Extension Code : %02x\n",
2209 evt->sel_type.standard_type.event_data[2]);
2210 break;
2211 }
2212 } else if (evt->sel_type.standard_type.event_type >= 0x2 && evt->sel_type.standard_type.event_type <= 0xc) {
2213 /* Generic Discrete */
2214 } else if (evt->sel_type.standard_type.event_type == 0x6f) {
2215
2216 /* Sensor-Specific Discrete */
2217 if (evt->sel_type.standard_type.sensor_type == 0xC &&
2218 evt->sel_type.standard_type.sensor_num == 0 && /**** THIS LOOK TO BE OEM ****/
2219 (evt->sel_type.standard_type.event_data[0] & 0x30) == 0x20)
2220 {
2221 /* break down memory ECC reporting if we can */
2222 printf(" Event Data : CPU %d DIMM %d\n",
2223 evt->sel_type.standard_type.event_data[2] & 0x0f,
2224 (evt->sel_type.standard_type.event_data[2] & 0xf0) >> 4);
2225 }
2226 else if(
2227 evt->sel_type.standard_type.sensor_type == 0x2b && /* Version change */
2228 evt->sel_type.standard_type.event_data[0] == 0xC1 /* Data in Data 2 */
2229 )
2230
2231 {
2232 //evt->sel_type.standard_type.event_data[1]
2233 }
2234 else
2235 {
2236 /* FIXME : Add sensor specific discrete types */
2237 printf(" Event Interpretation : Missing\n");
2238 }
2239 } else if (evt->sel_type.standard_type.event_type >= 0x70 && evt->sel_type.standard_type.event_type <= 0x7f) {
2240 /* OEM */
2241 } else {
2242 printf(" Event Data : %02x%02x%02x\n",
2243 evt->sel_type.standard_type.event_data[0], evt->sel_type.standard_type.event_data[1], evt->sel_type.standard_type.event_data[2]);
2244 }
2245
2246 ipmi_get_event_desc(intf, evt, &description);
2247 printf(" Description : %s\n",
2248 description ? description : "");
2249 free(description);
2250 description = NULL;
2251
2252 printf("\n");
2253 }
2254
2255 static int
__ipmi_sel_savelist_entries(struct ipmi_intf * intf,int count,const char * savefile,int binary)2256 __ipmi_sel_savelist_entries(struct ipmi_intf * intf, int count, const char * savefile,
2257 int binary)
2258 {
2259 struct ipmi_rs * rsp;
2260 struct ipmi_rq req;
2261 uint16_t next_id = 0, curr_id = 0;
2262 struct sel_event_record evt;
2263 int n=0;
2264 FILE * fp = NULL;
2265
2266 memset(&req, 0, sizeof(req));
2267 req.msg.netfn = IPMI_NETFN_STORAGE;
2268 req.msg.cmd = IPMI_CMD_GET_SEL_INFO;
2269
2270 rsp = intf->sendrecv(intf, &req);
2271 if (rsp == NULL) {
2272 lprintf(LOG_ERR, "Get SEL Info command failed");
2273 return -1;
2274 }
2275 if (rsp->ccode > 0) {
2276 lprintf(LOG_ERR, "Get SEL Info command failed: %s",
2277 val2str(rsp->ccode, completion_code_vals));
2278 return -1;
2279 }
2280 if (verbose > 2)
2281 printbuf(rsp->data, rsp->data_len, "sel_info");
2282
2283 if (rsp->data[1] == 0 && rsp->data[2] == 0) {
2284 lprintf(LOG_ERR, "SEL has no entries");
2285 return 0;
2286 }
2287
2288 memset(&req, 0, sizeof(req));
2289 req.msg.netfn = IPMI_NETFN_STORAGE;
2290 req.msg.cmd = IPMI_CMD_RESERVE_SEL;
2291
2292 rsp = intf->sendrecv(intf, &req);
2293 if (rsp == NULL) {
2294 lprintf(LOG_ERR, "Reserve SEL command failed");
2295 return -1;
2296 }
2297 if (rsp->ccode > 0) {
2298 lprintf(LOG_ERR, "Reserve SEL command failed: %s",
2299 val2str(rsp->ccode, completion_code_vals));
2300 return -1;
2301 }
2302
2303 if (count < 0) {
2304 /** Show only the most recent 'count' records. */
2305 int i;
2306 uint16_t entries;
2307
2308 req.msg.cmd = IPMI_CMD_GET_SEL_INFO;
2309 rsp = intf->sendrecv(intf, &req);
2310 if (rsp == NULL) {
2311 lprintf(LOG_ERR, "Get SEL Info command failed");
2312 return -1;
2313 }
2314 if (rsp->ccode > 0) {
2315 lprintf(LOG_ERR, "Get SEL Info command failed: %s",
2316 val2str(rsp->ccode, completion_code_vals));
2317 return -1;
2318 }
2319 entries = buf2short(rsp->data + 1);
2320 if (-count > entries)
2321 count = -entries;
2322
2323 for(i = 0; i < entries + count; i++) {
2324 next_id = ipmi_sel_get_std_entry(intf, next_id, &evt);
2325 if (next_id == 0) {
2326 /*
2327 * usually next_id of zero means end but
2328 * retry because some hardware has quirks
2329 * and will return 0 randomly.
2330 */
2331 next_id = ipmi_sel_get_std_entry(intf, next_id, &evt);
2332 if (next_id == 0) {
2333 break;
2334 }
2335 }
2336 }
2337 }
2338
2339 if (savefile != NULL) {
2340 fp = ipmi_open_file_write(savefile);
2341 }
2342
2343 while (next_id != 0xffff) {
2344 curr_id = next_id;
2345 lprintf(LOG_DEBUG, "SEL Next ID: %04x", curr_id);
2346
2347 next_id = ipmi_sel_get_std_entry(intf, curr_id, &evt);
2348 if (next_id == 0) {
2349 /*
2350 * usually next_id of zero means end but
2351 * retry because some hardware has quirks
2352 * and will return 0 randomly.
2353 */
2354 next_id = ipmi_sel_get_std_entry(intf, curr_id, &evt);
2355 if (next_id == 0)
2356 break;
2357 }
2358
2359 if (verbose)
2360 ipmi_sel_print_std_entry_verbose(intf, &evt);
2361 else
2362 ipmi_sel_print_std_entry(intf, &evt);
2363
2364 if (fp != NULL) {
2365 if (binary)
2366 fwrite(&evt, 1, 16, fp);
2367 else
2368 ipmi_sel_print_event_file(intf, &evt, fp);
2369 }
2370
2371 if (++n == count) {
2372 break;
2373 }
2374 }
2375
2376 if (fp != NULL)
2377 fclose(fp);
2378
2379 return 0;
2380 }
2381
2382 static int
ipmi_sel_list_entries(struct ipmi_intf * intf,int count)2383 ipmi_sel_list_entries(struct ipmi_intf * intf, int count)
2384 {
2385 return __ipmi_sel_savelist_entries(intf, count, NULL, 0);
2386 }
2387
2388 static int
ipmi_sel_save_entries(struct ipmi_intf * intf,int count,const char * savefile)2389 ipmi_sel_save_entries(struct ipmi_intf * intf, int count, const char * savefile)
2390 {
2391 return __ipmi_sel_savelist_entries(intf, count, savefile, 0);
2392 }
2393
2394 /*
2395 * ipmi_sel_interpret
2396 *
2397 * return 0 on success,
2398 * -1 on error
2399 */
2400 static int
ipmi_sel_interpret(struct ipmi_intf * intf,unsigned long iana,const char * readfile,const char * format)2401 ipmi_sel_interpret(struct ipmi_intf *intf, unsigned long iana,
2402 const char *readfile, const char *format)
2403 {
2404 FILE *fp = 0;
2405 struct sel_event_record evt;
2406 char *buffer = NULL;
2407 char *cursor = NULL;
2408 int status = 0;
2409 /* since the interface is not used, iana is taken from
2410 * the command line
2411 */
2412 sel_iana = iana;
2413 if (strncmp("pps", format, 3) == 0) {
2414 /* Parser for the following format */
2415 /* 0x001F: Event: at Mar 27 06:41:10 2007;from:(0x9a,0,7);
2416 * sensor:(0xc3,119); event:0x6f(asserted): 0xA3 0x00 0x88
2417 * commonly found in PPS shelf managers
2418 * Supports a tweak for hotswap events that are already interpreted.
2419 */
2420 fp = ipmi_open_file(readfile, 0);
2421 if (fp == NULL) {
2422 lprintf(LOG_ERR, "Failed to open file '%s' for reading.",
2423 readfile);
2424 return (-1);
2425 }
2426 buffer = (char *)malloc((size_t)256);
2427 if (buffer == NULL) {
2428 lprintf(LOG_ERR, "ipmitool: malloc failure");
2429 fclose(fp);
2430 return (-1);
2431 }
2432 do {
2433 /* Only allow complete lines to be parsed,
2434 * hardcoded maximum line length
2435 */
2436 if (fgets(buffer, 256, fp) == NULL) {
2437 status = (-1);
2438 break;
2439 }
2440 if (strlen(buffer) > 255) {
2441 lprintf(LOG_ERR, "ipmitool: invalid entry found in file.");
2442 continue;
2443 }
2444 cursor = buffer;
2445 /* assume normal "System" event */
2446 evt.record_type = 2;
2447 errno = 0;
2448 evt.record_id = strtol((const char *)cursor, (char **)NULL, 16);
2449 if (errno != 0) {
2450 lprintf(LOG_ERR, "Invalid record ID.");
2451 status = (-1);
2452 break;
2453 }
2454 evt.sel_type.standard_type.evm_rev = 4;
2455
2456 /* FIXME: convert*/
2457 /* evt.sel_type.standard_type.timestamp; */
2458
2459 /* skip timestamp */
2460 cursor = index((const char *)cursor, ';');
2461 cursor++;
2462
2463 /* FIXME: parse originator */
2464 evt.sel_type.standard_type.gen_id = 0x0020;
2465
2466 /* skip originator info */
2467 cursor = index((const char *)cursor, ';');
2468 cursor++;
2469
2470 /* Get sensor type */
2471 cursor = index((const char *)cursor, '(');
2472 cursor++;
2473
2474 errno = 0;
2475 evt.sel_type.standard_type.sensor_type =
2476 strtol((const char *)cursor, (char **)NULL, 16);
2477 if (errno != 0) {
2478 lprintf(LOG_ERR, "Invalid Sensor Type.");
2479 status = (-1);
2480 break;
2481 }
2482 cursor = index((const char *)cursor, ',');
2483 cursor++;
2484
2485 errno = 0;
2486 evt.sel_type.standard_type.sensor_num =
2487 strtol((const char *)cursor, (char **)NULL, 10);
2488 if (errno != 0) {
2489 lprintf(LOG_ERR, "Invalid Sensor Number.");
2490 status = (-1);
2491 break;
2492 }
2493
2494 /* skip to event type info */
2495 cursor = index((const char *)cursor, ':');
2496 cursor++;
2497
2498 errno = 0;
2499 evt.sel_type.standard_type.event_type=
2500 strtol((const char *)cursor, (char **)NULL, 16);
2501 if (errno != 0) {
2502 lprintf(LOG_ERR, "Invalid Event Type.");
2503 status = (-1);
2504 break;
2505 }
2506
2507 /* skip to event dir info */
2508 cursor = index((const char *)cursor, '(');
2509 cursor++;
2510 if (*cursor == 'a') {
2511 evt.sel_type.standard_type.event_dir = 0;
2512 } else {
2513 evt.sel_type.standard_type.event_dir = 1;
2514 }
2515 /* skip to data info */
2516 cursor = index((const char *)cursor, ' ');
2517 cursor++;
2518
2519 if (evt.sel_type.standard_type.sensor_type == 0xF0) {
2520 /* got to FRU id */
2521 while (!isdigit(*cursor)) {
2522 cursor++;
2523 }
2524 /* store FRUid */
2525 errno = 0;
2526 evt.sel_type.standard_type.event_data[2] =
2527 strtol(cursor, (char **)NULL, 10);
2528 if (errno != 0) {
2529 lprintf(LOG_ERR, "Invalid Event Data#2.");
2530 status = (-1);
2531 break;
2532 }
2533
2534 /* Get to previous state */
2535 cursor = index((const char *)cursor, 'M');
2536 cursor++;
2537
2538 /* Set previous state */
2539 errno = 0;
2540 evt.sel_type.standard_type.event_data[1] =
2541 strtol(cursor, (char **)NULL, 10);
2542 if (errno != 0) {
2543 lprintf(LOG_ERR, "Invalid Event Data#1.");
2544 status = (-1);
2545 break;
2546 }
2547
2548 /* Get to current state */
2549 cursor = index((const char *)cursor, 'M');
2550 cursor++;
2551
2552 /* Set current state */
2553 errno = 0;
2554 evt.sel_type.standard_type.event_data[0] =
2555 0xA0 | strtol(cursor, (char **)NULL, 10);
2556 if (errno != 0) {
2557 lprintf(LOG_ERR, "Invalid Event Data#0.");
2558 status = (-1);
2559 break;
2560 }
2561
2562 /* skip to cause */
2563 cursor = index((const char *)cursor, '=');
2564 cursor++;
2565 errno = 0;
2566 evt.sel_type.standard_type.event_data[1] |=
2567 (strtol(cursor, (char **)NULL, 16)) << 4;
2568 if (errno != 0) {
2569 lprintf(LOG_ERR, "Invalid Event Data#1.");
2570 status = (-1);
2571 break;
2572 }
2573 } else if (*cursor == '0') {
2574 errno = 0;
2575 evt.sel_type.standard_type.event_data[0] =
2576 strtol((const char *)cursor, (char **)NULL, 16);
2577 if (errno != 0) {
2578 lprintf(LOG_ERR, "Invalid Event Data#0.");
2579 status = (-1);
2580 break;
2581 }
2582 cursor = index((const char *)cursor, ' ');
2583 cursor++;
2584
2585 errno = 0;
2586 evt.sel_type.standard_type.event_data[1] =
2587 strtol((const char *)cursor, (char **)NULL, 16);
2588 if (errno != 0) {
2589 lprintf(LOG_ERR, "Invalid Event Data#1.");
2590 status = (-1);
2591 break;
2592 }
2593
2594 cursor = index((const char *)cursor, ' ');
2595 cursor++;
2596
2597 errno = 0;
2598 evt.sel_type.standard_type.event_data[2] =
2599 strtol((const char *)cursor, (char **)NULL, 16);
2600 if (errno != 0) {
2601 lprintf(LOG_ERR, "Invalid Event Data#2.");
2602 status = (-1);
2603 break;
2604 }
2605 } else {
2606 lprintf(LOG_ERR, "ipmitool: can't guess format.");
2607 }
2608 /* parse the PPS line into a sel_event_record */
2609 if (verbose) {
2610 ipmi_sel_print_std_entry_verbose(intf, &evt);
2611 } else {
2612 ipmi_sel_print_std_entry(intf, &evt);
2613 }
2614 cursor = NULL;
2615 } while (status == 0); /* until file is completely read */
2616 cursor = NULL;
2617 free(buffer);
2618 buffer = NULL;
2619 fclose(fp);
2620 } else {
2621 lprintf(LOG_ERR, "Given format '%s' is unknown.", format);
2622 status = (-1);
2623 }
2624 return status;
2625 }
2626
2627
2628 static int
ipmi_sel_writeraw(struct ipmi_intf * intf,const char * savefile)2629 ipmi_sel_writeraw(struct ipmi_intf * intf, const char * savefile)
2630 {
2631 return __ipmi_sel_savelist_entries(intf, 0, savefile, 1);
2632 }
2633
2634
2635 static int
ipmi_sel_readraw(struct ipmi_intf * intf,const char * inputfile)2636 ipmi_sel_readraw(struct ipmi_intf * intf, const char * inputfile)
2637 {
2638 struct sel_event_record evt;
2639 int ret = 0;
2640 FILE* fp = 0;
2641
2642 fp = ipmi_open_file(inputfile, 0);
2643 if (fp)
2644 {
2645 size_t bytesRead;
2646
2647 do {
2648 if ((bytesRead = fread(&evt, 1, 16, fp)) == 16)
2649 {
2650 if (verbose)
2651 ipmi_sel_print_std_entry_verbose(intf, &evt);
2652 else
2653 ipmi_sel_print_std_entry(intf, &evt);
2654 }
2655 else
2656 {
2657 if (bytesRead != 0)
2658 {
2659 lprintf(LOG_ERR, "ipmitool: incomplete record found in file.");
2660 ret = -1;
2661 }
2662
2663 break;
2664 }
2665
2666 } while (1);
2667 fclose(fp);
2668 }
2669 else
2670 {
2671 lprintf(LOG_ERR, "ipmitool: could not open input file.");
2672 ret = -1;
2673 }
2674 return ret;
2675 }
2676
2677
2678
2679 static uint16_t
ipmi_sel_reserve(struct ipmi_intf * intf)2680 ipmi_sel_reserve(struct ipmi_intf * intf)
2681 {
2682 struct ipmi_rs * rsp;
2683 struct ipmi_rq req;
2684
2685 memset(&req, 0, sizeof(req));
2686 req.msg.netfn = IPMI_NETFN_STORAGE;
2687 req.msg.cmd = IPMI_CMD_RESERVE_SEL;
2688
2689 rsp = intf->sendrecv(intf, &req);
2690 if (rsp == NULL) {
2691 lprintf(LOG_WARN, "Unable to reserve SEL");
2692 return 0;
2693 }
2694 if (rsp->ccode > 0) {
2695 printf("Unable to reserve SEL: %s",
2696 val2str(rsp->ccode, completion_code_vals));
2697 return 0;
2698 }
2699
2700 return (rsp->data[0] | (rsp->data[1] << 8));
2701 }
2702
2703
2704
2705 /*
2706 * ipmi_sel_get_time
2707 *
2708 * return 0 on success,
2709 * -1 on error
2710 */
2711 static int
ipmi_sel_get_time(struct ipmi_intf * intf)2712 ipmi_sel_get_time(struct ipmi_intf * intf)
2713 {
2714 struct ipmi_rs * rsp;
2715 struct ipmi_rq req;
2716 static char tbuf[40];
2717 uint32_t timei;
2718 time_t time;
2719
2720 memset(&req, 0, sizeof(req));
2721 req.msg.netfn = IPMI_NETFN_STORAGE;
2722 req.msg.cmd = IPMI_GET_SEL_TIME;
2723
2724 rsp = intf->sendrecv(intf, &req);
2725
2726 if (rsp == NULL) {
2727 lprintf(LOG_ERR, "Get SEL Time command failed");
2728 return -1;
2729 }
2730 if (rsp->ccode > 0) {
2731 lprintf(LOG_ERR, "Get SEL Time command failed: %s",
2732 val2str(rsp->ccode, completion_code_vals));
2733 return -1;
2734 }
2735 if (rsp->data_len != 4) {
2736 lprintf(LOG_ERR, "Get SEL Time command failed: "
2737 "Invalid data length %d", rsp->data_len);
2738 return -1;
2739 }
2740
2741 memcpy(&timei, rsp->data, 4);
2742 #if WORDS_BIGENDIAN
2743 time = (time_t)(BSWAP_32(timei));
2744 #else
2745 time = (time_t)timei;
2746 #endif
2747
2748 strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", gmtime(&time));
2749 printf("%s\n", tbuf);
2750
2751 return 0;
2752 }
2753
2754
2755
2756 /*
2757 * ipmi_sel_set_time
2758 *
2759 * return 0 on success,
2760 * -1 on error
2761 */
2762 static int
ipmi_sel_set_time(struct ipmi_intf * intf,const char * time_string)2763 ipmi_sel_set_time(struct ipmi_intf * intf, const char * time_string)
2764 {
2765 struct ipmi_rs * rsp;
2766 struct ipmi_rq req;
2767 struct tm tm = {0};
2768 time_t t;
2769 uint32_t timei;
2770 const char * time_format = "%m/%d/%Y %H:%M:%S";
2771
2772 memset(&req, 0, sizeof(req));
2773 req.msg.netfn = IPMI_NETFN_STORAGE;
2774 req.msg.cmd = IPMI_SET_SEL_TIME;
2775
2776 /* See if user requested set to current client system time */
2777 if (strncasecmp(time_string, "now", 3) == 0) {
2778 t = time(NULL);
2779 }
2780 else {
2781 /* Now how do we get our time_t from our ascii version? */
2782 if (strptime(time_string, time_format, &tm) == 0) {
2783 lprintf(LOG_ERR, "Specified time could not be parsed");
2784 return -1;
2785 }
2786 tm.tm_isdst = (-1); /* look up DST information */
2787 t = mktime(&tm);
2788 if (t < 0) {
2789 lprintf(LOG_ERR, "Specified time could not be parsed");
2790 return -1;
2791 }
2792 }
2793
2794 {
2795 //modify UTC time to local time expressed in number of seconds from 1/1/70 0:0:0 1970 GMT
2796 struct tm * tm_tmp = {0};
2797 int gt_year,gt_yday,gt_hour,gt_min,lt_year,lt_yday,lt_hour,lt_min;
2798 int delta_hour;
2799 tm_tmp=gmtime(&t);
2800 gt_year=tm_tmp->tm_year;
2801 gt_yday=tm_tmp->tm_yday;
2802 gt_hour=tm_tmp->tm_hour;
2803 gt_min=tm_tmp->tm_min;
2804 memset(&*tm_tmp, 0, sizeof(struct tm));
2805 tm_tmp=localtime(&t);
2806 lt_year=tm_tmp->tm_year;
2807 lt_yday=tm_tmp->tm_yday;
2808 lt_hour=tm_tmp->tm_hour;
2809 lt_min=tm_tmp->tm_min;
2810 delta_hour=lt_hour - gt_hour;
2811 if ( (lt_year > gt_year) || ((lt_year == gt_year) && (lt_yday > gt_yday)) )
2812 delta_hour += 24;
2813 if ( (lt_year < gt_year) || ((lt_year == gt_year) && (lt_yday < gt_yday)) )
2814 delta_hour -= 24;
2815
2816 t += (delta_hour * 60 * 60) + (lt_min - gt_min) * 60;
2817 }
2818
2819 timei = (uint32_t)t;
2820 req.msg.data = (uint8_t *)&timei;
2821 req.msg.data_len = 4;
2822
2823 #if WORDS_BIGENDIAN
2824 timei = BSWAP_32(timei);
2825 #endif
2826
2827 rsp = intf->sendrecv(intf, &req);
2828 if (rsp == NULL) {
2829 lprintf(LOG_ERR, "Set SEL Time command failed");
2830 return -1;
2831 }
2832 if (rsp->ccode > 0) {
2833 lprintf(LOG_ERR, "Set SEL Time command failed: %s",
2834 val2str(rsp->ccode, completion_code_vals));
2835 return -1;
2836 }
2837
2838 ipmi_sel_get_time(intf);
2839
2840 return 0;
2841 }
2842
2843
2844
2845 static int
ipmi_sel_clear(struct ipmi_intf * intf)2846 ipmi_sel_clear(struct ipmi_intf * intf)
2847 {
2848 struct ipmi_rs * rsp;
2849 struct ipmi_rq req;
2850 uint16_t reserve_id;
2851 uint8_t msg_data[6];
2852
2853 reserve_id = ipmi_sel_reserve(intf);
2854 if (reserve_id == 0)
2855 return -1;
2856
2857 memset(msg_data, 0, 6);
2858 msg_data[0] = reserve_id & 0xff;
2859 msg_data[1] = reserve_id >> 8;
2860 msg_data[2] = 'C';
2861 msg_data[3] = 'L';
2862 msg_data[4] = 'R';
2863 msg_data[5] = 0xaa;
2864
2865 memset(&req, 0, sizeof(req));
2866 req.msg.netfn = IPMI_NETFN_STORAGE;
2867 req.msg.cmd = IPMI_CMD_CLEAR_SEL;
2868 req.msg.data = msg_data;
2869 req.msg.data_len = 6;
2870
2871 rsp = intf->sendrecv(intf, &req);
2872 if (rsp == NULL) {
2873 lprintf(LOG_ERR, "Unable to clear SEL");
2874 return -1;
2875 }
2876 if (rsp->ccode > 0) {
2877 lprintf(LOG_ERR, "Unable to clear SEL: %s",
2878 val2str(rsp->ccode, completion_code_vals));
2879 return -1;
2880 }
2881
2882 printf("Clearing SEL. Please allow a few seconds to erase.\n");
2883 return 0;
2884 }
2885
2886 static int
ipmi_sel_delete(struct ipmi_intf * intf,int argc,char ** argv)2887 ipmi_sel_delete(struct ipmi_intf * intf, int argc, char ** argv)
2888 {
2889 struct ipmi_rs * rsp;
2890 struct ipmi_rq req;
2891 uint16_t id;
2892 uint8_t msg_data[4];
2893 int rc = 0;
2894
2895 if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {
2896 lprintf(LOG_ERR, "usage: delete <id>...<id>\n");
2897 return -1;
2898 }
2899
2900 id = ipmi_sel_reserve(intf);
2901 if (id == 0)
2902 return -1;
2903
2904 memset(msg_data, 0, 4);
2905 msg_data[0] = id & 0xff;
2906 msg_data[1] = id >> 8;
2907
2908 for (; argc != 0; argc--)
2909 {
2910 if (str2ushort(argv[argc-1], &id) != 0) {
2911 lprintf(LOG_ERR, "Given SEL ID '%s' is invalid.",
2912 argv[argc-1]);
2913 rc = (-1);
2914 continue;
2915 }
2916 msg_data[2] = id & 0xff;
2917 msg_data[3] = id >> 8;
2918
2919 memset(&req, 0, sizeof(req));
2920 req.msg.netfn = IPMI_NETFN_STORAGE;
2921 req.msg.cmd = IPMI_CMD_DELETE_SEL_ENTRY;
2922 req.msg.data = msg_data;
2923 req.msg.data_len = 4;
2924
2925 rsp = intf->sendrecv(intf, &req);
2926 if (rsp == NULL) {
2927 lprintf(LOG_ERR, "Unable to delete entry %d", id);
2928 rc = -1;
2929 }
2930 else if (rsp->ccode > 0) {
2931 lprintf(LOG_ERR, "Unable to delete entry %d: %s", id,
2932 val2str(rsp->ccode, completion_code_vals));
2933 rc = -1;
2934 }
2935 else {
2936 printf("Deleted entry %d\n", id);
2937 }
2938 }
2939
2940 return rc;
2941 }
2942
2943 static int
ipmi_sel_show_entry(struct ipmi_intf * intf,int argc,char ** argv)2944 ipmi_sel_show_entry(struct ipmi_intf * intf, int argc, char ** argv)
2945 {
2946 struct entity_id entity;
2947 struct sdr_record_list *entry;
2948 struct sdr_record_list *list;
2949 struct sdr_record_list *sdr;
2950 struct sel_event_record evt;
2951 int i;
2952 int oldv;
2953 int rc = 0;
2954 uint16_t id;
2955
2956 if (argc == 0 || strncmp(argv[0], "help", 4) == 0) {
2957 lprintf(LOG_ERR, "usage: sel get <id>...<id>");
2958 return (-1);
2959 }
2960
2961 if (ipmi_sel_reserve(intf) == 0) {
2962 lprintf(LOG_ERR, "Unable to reserve SEL");
2963 return (-1);
2964 }
2965
2966 for (i = 0; i < argc; i++) {
2967 if (str2ushort(argv[i], &id) != 0) {
2968 lprintf(LOG_ERR, "Given SEL ID '%s' is invalid.",
2969 argv[i]);
2970 rc = (-1);
2971 continue;
2972 }
2973
2974 lprintf(LOG_DEBUG, "Looking up SEL entry 0x%x", id);
2975
2976 /* lookup SEL entry based on ID */
2977 if (!ipmi_sel_get_std_entry(intf, id, &evt)) {
2978 lprintf(LOG_DEBUG, "SEL Entry 0x%x not found.", id);
2979 rc = (-1);
2980 continue;
2981 }
2982 if (evt.sel_type.standard_type.sensor_num == 0
2983 && evt.sel_type.standard_type.sensor_type == 0
2984 && evt.record_type == 0) {
2985 lprintf(LOG_WARN, "SEL Entry 0x%x not found", id);
2986 rc = (-1);
2987 continue;
2988 }
2989
2990 /* lookup SDR entry based on sensor number and type */
2991 ipmi_sel_print_extended_entry_verbose(intf, &evt);
2992
2993 sdr = ipmi_sdr_find_sdr_bynumtype(intf,
2994 evt.sel_type.standard_type.gen_id,
2995 evt.sel_type.standard_type.sensor_num,
2996 evt.sel_type.standard_type.sensor_type);
2997 if (sdr == NULL) {
2998 continue;
2999 }
3000
3001 /* print SDR entry */
3002 oldv = verbose;
3003 verbose = verbose ? verbose : 1;
3004 switch (sdr->type) {
3005 case SDR_RECORD_TYPE_FULL_SENSOR:
3006 case SDR_RECORD_TYPE_COMPACT_SENSOR:
3007 ipmi_sensor_print_fc(intf, sdr->record.common,
3008 sdr->type);
3009 entity.id = sdr->record.common->entity.id;
3010 entity.instance = sdr->record.common->entity.instance;
3011 break;
3012 case SDR_RECORD_TYPE_EVENTONLY_SENSOR:
3013 ipmi_sdr_print_sensor_eventonly(intf, sdr->record.eventonly);
3014 entity.id = sdr->record.eventonly->entity.id;
3015 entity.instance = sdr->record.eventonly->entity.instance;
3016 break;
3017 default:
3018 verbose = oldv;
3019 continue;
3020 }
3021 verbose = oldv;
3022
3023 /* lookup SDR entry based on entity id */
3024 list = ipmi_sdr_find_sdr_byentity(intf, &entity);
3025 for (entry=list; entry; entry=entry->next) {
3026 /* print FRU devices we find for this entity */
3027 if (entry->type == SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR)
3028 ipmi_fru_print(intf, entry->record.fruloc);
3029 }
3030
3031 if ((argc > 1) && (i < (argc - 1))) {
3032 printf("----------------------\n\n");
3033 }
3034 }
3035
3036 return rc;
3037 }
3038
ipmi_sel_main(struct ipmi_intf * intf,int argc,char ** argv)3039 int ipmi_sel_main(struct ipmi_intf * intf, int argc, char ** argv)
3040 {
3041 int rc = 0;
3042
3043 if (argc == 0)
3044 rc = ipmi_sel_get_info(intf);
3045 else if (strncmp(argv[0], "help", 4) == 0)
3046 lprintf(LOG_ERR, "SEL Commands: "
3047 "info clear delete list elist get add time save readraw writeraw interpret");
3048 else if (strncmp(argv[0], "interpret", 9) == 0) {
3049 uint32_t iana = 0;
3050 if (argc < 4) {
3051 lprintf(LOG_NOTICE, "usage: sel interpret iana filename format(pps)");
3052 return 0;
3053 }
3054 if (str2uint(argv[1], &iana) != 0) {
3055 lprintf(LOG_ERR, "Given IANA '%s' is invalid.",
3056 argv[1]);
3057 return (-1);
3058 }
3059 rc = ipmi_sel_interpret(intf, iana, argv[2], argv[3]);
3060 }
3061 else if (strncmp(argv[0], "info", 4) == 0)
3062 rc = ipmi_sel_get_info(intf);
3063 else if (strncmp(argv[0], "save", 4) == 0) {
3064 if (argc < 2) {
3065 lprintf(LOG_NOTICE, "usage: sel save <filename>");
3066 return 0;
3067 }
3068 rc = ipmi_sel_save_entries(intf, 0, argv[1]);
3069 }
3070 else if (strncmp(argv[0], "add", 3) == 0) {
3071 if (argc < 2) {
3072 lprintf(LOG_NOTICE, "usage: sel add <filename>");
3073 return 0;
3074 }
3075 rc = ipmi_sel_add_entries_fromfile(intf, argv[1]);
3076 }
3077 else if (strncmp(argv[0], "writeraw", 8) == 0) {
3078 if (argc < 2) {
3079 lprintf(LOG_NOTICE, "usage: sel writeraw <filename>");
3080 return 0;
3081 }
3082 rc = ipmi_sel_writeraw(intf, argv[1]);
3083 }
3084 else if (strncmp(argv[0], "readraw", 7) == 0) {
3085 if (argc < 2) {
3086 lprintf(LOG_NOTICE, "usage: sel readraw <filename>");
3087 return 0;
3088 }
3089 rc = ipmi_sel_readraw(intf, argv[1]);
3090 }
3091 else if (strncmp(argv[0], "ereadraw", 8) == 0) {
3092 if (argc < 2) {
3093 lprintf(LOG_NOTICE, "usage: sel ereadraw <filename>");
3094 return 0;
3095 }
3096 sel_extended = 1;
3097 rc = ipmi_sel_readraw(intf, argv[1]);
3098 }
3099 else if (strncmp(argv[0], "list", 4) == 0 ||
3100 strncmp(argv[0], "elist", 5) == 0) {
3101 /*
3102 * Usage:
3103 * list - show all SEL entries
3104 * list first <n> - show the first (oldest) <n> SEL entries
3105 * list last <n> - show the last (newsest) <n> SEL entries
3106 */
3107 int count = 0;
3108 int sign = 1;
3109 char *countstr = NULL;
3110
3111 if (strncmp(argv[0], "elist", 5) == 0)
3112 sel_extended = 1;
3113 else
3114 sel_extended = 0;
3115
3116 if (argc == 2) {
3117 countstr = argv[1];
3118 }
3119 else if (argc == 3) {
3120 countstr = argv[2];
3121
3122 if (strncmp(argv[1], "last", 4) == 0) {
3123 sign = -1;
3124 }
3125 else if (strncmp(argv[1], "first", 5) != 0) {
3126 lprintf(LOG_ERR, "Unknown sel list option");
3127 return -1;
3128 }
3129 }
3130
3131 if (countstr) {
3132 if (str2int(countstr, &count) != 0) {
3133 lprintf(LOG_ERR, "Numeric argument required; got '%s'",
3134 countstr);
3135 return -1;
3136 }
3137 }
3138 count *= sign;
3139
3140 rc = ipmi_sel_list_entries(intf,count);
3141 }
3142 else if (strncmp(argv[0], "clear", 5) == 0)
3143 rc = ipmi_sel_clear(intf);
3144 else if (strncmp(argv[0], "delete", 6) == 0) {
3145 if (argc < 2)
3146 lprintf(LOG_ERR, "usage: sel delete <id>...<id>");
3147 else
3148 rc = ipmi_sel_delete(intf, argc-1, &argv[1]);
3149 }
3150 else if (strncmp(argv[0], "get", 3) == 0) {
3151 if (argc < 2)
3152 lprintf(LOG_ERR, "usage: sel get <entry>");
3153 else
3154 rc = ipmi_sel_show_entry(intf, argc-1, &argv[1]);
3155 }
3156 else if (strncmp(argv[0], "time", 4) == 0) {
3157 if (argc < 2)
3158 lprintf(LOG_ERR, "sel time commands: get set");
3159 else if (strncmp(argv[1], "get", 3) == 0)
3160 ipmi_sel_get_time(intf);
3161 else if (strncmp(argv[1], "set", 3) == 0) {
3162 if (argc < 3)
3163 lprintf(LOG_ERR, "usage: sel time set \"mm/dd/yyyy hh:mm:ss\"");
3164 else
3165 rc = ipmi_sel_set_time(intf, argv[2]);
3166 } else {
3167 lprintf(LOG_ERR, "sel time commands: get set");
3168 }
3169 }
3170 else {
3171 lprintf(LOG_ERR, "Invalid SEL command: %s", argv[0]);
3172 rc = -1;
3173 }
3174
3175 return rc;
3176 }
3177