1 /* 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 33 #include <stdlib.h> 34 #include <string.h> 35 #include <stdio.h> 36 #include <time.h> 37 38 #include <ipmitool/helper.h> 39 #include <ipmitool/log.h> 40 #include <ipmitool/bswap.h> 41 #include <ipmitool/ipmi.h> 42 #include <ipmitool/ipmi_intf.h> 43 #include <ipmitool/ipmi_mc.h> 44 #include <ipmitool/ipmi_strings.h> 45 46 extern int verbose; 47 48 static int ipmi_sysinfo_main(struct ipmi_intf *intf, int argc, char ** argv, 49 int is_set); 50 static void printf_sysinfo_usage(int full_help); 51 52 /* ipmi_mc_reset - attempt to reset an MC 53 * 54 * @intf: ipmi interface 55 * @cmd: reset command to send 56 * BMC_WARM_RESET or 57 * BMC_COLD_RESET 58 * 59 * returns 0 on success 60 * returns -1 on error 61 */ 62 static int 63 ipmi_mc_reset(struct ipmi_intf * intf, int cmd) 64 { 65 struct ipmi_rs * rsp; 66 struct ipmi_rq req; 67 68 if( !intf->opened ) 69 intf->open(intf); 70 71 memset(&req, 0, sizeof(req)); 72 req.msg.netfn = IPMI_NETFN_APP; 73 req.msg.cmd = cmd; 74 req.msg.data_len = 0; 75 76 if (cmd == BMC_COLD_RESET) 77 intf->noanswer = 1; 78 79 rsp = intf->sendrecv(intf, &req); 80 81 if (cmd == BMC_COLD_RESET) 82 intf->abort = 1; 83 84 if (cmd == BMC_COLD_RESET && rsp == NULL) { 85 /* This is expected. See 20.2 Cold Reset Command, p.243, IPMIv2.0 rev1.0 */ 86 } else if (rsp == NULL) { 87 lprintf(LOG_ERR, "MC reset command failed."); 88 return (-1); 89 } else if (rsp->ccode > 0) { 90 lprintf(LOG_ERR, "MC reset command failed: %s", 91 val2str(rsp->ccode, completion_code_vals)); 92 return (-1); 93 } 94 95 printf("Sent %s reset command to MC\n", 96 (cmd == BMC_WARM_RESET) ? "warm" : "cold"); 97 98 return 0; 99 } 100 101 #ifdef HAVE_PRAGMA_PACK 102 #pragma pack(1) 103 #endif 104 struct bmc_enables_data { 105 #if WORDS_BIGENDIAN 106 uint8_t oem2 : 1; 107 uint8_t oem1 : 1; 108 uint8_t oem0 : 1; 109 uint8_t __reserved : 1; 110 uint8_t system_event_log : 1; 111 uint8_t event_msgbuf : 1; 112 uint8_t event_msgbuf_intr : 1; 113 uint8_t receive_msg_intr : 1; 114 #else 115 uint8_t receive_msg_intr : 1; 116 uint8_t event_msgbuf_intr : 1; 117 uint8_t event_msgbuf : 1; 118 uint8_t system_event_log : 1; 119 uint8_t __reserved : 1; 120 uint8_t oem0 : 1; 121 uint8_t oem1 : 1; 122 uint8_t oem2 : 1; 123 #endif 124 } ATTRIBUTE_PACKING; 125 #ifdef HAVE_PRAGMA_PACK 126 #pragma pack(0) 127 #endif 128 129 struct bitfield_data { 130 const char * name; 131 const char * desc; 132 uint32_t mask; 133 } mc_enables_bf[] = { 134 { 135 .name = "recv_msg_intr", 136 .desc = "Receive Message Queue Interrupt", 137 .mask = 1<<0, 138 }, 139 { 140 .name = "event_msg_intr", 141 .desc = "Event Message Buffer Full Interrupt", 142 .mask = 1<<1, 143 }, 144 { 145 .name = "event_msg", 146 .desc = "Event Message Buffer", 147 .mask = 1<<2, 148 }, 149 { 150 .name = "system_event_log", 151 .desc = "System Event Logging", 152 .mask = 1<<3, 153 }, 154 { 155 .name = "oem0", 156 .desc = "OEM 0", 157 .mask = 1<<5, 158 }, 159 { 160 .name = "oem1", 161 .desc = "OEM 1", 162 .mask = 1<<6, 163 }, 164 { 165 .name = "oem2", 166 .desc = "OEM 2", 167 .mask = 1<<7, 168 }, 169 { NULL }, 170 }; 171 172 static void 173 printf_mc_reset_usage(void) 174 { 175 lprintf(LOG_NOTICE, "usage: mc reset <warm|cold>"); 176 } /* printf_mc_reset_usage(void) */ 177 178 static void 179 printf_mc_usage(void) 180 { 181 struct bitfield_data * bf; 182 lprintf(LOG_NOTICE, "MC Commands:"); 183 lprintf(LOG_NOTICE, " reset <warm|cold>"); 184 lprintf(LOG_NOTICE, " guid"); 185 lprintf(LOG_NOTICE, " info"); 186 lprintf(LOG_NOTICE, " watchdog <get|reset|off>"); 187 lprintf(LOG_NOTICE, " selftest"); 188 lprintf(LOG_NOTICE, " getenables"); 189 lprintf(LOG_NOTICE, " setenables <option=on|off> ..."); 190 for (bf = mc_enables_bf; bf->name != NULL; bf++) { 191 lprintf(LOG_NOTICE, " %-20s %s", bf->name, bf->desc); 192 } 193 printf_sysinfo_usage(0); 194 } 195 196 static void 197 printf_sysinfo_usage(int full_help) 198 { 199 if (full_help != 0) 200 lprintf(LOG_NOTICE, "usage:"); 201 202 lprintf(LOG_NOTICE, " getsysinfo <argument>"); 203 204 if (full_help != 0) { 205 lprintf(LOG_NOTICE, 206 " Retrieves system info from BMC for given argument"); 207 } 208 209 lprintf(LOG_NOTICE, " setsysinfo <argument> <string>"); 210 211 if (full_help != 0) { 212 lprintf(LOG_NOTICE, 213 " Stores system info string for given argument to BMC"); 214 lprintf(LOG_NOTICE, ""); 215 lprintf(LOG_NOTICE, " Valid arguments are:"); 216 } 217 lprintf(LOG_NOTICE, 218 " system_fw_version System firmware (e.g. BIOS) version"); 219 lprintf(LOG_NOTICE, 220 " primary_os_name Primary operating system name"); 221 lprintf(LOG_NOTICE, " os_name Operating system name"); 222 lprintf(LOG_NOTICE, 223 " system_name System Name of server(vendor dependent)"); 224 lprintf(LOG_NOTICE, 225 " delloem_os_version Running version of operating system"); 226 lprintf(LOG_NOTICE, " delloem_url URL of BMC webserver"); 227 lprintf(LOG_NOTICE, ""); 228 } 229 230 static void 231 print_watchdog_usage(void) 232 { 233 lprintf(LOG_NOTICE, "usage: watchdog <command>:"); 234 lprintf(LOG_NOTICE, " get : Get Current Watchdog settings"); 235 lprintf(LOG_NOTICE, " reset : Restart Watchdog timer based on most recent settings"); 236 lprintf(LOG_NOTICE, " off : Shut off a running Watchdog timer"); 237 } 238 239 /* ipmi_mc_get_enables - print out MC enables 240 * 241 * @intf: ipmi inteface 242 * 243 * returns 0 on success 244 * returns -1 on error 245 */ 246 static int 247 ipmi_mc_get_enables(struct ipmi_intf * intf) 248 { 249 struct ipmi_rs * rsp; 250 struct ipmi_rq req; 251 struct bitfield_data * bf; 252 253 memset(&req, 0, sizeof(req)); 254 req.msg.netfn = IPMI_NETFN_APP; 255 req.msg.cmd = BMC_GET_GLOBAL_ENABLES; 256 257 rsp = intf->sendrecv(intf, &req); 258 if (rsp == NULL) { 259 lprintf(LOG_ERR, "Get Global Enables command failed"); 260 return -1; 261 } 262 if (rsp->ccode > 0) { 263 lprintf(LOG_ERR, "Get Global Enables command failed: %s", 264 val2str(rsp->ccode, completion_code_vals)); 265 return -1; 266 } 267 268 for (bf = mc_enables_bf; bf->name != NULL; bf++) { 269 printf("%-40s : %sabled\n", bf->desc, 270 rsp->data[0] & bf->mask ? "en" : "dis"); 271 } 272 273 return 0; 274 } 275 276 /* ipmi_mc_set_enables - set MC enable flags 277 * 278 * @intf: ipmi inteface 279 * @argc: argument count 280 * @argv: argument list 281 * 282 * returns 0 on success 283 * returns -1 on error 284 */ 285 static int 286 ipmi_mc_set_enables(struct ipmi_intf * intf, int argc, char ** argv) 287 { 288 struct ipmi_rs * rsp; 289 struct ipmi_rq req; 290 struct bitfield_data * bf; 291 uint8_t en; 292 int i; 293 294 if (argc < 1) { 295 printf_mc_usage(); 296 return (-1); 297 } 298 else if (strncmp(argv[0], "help", 4) == 0) { 299 printf_mc_usage(); 300 return 0; 301 } 302 303 memset(&req, 0, sizeof(req)); 304 req.msg.netfn = IPMI_NETFN_APP; 305 req.msg.cmd = BMC_GET_GLOBAL_ENABLES; 306 307 rsp = intf->sendrecv(intf, &req); 308 if (rsp == NULL) { 309 lprintf(LOG_ERR, "Get Global Enables command failed"); 310 return -1; 311 } 312 if (rsp->ccode > 0) { 313 lprintf(LOG_ERR, "Get Global Enables command failed: %s", 314 val2str(rsp->ccode, completion_code_vals)); 315 return -1; 316 } 317 318 en = rsp->data[0]; 319 320 for (i = 0; i < argc; i++) { 321 for (bf = mc_enables_bf; bf->name != NULL; bf++) { 322 int nl = strlen(bf->name); 323 if (strncmp(argv[i], bf->name, nl) != 0) 324 continue; 325 if (strncmp(argv[i]+nl+1, "off", 3) == 0) { 326 printf("Disabling %s\n", bf->desc); 327 en &= ~bf->mask; 328 } 329 else if (strncmp(argv[i]+nl+1, "on", 2) == 0) { 330 printf("Enabling %s\n", bf->desc); 331 en |= bf->mask; 332 } 333 else { 334 lprintf(LOG_ERR, "Unrecognized option: %s", argv[i]); 335 } 336 } 337 } 338 339 if (en == rsp->data[0]) { 340 printf("\nNothing to change...\n"); 341 ipmi_mc_get_enables(intf); 342 return 0; 343 } 344 345 req.msg.cmd = BMC_SET_GLOBAL_ENABLES; 346 req.msg.data = &en; 347 req.msg.data_len = 1; 348 349 rsp = intf->sendrecv(intf, &req); 350 if (rsp == NULL) { 351 lprintf(LOG_ERR, "Set Global Enables command failed"); 352 return -1; 353 } 354 else if (rsp->ccode > 0) { 355 lprintf(LOG_ERR, "Set Global Enables command failed: %s", 356 val2str(rsp->ccode, completion_code_vals)); 357 return -1; 358 } 359 360 printf("\nVerifying...\n"); 361 ipmi_mc_get_enables(intf); 362 363 return 0; 364 } 365 366 /* IPM Device, Get Device ID Command - Additional Device Support */ 367 const char *ipm_dev_adtl_dev_support[8] = { 368 "Sensor Device", /* bit 0 */ 369 "SDR Repository Device", /* bit 1 */ 370 "SEL Device", /* bit 2 */ 371 "FRU Inventory Device", /* ... */ 372 "IPMB Event Receiver", 373 "IPMB Event Generator", 374 "Bridge", 375 "Chassis Device" /* bit 7 */ 376 }; 377 378 /* ipmi_mc_get_deviceid - print information about this MC 379 * 380 * @intf: ipmi interface 381 * 382 * returns 0 on success 383 * returns -1 on error 384 */ 385 static int 386 ipmi_mc_get_deviceid(struct ipmi_intf * intf) 387 { 388 struct ipmi_rs * rsp; 389 struct ipmi_rq req; 390 struct ipm_devid_rsp *devid; 391 int i; 392 const char *product=NULL; 393 394 memset(&req, 0, sizeof(req)); 395 req.msg.netfn = IPMI_NETFN_APP; 396 req.msg.cmd = BMC_GET_DEVICE_ID; 397 req.msg.data_len = 0; 398 399 rsp = intf->sendrecv(intf, &req); 400 if (rsp == NULL) { 401 lprintf(LOG_ERR, "Get Device ID command failed"); 402 return -1; 403 } 404 if (rsp->ccode > 0) { 405 lprintf(LOG_ERR, "Get Device ID command failed: %s", 406 val2str(rsp->ccode, completion_code_vals)); 407 return -1; 408 } 409 410 devid = (struct ipm_devid_rsp *) rsp->data; 411 printf("Device ID : %i\n", 412 devid->device_id); 413 printf("Device Revision : %i\n", 414 devid->device_revision & IPM_DEV_DEVICE_ID_REV_MASK); 415 printf("Firmware Revision : %u.%02x\n", 416 devid->fw_rev1 & IPM_DEV_FWREV1_MAJOR_MASK, 417 devid->fw_rev2); 418 printf("IPMI Version : %x.%x\n", 419 IPM_DEV_IPMI_VERSION_MAJOR(devid->ipmi_version), 420 IPM_DEV_IPMI_VERSION_MINOR(devid->ipmi_version)); 421 printf("Manufacturer ID : %lu\n", 422 (long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id)); 423 printf("Manufacturer Name : %s\n", 424 val2str( (long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id), 425 ipmi_oem_info) ); 426 427 printf("Product ID : %u (0x%02x%02x)\n", 428 buf2short((uint8_t *)(devid->product_id)), 429 devid->product_id[1], devid->product_id[0]); 430 431 product=oemval2str(IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id), 432 (devid->product_id[1]<<8)+devid->product_id[0], 433 ipmi_oem_product_info); 434 435 if (product!=NULL) { 436 printf("Product Name : %s\n", product); 437 } 438 439 printf("Device Available : %s\n", 440 (devid->fw_rev1 & IPM_DEV_FWREV1_AVAIL_MASK) ? 441 "no" : "yes"); 442 printf("Provides Device SDRs : %s\n", 443 (devid->device_revision & IPM_DEV_DEVICE_ID_SDR_MASK) ? 444 "yes" : "no"); 445 printf("Additional Device Support :\n"); 446 for (i = 0; i < IPM_DEV_ADTL_SUPPORT_BITS; i++) { 447 if (devid->adtl_device_support & (1 << i)) { 448 printf(" %s\n", ipm_dev_adtl_dev_support[i]); 449 } 450 } 451 if (rsp->data_len == sizeof(*devid)) { 452 printf("Aux Firmware Rev Info : \n"); 453 /* These values could be looked-up by vendor if documented, 454 * so we put them on individual lines for better treatment later 455 */ 456 printf(" 0x%02x\n 0x%02x\n 0x%02x\n 0x%02x\n", 457 devid->aux_fw_rev[0], 458 devid->aux_fw_rev[1], 459 devid->aux_fw_rev[2], 460 devid->aux_fw_rev[3]); 461 } 462 return 0; 463 } 464 465 /* Structure follow the IPMI V.2 Rev 1.0 466 * See Table 20-10 */ 467 #ifdef HAVE_PRAGMA_PACK 468 #pragma pack(1) 469 #endif 470 471 struct ipmi_guid { 472 uint32_t time_low; /* timestamp low field */ 473 uint16_t time_mid; /* timestamp middle field */ 474 uint16_t time_hi_and_version; /* timestamp high field and version number */ 475 uint8_t clock_seq_hi_variant;/* clock sequence high field and variant */ 476 uint8_t clock_seq_low; /* clock sequence low field */ 477 uint8_t node[6]; /* node */ 478 } ATTRIBUTE_PACKING; 479 #ifdef HAVE_PRAGMA_PACK 480 #pragma pack(0) 481 #endif 482 483 /* ipmi_mc_get_guid - print this MC GUID 484 * 485 * @intf: ipmi interface 486 * 487 * returns 0 on success 488 * returns -1 on error 489 */ 490 static int 491 ipmi_mc_get_guid(struct ipmi_intf * intf) 492 { 493 struct ipmi_rs * rsp; 494 struct ipmi_rq req; 495 struct ipmi_guid guid; 496 497 memset(&req, 0, sizeof(req)); 498 req.msg.netfn = IPMI_NETFN_APP; 499 req.msg.cmd = BMC_GET_GUID; 500 501 rsp = intf->sendrecv(intf, &req); 502 if (rsp == NULL) { 503 lprintf(LOG_ERR, "Get GUID command failed"); 504 return -1; 505 } 506 if (rsp->ccode > 0) { 507 lprintf(LOG_ERR, "Get GUID command failed: %s", 508 val2str(rsp->ccode, completion_code_vals)); 509 return -1; 510 } 511 512 if (rsp->data_len == sizeof(struct ipmi_guid)) { 513 char tbuf[40]; 514 time_t s; 515 memset(tbuf, 0, 40); 516 memset(&guid, 0, sizeof(struct ipmi_guid)); 517 memcpy(&guid, rsp->data, rsp->data_len); 518 519 /* Kipp - changed order of last field (node) to follow specification */ 520 printf("System GUID : %08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x\n", 521 guid.time_low, guid.time_mid, guid.time_hi_and_version, 522 guid.clock_seq_hi_variant << 8 | guid.clock_seq_low, 523 guid.node[0], guid.node[1], guid.node[2], 524 guid.node[3], guid.node[4], guid.node[5]); 525 526 s = (time_t)guid.time_low; /* Kipp - removed the BSWAP_32, it was not needed here */ 527 strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", localtime(&s)); 528 printf("Timestamp : %s\n", tbuf); 529 } 530 else { 531 lprintf(LOG_ERR, "Invalid GUID length %d", rsp->data_len); 532 } 533 534 return 0; 535 } 536 537 /* ipmi_mc_get_selftest - returns and print selftest results 538 * 539 * @intf: ipmi interface 540 */ 541 static int ipmi_mc_get_selftest(struct ipmi_intf * intf) 542 { 543 int rv = 0; 544 struct ipmi_rs * rsp; 545 struct ipmi_rq req; 546 struct ipm_selftest_rsp *sft_res; 547 548 memset(&req, 0, sizeof(req)); 549 req.msg.netfn = IPMI_NETFN_APP; 550 req.msg.cmd = BMC_GET_SELF_TEST; 551 req.msg.data_len = 0; 552 553 rsp = intf->sendrecv(intf, &req); 554 if (!rsp) { 555 lprintf(LOG_ERR, "No response from devices\n"); 556 return -1; 557 } 558 559 if (rsp->ccode) { 560 lprintf(LOG_ERR, "Bad response: (%s)", 561 val2str(rsp->ccode, completion_code_vals)); 562 return -1; 563 } 564 565 sft_res = (struct ipm_selftest_rsp *) rsp->data; 566 567 if (sft_res->code == IPM_SFT_CODE_OK) { 568 printf("Selftest: passed\n"); 569 rv = 0; 570 } 571 572 else if (sft_res->code == IPM_SFT_CODE_NOT_IMPLEMENTED) { 573 printf("Selftest: not implemented\n"); 574 rv = -1; 575 } 576 577 else if (sft_res->code == IPM_SFT_CODE_DEV_CORRUPTED) { 578 printf("Selftest: device corrupted\n"); 579 rv = -1; 580 581 if (sft_res->test & IPM_SELFTEST_SEL_ERROR) { 582 printf(" -> SEL device not accessible\n"); 583 } 584 if (sft_res->test & IPM_SELFTEST_SDR_ERROR) { 585 printf(" -> SDR repository not accesible\n"); 586 } 587 if (sft_res->test & IPM_SELFTEST_FRU_ERROR) { 588 printf("FRU device not accessible\n"); 589 } 590 if (sft_res->test & IPM_SELFTEST_IPMB_ERROR) { 591 printf("IPMB signal lines do not respond\n"); 592 } 593 if (sft_res->test & IPM_SELFTEST_SDRR_EMPTY) { 594 printf("SDR repository empty\n"); 595 } 596 if (sft_res->test & IPM_SELFTEST_INTERNAL_USE) { 597 printf("Internal Use Area corrupted\n"); 598 } 599 if (sft_res->test & IPM_SELFTEST_FW_BOOTBLOCK) { 600 printf("Controller update boot block corrupted\n"); 601 } 602 if (sft_res->test & IPM_SELFTEST_FW_CORRUPTED) { 603 printf("controller operational firmware corrupted\n"); 604 } 605 } 606 607 else if (sft_res->code == IPM_SFT_CODE_FATAL_ERROR) { 608 printf("Selftest : fatal error\n"); 609 printf("Failure code : %02x\n", sft_res->test); 610 rv = -1; 611 } 612 613 else if (sft_res->code == IPM_SFT_CODE_RESERVED) { 614 printf("Selftest: N/A"); 615 rv = -1; 616 } 617 618 else { 619 printf("Selftest : device specific (%02Xh)\n", sft_res->code); 620 printf("Failure code : %02Xh\n", sft_res->test); 621 rv = 0; 622 } 623 624 return rv; 625 } 626 627 /* ipmi_mc_get_watchdog 628 * 629 * @intf: ipmi interface 630 * 631 * returns 0 on success 632 * returns -1 on error 633 */ 634 635 const char *wdt_use_string[8] = { 636 "Reserved", 637 "BIOS FRB2", 638 "BIOS/POST", 639 "OS Load", 640 "SMS/OS", 641 "OEM", 642 "Reserved", 643 "Reserved" 644 }; 645 646 const char *wdt_action_string[8] = { 647 "No action", 648 "Hard Reset", 649 "Power Down", 650 "Power Cycle", 651 "Reserved", 652 "Reserved", 653 "Reserved", 654 "Reserved" 655 }; 656 657 static int 658 ipmi_mc_get_watchdog(struct ipmi_intf * intf) 659 { 660 struct ipmi_rs * rsp; 661 struct ipmi_rq req; 662 struct ipm_get_watchdog_rsp * wdt_res; 663 664 memset(&req, 0, sizeof(req)); 665 req.msg.netfn = IPMI_NETFN_APP; 666 req.msg.cmd = BMC_GET_WATCHDOG_TIMER; 667 req.msg.data_len = 0; 668 669 rsp = intf->sendrecv(intf, &req); 670 if (rsp == NULL) { 671 lprintf(LOG_ERR, "Get Watchdog Timer command failed"); 672 return -1; 673 } 674 675 if (rsp->ccode) { 676 lprintf(LOG_ERR, "Get Watchdog Timer command failed: %s", 677 val2str(rsp->ccode, completion_code_vals)); 678 return -1; 679 } 680 681 wdt_res = (struct ipm_get_watchdog_rsp *) rsp->data; 682 683 printf("Watchdog Timer Use: %s (0x%02x)\n", 684 wdt_use_string[(wdt_res->timer_use & 0x07 )], wdt_res->timer_use); 685 printf("Watchdog Timer Is: %s\n", 686 wdt_res->timer_use & 0x40 ? "Started/Running" : "Stopped"); 687 printf("Watchdog Timer Actions: %s (0x%02x)\n", 688 wdt_action_string[(wdt_res->timer_actions&0x07)], wdt_res->timer_actions); 689 printf("Pre-timeout interval: %d seconds\n", wdt_res->pre_timeout); 690 printf("Timer Expiration Flags: 0x%02x\n", wdt_res->timer_use_exp); 691 printf("Initial Countdown: %i sec\n", 692 ((wdt_res->initial_countdown_msb << 8) | wdt_res->initial_countdown_lsb)/10); 693 printf("Present Countdown: %i sec\n", 694 (((wdt_res->present_countdown_msb << 8) | wdt_res->present_countdown_lsb)) / 10); 695 696 return 0; 697 } 698 699 /* ipmi_mc_shutoff_watchdog 700 * 701 * @intf: ipmi interface 702 * 703 * returns 0 on success 704 * returns -1 on error 705 */ 706 static int 707 ipmi_mc_shutoff_watchdog(struct ipmi_intf * intf) 708 { 709 struct ipmi_rs * rsp; 710 struct ipmi_rq req; 711 unsigned char msg_data[6]; 712 713 memset(&req, 0, sizeof(req)); 714 req.msg.netfn = IPMI_NETFN_APP; 715 req.msg.cmd = BMC_SET_WATCHDOG_TIMER; 716 req.msg.data = msg_data; 717 req.msg.data_len = 6; 718 719 /* 720 * The only set cmd we're allowing is to shut off the timer. 721 * Turning on the timer should be the job of the ipmi watchdog driver. 722 * See 'modinfo ipmi_watchdog' for more info. (NOTE: the reset 723 * command will restart the timer if it's already been initialized.) 724 * 725 * Out-of-band watchdog set commands can still be sent via the raw 726 * command interface but this is a very dangerous thing to do since 727 * a periodic "poke"/reset over a network is unreliable. This is 728 * not a recommended way to use the IPMI watchdog commands. 729 */ 730 731 msg_data[0] = IPM_WATCHDOG_SMS_OS; 732 msg_data[1] = IPM_WATCHDOG_NO_ACTION; 733 msg_data[2] = 0x00; /* pretimeout interval */ 734 msg_data[3] = IPM_WATCHDOG_CLEAR_SMS_OS; 735 msg_data[4] = 0xb8; /* countdown lsb (100 ms/count) */ 736 msg_data[5] = 0x0b; /* countdown msb - 5 mins */ 737 738 rsp = intf->sendrecv(intf, &req); 739 if (rsp == NULL) { 740 lprintf(LOG_ERR, "Watchdog Timer Shutoff command failed!"); 741 return -1; 742 } 743 744 if (rsp->ccode) { 745 lprintf(LOG_ERR, "Watchdog Timer Shutoff command failed! %s", 746 val2str(rsp->ccode, completion_code_vals)); 747 return -1; 748 } 749 750 printf("Watchdog Timer Shutoff successful -- timer stopped\n"); 751 return 0; 752 } 753 754 755 /* ipmi_mc_rst_watchdog 756 * 757 * @intf: ipmi interface 758 * 759 * returns 0 on success 760 * returns -1 on error 761 */ 762 static int 763 ipmi_mc_rst_watchdog(struct ipmi_intf * intf) 764 { 765 struct ipmi_rs * rsp; 766 struct ipmi_rq req; 767 768 memset(&req, 0, sizeof(req)); 769 req.msg.netfn = IPMI_NETFN_APP; 770 req.msg.cmd = BMC_RESET_WATCHDOG_TIMER; 771 req.msg.data_len = 0; 772 773 rsp = intf->sendrecv(intf, &req); 774 if (rsp == NULL) { 775 lprintf(LOG_ERR, "Reset Watchdog Timer command failed!"); 776 return -1; 777 } 778 779 if (rsp->ccode) { 780 lprintf(LOG_ERR, "Reset Watchdog Timer command failed: %s", 781 (rsp->ccode == IPM_WATCHDOG_RESET_ERROR) ? 782 "Attempt to reset unitialized watchdog" : 783 val2str(rsp->ccode, completion_code_vals)); 784 return -1; 785 } 786 787 printf("IPMI Watchdog Timer Reset - countdown restarted!\n"); 788 return 0; 789 } 790 791 /* ipmi_mc_main - top-level handler for MC functions 792 * 793 * @intf: ipmi interface 794 * @argc: number of arguments 795 * @argv: argument list 796 * 797 * returns 0 on success 798 * returns -1 on error 799 */ 800 int 801 ipmi_mc_main(struct ipmi_intf * intf, int argc, char ** argv) 802 { 803 int rc = 0; 804 805 if (argc < 1) { 806 lprintf(LOG_ERR, "Not enough parameters given."); 807 printf_mc_usage(); 808 rc = (-1); 809 } 810 else if (strncmp(argv[0], "help", 4) == 0) { 811 printf_mc_usage(); 812 rc = 0; 813 } 814 else if (strncmp(argv[0], "reset", 5) == 0) { 815 if (argc < 2) { 816 lprintf(LOG_ERR, "Not enough parameters given."); 817 printf_mc_reset_usage(); 818 rc = (-1); 819 } 820 else if (strncmp(argv[1], "help", 4) == 0) { 821 printf_mc_reset_usage(); 822 rc = 0; 823 } 824 else if (strncmp(argv[1], "cold", 4) == 0) { 825 rc = ipmi_mc_reset(intf, BMC_COLD_RESET); 826 } 827 else if (strncmp(argv[1], "warm", 4) == 0) { 828 rc = ipmi_mc_reset(intf, BMC_WARM_RESET); 829 } 830 else { 831 lprintf(LOG_ERR, "Invalid mc/bmc %s command: %s", argv[0], argv[1]); 832 printf_mc_reset_usage(); 833 rc = (-1); 834 } 835 } 836 else if (strncmp(argv[0], "info", 4) == 0) { 837 rc = ipmi_mc_get_deviceid(intf); 838 } 839 else if (strncmp(argv[0], "guid", 4) == 0) { 840 rc = ipmi_mc_get_guid(intf); 841 } 842 else if (strncmp(argv[0], "getenables", 10) == 0) { 843 rc = ipmi_mc_get_enables(intf); 844 } 845 else if (strncmp(argv[0], "setenables", 10) == 0) { 846 rc = ipmi_mc_set_enables(intf, argc-1, &(argv[1])); 847 } 848 else if (!strncmp(argv[0], "selftest", 8)) { 849 rc = ipmi_mc_get_selftest(intf); 850 } 851 else if (!strncmp(argv[0], "watchdog", 8)) { 852 if (argc < 2) { 853 lprintf(LOG_ERR, "Not enough parameters given."); 854 print_watchdog_usage(); 855 rc = (-1); 856 } 857 else if (strncmp(argv[1], "help", 4) == 0) { 858 print_watchdog_usage(); 859 rc = 0; 860 } 861 else if (strncmp(argv[1], "get", 3) == 0) { 862 rc = ipmi_mc_get_watchdog(intf); 863 } 864 else if(strncmp(argv[1], "off", 3) == 0) { 865 rc = ipmi_mc_shutoff_watchdog(intf); 866 } 867 else if(strncmp(argv[1], "reset", 5) == 0) { 868 rc = ipmi_mc_rst_watchdog(intf); 869 } 870 else { 871 lprintf(LOG_ERR, "Invalid mc/bmc %s command: %s", argv[0], argv[1]); 872 print_watchdog_usage(); 873 rc = (-1); 874 } 875 } 876 else if (strncmp(argv[0], "getsysinfo", 10) == 0) { 877 rc = ipmi_sysinfo_main(intf, argc, argv, 0); 878 } 879 else if (strncmp(argv[0], "setsysinfo", 10) == 0) { 880 rc = ipmi_sysinfo_main(intf, argc, argv, 1); 881 } 882 else { 883 lprintf(LOG_ERR, "Invalid mc/bmc command: %s", argv[0]); 884 printf_mc_usage(); 885 rc = (-1); 886 } 887 return rc; 888 } 889 890 /* 891 * sysinfo_param() - function converts sysinfo param to int 892 * 893 * @str - user input string 894 * @maxset - ? 895 * 896 * returns (-1) on error 897 * returns > 0 on success 898 */ 899 static int 900 sysinfo_param(const char *str, int *maxset) 901 { 902 if (!str || !maxset) 903 return (-1); 904 905 *maxset = 4; 906 if (!strcmp(str, "system_name")) 907 return IPMI_SYSINFO_HOSTNAME; 908 else if (!strcmp(str, "primary_os_name")) 909 return IPMI_SYSINFO_PRIMARY_OS_NAME; 910 else if (!strcmp(str, "os_name")) 911 return IPMI_SYSINFO_OS_NAME; 912 else if (!strcmp(str, "delloem_os_version")) 913 return IPMI_SYSINFO_DELL_OS_VERSION; 914 else if (!strcmp(str, "delloem_url")) { 915 *maxset = 2; 916 return IPMI_SYSINFO_DELL_URL; 917 } else if (!strcmp(str, "system_fw_version")) { 918 return IPMI_SYSINFO_SYSTEM_FW_VERSION; 919 } 920 921 return (-1); 922 } 923 924 /* 925 * ipmi_mc_getsysinfo() - function processes the IPMI Get System Info command 926 * 927 * @intf - ipmi interface 928 * @param - parameter eg. 0xC0..0xFF = OEM 929 * @block - number of block parameters 930 * @set - number of set parameters 931 * @len - length of buffer 932 * @buffer - pointer to buffer 933 * 934 * returns (-1) on failure 935 * returns 0 on success 936 * returns > 0 IPMI code 937 */ 938 int 939 ipmi_mc_getsysinfo(struct ipmi_intf * intf, int param, int block, int set, 940 int len, void *buffer) 941 { 942 uint8_t data[4]; 943 struct ipmi_rs *rsp = NULL; 944 struct ipmi_rq req = {0}; 945 946 memset(buffer, 0, len); 947 memset(data, 0, 4); 948 req.msg.netfn = IPMI_NETFN_APP; 949 req.msg.lun = 0; 950 req.msg.cmd = IPMI_GET_SYS_INFO; 951 req.msg.data_len = 4; 952 req.msg.data = data; 953 954 if (verbose > 1) 955 printf("getsysinfo: %.2x/%.2x/%.2x\n", param, block, set); 956 957 data[0] = 0; /* get/set */ 958 data[1] = param; 959 data[2] = block; 960 data[3] = set; 961 962 /* 963 * Format of get output is: 964 * u8 param_rev 965 * u8 selector 966 * u8 encoding bit[0-3]; 967 * u8 length 968 * u8 data0[14] 969 */ 970 rsp = intf->sendrecv(intf, &req); 971 if (rsp == NULL) 972 return (-1); 973 974 if (rsp->ccode == 0) { 975 if (len > rsp->data_len) 976 len = rsp->data_len; 977 if (len && buffer) 978 memcpy(buffer, rsp->data, len); 979 } 980 return rsp->ccode; 981 } 982 983 /* 984 * ipmi_mc_setsysinfo() - function processes the IPMI Set System Info command 985 * 986 * @intf - ipmi interface 987 * @len - length of buffer 988 * @buffer - pointer to buffer 989 * 990 * returns (-1) on failure 991 * returns 0 on success 992 * returns > 0 IPMI code 993 */ 994 int 995 ipmi_mc_setsysinfo(struct ipmi_intf * intf, int len, void *buffer) 996 { 997 struct ipmi_rs *rsp = NULL; 998 struct ipmi_rq req = {0}; 999 1000 req.msg.netfn = IPMI_NETFN_APP; 1001 req.msg.lun = 0; 1002 req.msg.cmd = IPMI_SET_SYS_INFO; 1003 req.msg.data_len = len; 1004 req.msg.data = buffer; 1005 1006 /* 1007 * Format of set input: 1008 * u8 param rev 1009 * u8 selector 1010 * u8 data1[16] 1011 */ 1012 rsp = intf->sendrecv(intf, &req); 1013 if (rsp != NULL) { 1014 return rsp->ccode; 1015 } 1016 return -1; 1017 } 1018 1019 static int 1020 ipmi_sysinfo_main(struct ipmi_intf *intf, int argc, char ** argv, int is_set) 1021 { 1022 char *str; 1023 unsigned char infostr[256]; 1024 unsigned char paramdata[18]; 1025 int len, maxset, param, pos, rc, set; 1026 1027 if (argc == 2 && strcmp(argv[1], "help") == 0) { 1028 printf_sysinfo_usage(1); 1029 return 0; 1030 } 1031 else if (argc < 2 || (is_set == 1 && argc < 3)) { 1032 lprintf(LOG_ERR, "Not enough parameters given."); 1033 printf_sysinfo_usage(1); 1034 return (-1); 1035 } 1036 1037 /* Get Parameters */ 1038 if ((param = sysinfo_param(argv[1], &maxset)) < 0) { 1039 lprintf(LOG_ERR, "Invalid mc/bmc %s command: %s", argv[0], argv[1]); 1040 printf_sysinfo_usage(1); 1041 return (-1); 1042 } 1043 1044 rc = 0; 1045 if (is_set != 0) { 1046 str = argv[2]; 1047 set = pos = 0; 1048 len = strlen(str); 1049 1050 /* first block holds 14 bytes, all others hold 16 */ 1051 if ((len + 2 + 15) / 16 >= maxset) 1052 len = (maxset * 16) - 2; 1053 1054 do { 1055 memset(paramdata, 0, sizeof(paramdata)); 1056 paramdata[0] = param; 1057 paramdata[1] = set; 1058 if (set == 0) { 1059 /* First block is special case */ 1060 paramdata[2] = 0; /* ascii encoding */ 1061 paramdata[3] = len; /* length */ 1062 strncpy(paramdata + 4, str + pos, IPMI_SYSINFO_SET0_SIZE); 1063 pos += IPMI_SYSINFO_SET0_SIZE; 1064 } 1065 else { 1066 strncpy(paramdata + 2, str + pos, IPMI_SYSINFO_SETN_SIZE); 1067 pos += IPMI_SYSINFO_SETN_SIZE; 1068 } 1069 rc = ipmi_mc_setsysinfo(intf, 18, paramdata); 1070 1071 if (rc) 1072 break; 1073 1074 set++; 1075 } while (pos < len); 1076 } 1077 else { 1078 memset(infostr, 0, sizeof(infostr)); 1079 /* Read blocks of data */ 1080 pos = 0; 1081 for (set = 0; set < maxset; set++) { 1082 rc = ipmi_mc_getsysinfo(intf, param, set, 0, 18, paramdata); 1083 1084 if (rc) 1085 break; 1086 1087 if (set == 0) { 1088 /* First block is special case */ 1089 if ((paramdata[2] & 0xF) == 0) { 1090 /* Determine max number of blocks to read */ 1091 maxset = ((paramdata[3] + 2) + 15) / 16; 1092 } 1093 memcpy(infostr + pos, paramdata + 4, IPMI_SYSINFO_SET0_SIZE); 1094 pos += IPMI_SYSINFO_SET0_SIZE; 1095 } 1096 else { 1097 memcpy(infostr + pos, paramdata + 2, IPMI_SYSINFO_SETN_SIZE); 1098 pos += IPMI_SYSINFO_SETN_SIZE; 1099 } 1100 } 1101 printf("%s\n", infostr); 1102 } 1103 if (rc < 0) { 1104 lprintf(LOG_ERR, "%s %s set %d command failed", argv[0], argv[1], set); 1105 } 1106 else if (rc == 0x80) { 1107 lprintf(LOG_ERR, "%s %s parameter not supported", argv[0], argv[1]); 1108 } 1109 else if (rc > 0) { 1110 lprintf(LOG_ERR, "%s command failed: %s", argv[0], 1111 val2str(rc, completion_code_vals)); 1112 } 1113 return rc; 1114 } 1115