summaryrefslogtreecommitdiff
path: root/lib/ipmi_mc.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/ipmi_mc.c')
-rw-r--r--lib/ipmi_mc.c774
1 files changed, 640 insertions, 134 deletions
diff --git a/lib/ipmi_mc.c b/lib/ipmi_mc.c
index 4580bfb..a594347 100644
--- a/lib/ipmi_mc.c
+++ b/lib/ipmi_mc.c
@@ -34,6 +34,10 @@
#include <string.h>
#include <stdio.h>
#include <time.h>
+#include <limits.h>
+#include <stdbool.h>
+
+#include <arpa/inet.h>
#include <ipmitool/helper.h>
#include <ipmitool/log.h>
@@ -42,6 +46,7 @@
#include <ipmitool/ipmi_intf.h>
#include <ipmitool/ipmi_mc.h>
#include <ipmitool/ipmi_strings.h>
+#include <ipmitool/ipmi_time.h>
extern int verbose;
@@ -81,14 +86,14 @@ ipmi_mc_reset(struct ipmi_intf * intf, int cmd)
if (cmd == BMC_COLD_RESET)
intf->abort = 1;
- if (cmd == BMC_COLD_RESET && rsp == NULL) {
+ if (cmd == BMC_COLD_RESET && !rsp) {
/* This is expected. See 20.2 Cold Reset Command, p.243, IPMIv2.0 rev1.0 */
- } else if (rsp == NULL) {
+ } else if (!rsp) {
lprintf(LOG_ERR, "MC reset command failed.");
return (-1);
- } else if (rsp->ccode > 0) {
+ } else if (rsp->ccode) {
lprintf(LOG_ERR, "MC reset command failed: %s",
- val2str(rsp->ccode, completion_code_vals));
+ CC_STRING(rsp->ccode));
return (-1);
}
@@ -181,13 +186,13 @@ printf_mc_usage(void)
struct bitfield_data * bf;
lprintf(LOG_NOTICE, "MC Commands:");
lprintf(LOG_NOTICE, " reset <warm|cold>");
- lprintf(LOG_NOTICE, " guid");
+ lprintf(LOG_NOTICE, " guid [auto|smbios|ipmi|rfc4122|dump]");
lprintf(LOG_NOTICE, " info");
lprintf(LOG_NOTICE, " watchdog <get|reset|off>");
lprintf(LOG_NOTICE, " selftest");
lprintf(LOG_NOTICE, " getenables");
lprintf(LOG_NOTICE, " setenables <option=on|off> ...");
- for (bf = mc_enables_bf; bf->name != NULL; bf++) {
+ for (bf = mc_enables_bf; bf->name; bf++) {
lprintf(LOG_NOTICE, " %-20s %s", bf->name, bf->desc);
}
printf_sysinfo_usage(0);
@@ -230,15 +235,38 @@ printf_sysinfo_usage(int full_help)
static void
print_watchdog_usage(void)
{
- lprintf(LOG_NOTICE, "usage: watchdog <command>:");
- lprintf(LOG_NOTICE, " get : Get Current Watchdog settings");
- lprintf(LOG_NOTICE, " reset : Restart Watchdog timer based on most recent settings");
- lprintf(LOG_NOTICE, " off : Shut off a running Watchdog timer");
+ lprintf(LOG_NOTICE,
+"usage: watchdog <command>:\n"
+"\n"
+" set <option[=value]> [<option[=value]> ...]\n"
+" Set Watchdog settings\n"
+" Options: (* = mandatory)\n"
+" timeout=<1-6553> - [0] Initial countdown value, sec\n"
+" pretimeout=<1-255> - [0] Pre-timeout interval, sec\n"
+" int=<smi|nmi|msg> - [-] Pre-timeout interrupt type\n"
+" use=<frb2|post|osload|sms|oem> - [-] Timer use\n"
+" clear=<frb2|post|osload|sms|oem> - [-] Clear timer use expiration\n"
+" flag, can be specified\n"
+" multiple times\n"
+" action=<reset|poweroff|cycle|none> - [none] Timer action\n"
+" nolog - [-] Don't log the timer use\n"
+" dontstop - [-] Don't stop the timer\n"
+" while applying settings\n"
+"\n"
+" get\n"
+" Get Current settings\n"
+"\n"
+" reset\n"
+" Restart Watchdog timer based on the most recent settings\n"
+"\n"
+" off\n"
+" Shut off a running Watchdog timer"
+ );
}
/* ipmi_mc_get_enables - print out MC enables
*
- * @intf: ipmi inteface
+ * @intf: ipmi interface
*
* returns 0 on success
* returns -1 on error
@@ -255,17 +283,17 @@ ipmi_mc_get_enables(struct ipmi_intf * intf)
req.msg.cmd = BMC_GET_GLOBAL_ENABLES;
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL) {
+ if (!rsp) {
lprintf(LOG_ERR, "Get Global Enables command failed");
return -1;
}
- if (rsp->ccode > 0) {
+ if (rsp->ccode) {
lprintf(LOG_ERR, "Get Global Enables command failed: %s",
- val2str(rsp->ccode, completion_code_vals));
+ CC_STRING(rsp->ccode));
return -1;
}
- for (bf = mc_enables_bf; bf->name != NULL; bf++) {
+ for (bf = mc_enables_bf; bf->name; bf++) {
printf("%-40s : %sabled\n", bf->desc,
rsp->data[0] & bf->mask ? "en" : "dis");
}
@@ -275,7 +303,7 @@ ipmi_mc_get_enables(struct ipmi_intf * intf)
/* ipmi_mc_set_enables - set MC enable flags
*
- * @intf: ipmi inteface
+ * @intf: ipmi interface
* @argc: argument count
* @argv: argument list
*
@@ -295,7 +323,7 @@ ipmi_mc_set_enables(struct ipmi_intf * intf, int argc, char ** argv)
printf_mc_usage();
return (-1);
}
- else if (strncmp(argv[0], "help", 4) == 0) {
+ else if (!strcmp(argv[0], "help")) {
printf_mc_usage();
return 0;
}
@@ -305,28 +333,28 @@ ipmi_mc_set_enables(struct ipmi_intf * intf, int argc, char ** argv)
req.msg.cmd = BMC_GET_GLOBAL_ENABLES;
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL) {
+ if (!rsp) {
lprintf(LOG_ERR, "Get Global Enables command failed");
return -1;
}
- if (rsp->ccode > 0) {
+ if (rsp->ccode) {
lprintf(LOG_ERR, "Get Global Enables command failed: %s",
- val2str(rsp->ccode, completion_code_vals));
+ CC_STRING(rsp->ccode));
return -1;
}
en = rsp->data[0];
for (i = 0; i < argc; i++) {
- for (bf = mc_enables_bf; bf->name != NULL; bf++) {
+ for (bf = mc_enables_bf; bf->name; bf++) {
int nl = strlen(bf->name);
- if (strncmp(argv[i], bf->name, nl) != 0)
+ if (strcmp(argv[i], bf->name))
continue;
- if (strncmp(argv[i]+nl+1, "off", 3) == 0) {
+ if (!strcmp(argv[i]+nl+1, "off")) {
printf("Disabling %s\n", bf->desc);
en &= ~bf->mask;
}
- else if (strncmp(argv[i]+nl+1, "on", 2) == 0) {
+ else if (!strcmp(argv[i]+nl+1, "on")) {
printf("Enabling %s\n", bf->desc);
en |= bf->mask;
}
@@ -347,13 +375,13 @@ ipmi_mc_set_enables(struct ipmi_intf * intf, int argc, char ** argv)
req.msg.data_len = 1;
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL) {
+ if (!rsp) {
lprintf(LOG_ERR, "Set Global Enables command failed");
return -1;
}
- else if (rsp->ccode > 0) {
+ else if (rsp->ccode) {
lprintf(LOG_ERR, "Set Global Enables command failed: %s",
- val2str(rsp->ccode, completion_code_vals));
+ CC_STRING(rsp->ccode));
return -1;
}
@@ -397,13 +425,13 @@ ipmi_mc_get_deviceid(struct ipmi_intf * intf)
req.msg.data_len = 0;
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL) {
+ if (!rsp) {
lprintf(LOG_ERR, "Get Device ID command failed");
return -1;
}
- if (rsp->ccode > 0) {
+ if (rsp->ccode) {
lprintf(LOG_ERR, "Get Device ID command failed: %s",
- val2str(rsp->ccode, completion_code_vals));
+ CC_STRING(rsp->ccode));
return -1;
}
@@ -421,18 +449,15 @@ ipmi_mc_get_deviceid(struct ipmi_intf * intf)
printf("Manufacturer ID : %lu\n",
(long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id));
printf("Manufacturer Name : %s\n",
- val2str( (long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id),
- ipmi_oem_info) );
+ OEM_MFG_STRING(devid->manufacturer_id));
printf("Product ID : %u (0x%02x%02x)\n",
buf2short((uint8_t *)(devid->product_id)),
devid->product_id[1], devid->product_id[0]);
- product=oemval2str(IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id),
- (devid->product_id[1]<<8)+devid->product_id[0],
- ipmi_oem_product_info);
+ product = OEM_PROD_STRING(devid->manufacturer_id, devid->product_id);
- if (product!=NULL) {
+ if (product) {
printf("Product Name : %s\n", product);
}
@@ -470,69 +495,292 @@ ipmi_mc_get_deviceid(struct ipmi_intf * intf)
* returns - negative number means error, positive is a ccode.
*/
int
-_ipmi_mc_get_guid(struct ipmi_intf *intf, struct ipmi_guid_t *guid)
+_ipmi_mc_get_guid(struct ipmi_intf *intf, ipmi_guid_t *guid)
{
struct ipmi_rs *rsp;
struct ipmi_rq req;
- if (guid == NULL) {
+ if (!guid) {
return (-3);
}
- memset(guid, 0, sizeof(struct ipmi_guid_t));
+ memset(guid, 0, sizeof(ipmi_guid_t));
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_APP;
req.msg.cmd = BMC_GET_GUID;
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL) {
+ if (!rsp) {
return (-1);
- } else if (rsp->ccode > 0) {
+ } else if (rsp->ccode) {
return rsp->ccode;
} else if (rsp->data_len != 16
- || rsp->data_len != sizeof(struct ipmi_guid_t)) {
+ || rsp->data_len != sizeof(ipmi_guid_t)) {
return (-2);
}
- memcpy(guid, &rsp->data[0], sizeof(struct ipmi_guid_t));
+ memcpy(guid, &rsp->data[0], sizeof(ipmi_guid_t));
return 0;
}
-/* ipmi_mc_print_guid - print-out given BMC GUID
+/* A helper function to convert GUID time to time_t */
+static time_t _guid_time(uint64_t t_low, uint64_t t_mid, uint64_t t_hi)
+{
+ /* GUID time-stamp is a 60-bit value representing the
+ * count of 100ns intervals since 00:00:00.00, 15 Oct 1582 */
+
+ const uint64_t t100ns_in_sec = 10000000LL;
+
+ /* Seconds from 15 Oct 1582 to 1 Jan 1970 00:00:00 */
+ uint64_t epoch_since_gregorian = 12219292800;
+
+ /* 100ns intervals since 15 Oct 1582 00:00:00 */
+ uint64_t gregorian = (GUID_TIME_HI(t_hi) << 48)
+ | (t_mid << 32)
+ | t_low;
+ time_t unixtime; /* We need timestamp in seconds since UNIX epoch */
+
+ gregorian /= t100ns_in_sec; /* Convert to seconds */
+ unixtime = gregorian - epoch_since_gregorian;
+
+ return unixtime;
+}
+
+#define TM_YEAR_BASE 1900
+#define EPOCH_YEAR 1970
+static bool _is_time_valid(time_t t)
+{
+ time_t t_now = time(NULL);
+ struct tm tm;
+ struct tm now;
+
+ gmtime_r(&t, &tm);
+ gmtime_r(&t_now, &now);
+
+ /* It's enought to check that the year fits in [Epoch .. now] interval */
+
+ if (tm.tm_year + TM_YEAR_BASE < EPOCH_YEAR)
+ return false;
+
+ if (tm.tm_year > now.tm_year) {
+ /* GUID timestamp can't be in future */
+ return false;
+ }
+
+ return true;
+}
+
+/** ipmi_mc_parse_guid - print-out given BMC GUID
+ *
+ * The function parses the raw guid data according to the requested encoding
+ * mode. If GUID_AUTO mode is requested, then automatic detection of encoding
+ * is attempted using the version nibble of the time_hi_and_version field of
+ * each of the supported encodings.
*
- * @guid - struct with GUID.
+ * Considering the rather random nature of GUIDs, it may happen that the
+ * version nibble is valid for multiple encodings at the same time. That's why
+ * if the version is 1 (time-based), the function will also check validity of
+ * the time stamp. If a valid time stamp is found for a given mode, the mode is
+ * considered detected and no further checks are performed. Otherwise other
+ * encodings are probed the same way. If in neither encoding the valid version
+ * nibble happened to indicate time-based version or no valid time-stamp has
+ * been found, then the last probed encoding with valid version nibble is
+ * considered detected. If none of the probed encodings indicated a valid
+ * version nibble, then fall back to GUID_DUMP
*
- * returns 0
+ * @param[in] guid - The original GUID data as received from BMC
+ * @param[in] mode - The requested mode/encoding
+ *
+ * @returns parsed GUID
*/
-static int
-ipmi_mc_print_guid(struct ipmi_guid_t guid)
+parsed_guid_t ipmi_parse_guid(void *guid, ipmi_guid_mode_t guid_mode)
{
- char tbuf[40];
- time_t s;
- memset(tbuf, 0, 40);
- /* Kipp - changed order of last field (node) to follow specification */
- printf("System GUID : %08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x\n",
- guid.time_low, guid.time_mid, guid.time_hi_and_version,
- guid.clock_seq_hi_variant << 8 | guid.clock_seq_low,
- guid.node[0], guid.node[1], guid.node[2],
- guid.node[3], guid.node[4], guid.node[5]);
+ ipmi_guid_mode_t i;
+ ipmi_guid_t *ipmi_guid = guid;
+ rfc_guid_t *rfc_guid = guid;
+ parsed_guid_t parsed_guid = { 0 };
+ uint32_t t_low[GUID_REAL_MODES];
+ uint16_t t_mid[GUID_REAL_MODES];
+ uint16_t t_hi[GUID_REAL_MODES];
+ uint16_t clk[GUID_REAL_MODES];
+ time_t seconds[GUID_REAL_MODES];
+ bool detect = false;
+
+ /* Unless another mode is detected, default to dumping */
+ if (GUID_AUTO == guid_mode) {
+ detect = true;
+ guid_mode = GUID_DUMP;
+ }
- s = (time_t)guid.time_low; /* Kipp - removed the BSWAP_32, it was not needed here */
- strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", localtime(&s));
- printf("Timestamp : %s\n", tbuf);
- return 0;
+ /* Try to convert time using all possible methods to use
+ * the result later if GUID_AUTO is requested */
+
+ /* For IPMI all fields are little-endian (LSB first) */
+ t_hi[GUID_IPMI] = ipmi16toh(&ipmi_guid->time_hi_and_version);
+ t_mid[GUID_IPMI] = ipmi16toh(&ipmi_guid->time_mid);
+ t_low[GUID_IPMI] = ipmi32toh(&ipmi_guid->time_low);
+ clk[GUID_IPMI] = ipmi16toh(&ipmi_guid->clock_seq_and_rsvd);
+
+ /* For RFC4122 all fields are in network byte order (MSB first) */
+ t_hi[GUID_RFC4122] = ntohs(rfc_guid->time_hi_and_version);
+ t_mid[GUID_RFC4122] = ntohs(rfc_guid->time_mid);
+ t_low[GUID_RFC4122] = ntohl(rfc_guid->time_low);
+ clk[GUID_RFC4122] = ntohs(rfc_guid->clock_seq_and_rsvd);
+
+ /* For SMBIOS time fields are little-endian (as in IPMI), the rest is
+ * in network order (as in RFC4122) */
+ t_hi[GUID_SMBIOS] = ipmi16toh(&rfc_guid->time_hi_and_version);
+ t_mid[GUID_SMBIOS] = ipmi16toh(&rfc_guid->time_mid);
+ t_low[GUID_SMBIOS] = ipmi32toh(&rfc_guid->time_low);
+ clk[GUID_SMBIOS] = ntohs(rfc_guid->clock_seq_and_rsvd);
+
+ /* Using 0 here to allow for reordering of modes in ipmi_guid_mode_t */
+ for (i = 0; i < GUID_REAL_MODES; ++i) {
+ seconds[i] = _guid_time(t_low[i], t_mid[i], t_hi[i]);
+
+ /* If autodetection was initially requested and mode
+ * hasn't been detected yet */
+ if (detect) {
+ guid_version_t ver = GUID_VERSION(t_hi[i]);
+ if (is_guid_version_valid(ver)) {
+ guid_mode = i;
+ if (GUID_VERSION_TIME == ver && _is_time_valid(seconds[i])) {
+ break;
+ }
+ }
+ }
+ }
+
+ if (guid_mode >= GUID_REAL_MODES) {
+ guid_mode = GUID_DUMP;
+ /* The endianness and field order are irrelevant for dump mode */
+ memcpy(&parsed_guid, guid, sizeof(ipmi_guid_t));
+ goto out;
+ }
+
+ /*
+ * Return only a valid version in the parsed version field.
+ * If one needs the raw value, they still may use
+ * GUID_VERSION(parsed_guid.time_hi_and_version)
+ */
+ parsed_guid.ver = GUID_VERSION(t_hi[guid_mode]);
+ if (parsed_guid.ver > GUID_VERSION_MAX) {
+ parsed_guid.ver = GUID_VERSION_UNKNOWN;
+ }
+
+ if (GUID_VERSION_TIME == parsed_guid.ver) {
+ parsed_guid.time = seconds[guid_mode];
+ }
+
+ if (GUID_IPMI == guid_mode) {
+ /*
+ * In IPMI all fields are little-endian (LSB first)
+ * That is, first byte last. Hence, swap before copying.
+ */
+ memcpy(parsed_guid.node,
+ array_byteswap(ipmi_guid->node, GUID_NODE_SZ),
+ GUID_NODE_SZ);
+ } else {
+ /*
+ * For RFC4122 and SMBIOS the node field is in network byte order.
+ * That is first byte first. Hence, copy as is.
+ */
+ memcpy(parsed_guid.node, rfc_guid->node, GUID_NODE_SZ);
+ }
+
+ parsed_guid.time_low = t_low[guid_mode];
+ parsed_guid.time_mid = t_mid[guid_mode];
+ parsed_guid.time_hi_and_version = t_hi[guid_mode];
+ parsed_guid.clock_seq_and_rsvd = clk[guid_mode];
+
+out:
+ parsed_guid.mode = guid_mode;
+ return parsed_guid;
}
-/* ipmi_mc_get_guid - Gets and prints-out System GUID */
-int
-ipmi_mc_get_guid(struct ipmi_intf *intf)
+/* ipmi_mc_print_guid - print-out given BMC GUID
+ *
+ * @param[in] intf - The IPMI interface to request GUID from
+ * @param[in] guid_mode - GUID decoding mode
+ *
+ * @returns status code
+ * @retval 0 - Success
+ * @retval -1 - Error
+ */
+static int
+ipmi_mc_print_guid(struct ipmi_intf *intf, ipmi_guid_mode_t guid_mode)
{
- struct ipmi_guid_t guid;
+ /* Allocate a byte array for ease of use in dump mode */
+ uint8_t guid_data[sizeof(ipmi_guid_t)];
+
+ /* These are host architecture specific */
+ parsed_guid_t guid;
+
+ const char *guid_ver_str[GUID_VERSION_COUNT] = {
+ [GUID_VERSION_UNKNOWN] = "Unknown/unsupported",
+ [GUID_VERSION_TIME] = "Time-based",
+ [GUID_VERSION_DCE] = "DCE Security with POSIX UIDs (not for IPMI)",
+ [GUID_VERSION_MD5] = "Name-based using MD5",
+ [GUID_VERSION_RND] = "Random or pseudo-random",
+ [GUID_VERSION_SHA1] = "Name-based using SHA-1"
+ };
+
+ const char *guid_mode_str[GUID_TOTAL_MODES] = {
+ [GUID_IPMI] = "IPMI",
+ [GUID_RFC4122] = "RFC4122",
+ [GUID_SMBIOS] = "SMBIOS",
+ [GUID_AUTO] = "Automatic (if you see this, report a bug)",
+ [GUID_DUMP] = "Unknown (data dumped)"
+ };
+
int rc;
- rc = _ipmi_mc_get_guid(intf, &guid);
+
+ rc = _ipmi_mc_get_guid(intf, (ipmi_guid_t *)guid_data);
if (eval_ccode(rc) != 0) {
return (-1);
}
- rc = ipmi_mc_print_guid(guid);
- return rc;
+
+ printf("System GUID : ");
+
+ guid = ipmi_parse_guid(guid_data, guid_mode);
+ if (GUID_DUMP == guid.mode) {
+ size_t i;
+ for (i = 0; i < sizeof(guid_data); ++i) {
+ printf("%02X", guid_data[i]);
+ }
+ printf("\n");
+ return 0;
+ }
+
+ printf("%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x\n",
+ (int)guid.time_low,
+ (int)guid.time_mid,
+ (int)guid.time_hi_and_version,
+ guid.clock_seq_and_rsvd,
+ guid.node[0], guid.node[1], guid.node[2],
+ guid.node[3], guid.node[4], guid.node[5]);
+
+ if (GUID_AUTO == guid_mode) {
+ /* ipmi_parse_guid() returns only valid modes in guid.ver */
+ printf("GUID Encoding : %s", guid_mode_str[guid.mode]);
+ if (GUID_IPMI != guid.mode) {
+ printf(" (WARNING: IPMI Specification violation!)");
+ }
+ printf("\n");
+ }
+
+ printf("GUID Version : %s", guid_ver_str[guid.ver]);
+
+ switch (guid.ver) {
+ case GUID_VERSION_UNKNOWN:
+ printf(" (%d)\n", GUID_VERSION((int)guid.time_hi_and_version));
+ break;
+ case GUID_VERSION_TIME:
+ printf("\nTimestamp : %s\n", ipmi_timestamp_numeric(guid.time));
+ break;
+ default:
+ printf("\n");
+ }
+
+ return 0;
}
/* ipmi_mc_get_selftest - returns and print selftest results
@@ -559,7 +807,7 @@ static int ipmi_mc_get_selftest(struct ipmi_intf * intf)
if (rsp->ccode) {
lprintf(LOG_ERR, "Bad response: (%s)",
- val2str(rsp->ccode, completion_code_vals));
+ CC_STRING(rsp->ccode));
return -1;
}
@@ -583,7 +831,7 @@ static int ipmi_mc_get_selftest(struct ipmi_intf * intf)
printf(" -> SEL device not accessible\n");
}
if (sft_res->test & IPM_SELFTEST_SDR_ERROR) {
- printf(" -> SDR repository not accesible\n");
+ printf(" -> SDR repository not accessible\n");
}
if (sft_res->test & IPM_SELFTEST_FRU_ERROR) {
printf("FRU device not accessible\n");
@@ -625,6 +873,63 @@ static int ipmi_mc_get_selftest(struct ipmi_intf * intf)
return rv;
}
+struct wdt_string_s {
+ const char *get; /* The name of 'timer use' for `watchdog get` command */
+ const char *set; /* The name of 'timer use' for `watchdog set` command */
+};
+
+
+#define WDTS(g,s) &(const struct wdt_string_s){ (g), (s) }
+
+const struct wdt_string_s *wdt_use[] = {
+ WDTS("Reserved", "none"),
+ WDTS("BIOS FRB2", "frb2"),
+ WDTS("BIOS/POST", "post"),
+ WDTS("OS Load", "osload"),
+ WDTS("SMS/OS", "sms"),
+ WDTS("OEM", "oem"),
+ WDTS("Reserved", NULL),
+ WDTS("Reserved", NULL),
+ NULL
+};
+
+const struct wdt_string_s *wdt_int[] = {
+ WDTS("None", "none"),
+ WDTS("SMI", "smi"),
+ WDTS("NMI/Diagnostic", "nmi"),
+ WDTS("Messaging", "msg"),
+ WDTS("Reserved", NULL),
+ WDTS("Reserved", NULL),
+ WDTS("Reserved", NULL),
+ WDTS("Reserved", NULL),
+ NULL
+};
+
+const struct wdt_string_s *wdt_action[] = {
+ WDTS("No action", "none"),
+ WDTS("Hard Reset", "reset"),
+ WDTS("Power Down", "poweroff"),
+ WDTS("Power Cycle", "cycle"),
+ WDTS("Reserved", NULL),
+ WDTS("Reserved", NULL),
+ WDTS("Reserved", NULL),
+ WDTS("Reserved", NULL),
+ NULL
+};
+
+int find_set_wdt_string(const struct wdt_string_s *w[], const char *s)
+{
+ int val = 0;
+ while (w[val]) {
+ if (!strcmp(s, w[val]->set)) break;
+ ++val;
+ }
+ if (!w[val]) {
+ return -1;
+ }
+ return val;
+}
+
/* ipmi_mc_get_watchdog
*
* @intf: ipmi interface
@@ -632,35 +937,15 @@ static int ipmi_mc_get_selftest(struct ipmi_intf * intf)
* returns 0 on success
* returns -1 on error
*/
-
-const char *wdt_use_string[8] = {
- "Reserved",
- "BIOS FRB2",
- "BIOS/POST",
- "OS Load",
- "SMS/OS",
- "OEM",
- "Reserved",
- "Reserved"
-};
-
-const char *wdt_action_string[8] = {
- "No action",
- "Hard Reset",
- "Power Down",
- "Power Cycle",
- "Reserved",
- "Reserved",
- "Reserved",
- "Reserved"
-};
-
static int
ipmi_mc_get_watchdog(struct ipmi_intf * intf)
{
struct ipmi_rs * rsp;
struct ipmi_rq req;
struct ipm_get_watchdog_rsp * wdt_res;
+ double init_cnt;
+ double pres_cnt;
+ size_t i;
memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_APP;
@@ -668,35 +953,226 @@ ipmi_mc_get_watchdog(struct ipmi_intf * intf)
req.msg.data_len = 0;
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL) {
+ if (!rsp) {
lprintf(LOG_ERR, "Get Watchdog Timer command failed");
return -1;
}
if (rsp->ccode) {
lprintf(LOG_ERR, "Get Watchdog Timer command failed: %s",
- val2str(rsp->ccode, completion_code_vals));
+ CC_STRING(rsp->ccode));
return -1;
}
wdt_res = (struct ipm_get_watchdog_rsp *) rsp->data;
+ /* Convert 100ms intervals to seconds */
+ init_cnt = (double)ipmi16toh(&wdt_res->init_cnt_le) / 10.0;
+ pres_cnt = (double)ipmi16toh(&wdt_res->pres_cnt_le) / 10.0;
+
printf("Watchdog Timer Use: %s (0x%02x)\n",
- wdt_use_string[(wdt_res->timer_use & 0x07 )], wdt_res->timer_use);
+ wdt_use[IPMI_WDT_GET(wdt_res->use, USE)]->get, wdt_res->use);
printf("Watchdog Timer Is: %s\n",
- wdt_res->timer_use & 0x40 ? "Started/Running" : "Stopped");
- printf("Watchdog Timer Actions: %s (0x%02x)\n",
- wdt_action_string[(wdt_res->timer_actions&0x07)], wdt_res->timer_actions);
+ IS_WDT_BIT(wdt_res->use, USE_RUNNING)
+ ? "Started/Running"
+ : "Stopped");
+ printf("Watchdog Timer Logging: %s\n",
+ IS_WDT_BIT(wdt_res->use, USE_NOLOG)
+ ? "Off"
+ : "On");
+ printf("Watchdog Timer Action: %s (0x%02x)\n",
+ wdt_action[IPMI_WDT_GET(wdt_res->intr_action, ACTION)]->get,
+ wdt_res->intr_action);
+ printf("Pre-timeout interrupt: %s\n",
+ wdt_int[IPMI_WDT_GET(wdt_res->intr_action, INTR)]->get);
printf("Pre-timeout interval: %d seconds\n", wdt_res->pre_timeout);
- printf("Timer Expiration Flags: 0x%02x\n", wdt_res->timer_use_exp);
- printf("Initial Countdown: %i sec\n",
- ((wdt_res->initial_countdown_msb << 8) | wdt_res->initial_countdown_lsb)/10);
- printf("Present Countdown: %i sec\n",
- (((wdt_res->present_countdown_msb << 8) | wdt_res->present_countdown_lsb)) / 10);
+ printf("Timer Expiration Flags: %s(0x%02x)\n",
+ wdt_res->exp_flags ? "" : "None ",
+ wdt_res->exp_flags);
+ for (i = 0; i < sizeof(wdt_res->exp_flags) * CHAR_BIT; ++i) {
+ if (IS_SET(wdt_res->exp_flags, i)) {
+ printf(" * %s\n", wdt_use[i]->get);
+ }
+ }
+ printf("Initial Countdown: %0.1f sec\n", init_cnt);
+ printf("Present Countdown: %0.1f sec\n", pres_cnt);
return 0;
}
+/* Configuration to set with ipmi_mc_set_watchdog() */
+typedef struct ipmi_mc_set_wdt_conf_s {
+ uint16_t timeout;
+ uint8_t pretimeout;
+ uint8_t intr;
+ uint8_t use;
+ uint8_t clear;
+ uint8_t action;
+ bool nolog;
+ bool dontstop;
+} wdt_conf_t;
+
+/* Options parser for ipmi_mc_set_watchdog() */
+static bool
+parse_set_wdt_options(wdt_conf_t *conf, int argc, char *argv[])
+{
+ const int MAX_TIMEOUT = 6553; /* Seconds, makes almost USHRT_MAX when
+ converted to 100ms intervals */
+ const int MAX_PRETIMEOUT = 255; /* Seconds */
+ bool error = true;
+ int i;
+
+ if (!argc || !strcmp(argv[0], "help")) {
+ goto out;
+ }
+
+ for (i = 0; i < argc; ++i) {
+ long val;
+ char *vstr = strchr(argv[i], '=');
+ if (vstr)
+ vstr++; /* Point to the value */
+
+ switch (argv[i][0]) { /* only check the first letter to allow for
+ shortcuts */
+ case 't': /* timeout */
+ val = strtol(vstr, NULL, 10);
+ if (val < 1 || val > MAX_TIMEOUT) {
+ lprintf(LOG_ERR, "Timeout value %lu is out of range (1-%d)\n",
+ val, MAX_TIMEOUT);
+ goto out;
+ }
+ conf->timeout = val * 10; /* Convert seconds to 100ms intervals */
+ break;
+ case 'p': /* pretimeout */
+ val = strtol(vstr, NULL, 10);
+ if (val < 1 || val > MAX_PRETIMEOUT) {
+ lprintf(LOG_ERR,
+ "Pretimeout value %lu is out of range (1-%d)\n",
+ val, MAX_PRETIMEOUT);
+ goto out;
+ }
+ conf->pretimeout = val; /* Convert seconds to 100ms intervals */
+ break;
+ case 'i': /* int */
+ if (0 > (val = find_set_wdt_string(wdt_int, vstr))) {
+ lprintf(LOG_ERR, "Interrupt type '%s' is not valid\n", vstr);
+ goto out;
+ }
+ conf->intr = val;
+ break;
+ case 'u': /* use */
+ if (0 > (val = find_set_wdt_string(wdt_use, vstr))) {
+ lprintf(LOG_ERR, "Use '%s' is not valid\n", vstr);
+ goto out;
+ }
+ conf->use = val;
+ break;
+ case 'a': /* action */
+ if (0 > (val = find_set_wdt_string(wdt_action, vstr))) {
+ lprintf(LOG_ERR, "Use '%s' is not valid\n", vstr);
+ goto out;
+ }
+ conf->action = val;
+ break;
+ case 'c': /* clear */
+ if (0 > (val = find_set_wdt_string(wdt_use, vstr))) {
+ lprintf(LOG_ERR, "Use '%s' is not valid\n", vstr);
+ goto out;
+ }
+ conf->clear |= 1 << val;
+ break;
+ case 'n': /* nolog */
+ conf->nolog = true;
+ break;
+ case 'd': /* dontstop */
+ conf->dontstop = true;
+ break;
+
+ default:
+ lprintf(LOG_ERR, "Invalid option '%s'", argv[i]);
+ break;
+ }
+ }
+
+ error = false;
+
+out:
+ return error;
+}
+
+/* ipmi_mc_set_watchdog
+ *
+ * @intf: ipmi interface
+ * @argc: argument count
+ * @argv: arguments
+ *
+ * returns 0 on success
+ * returns non-zero (-1 or IPMI completion code) on error
+ */
+static int
+ipmi_mc_set_watchdog(struct ipmi_intf * intf, int argc, char *argv[])
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req = {0};
+ unsigned char msg_data[6] = {0};
+ int rc = -1;
+ wdt_conf_t conf = {0};
+ bool options_error = parse_set_wdt_options(&conf, argc, argv);
+
+ /* Fill data bytes according to IPMI 2.0 Spec section 27.6 */
+ msg_data[0] = conf.nolog << IPMI_WDT_USE_NOLOG_SHIFT;
+ msg_data[0] |= conf.dontstop << IPMI_WDT_USE_DONTSTOP_SHIFT;
+ msg_data[0] |= conf.use & IPMI_WDT_USE_MASK;
+
+ msg_data[1] = (conf.intr & IPMI_WDT_INTR_MASK) << IPMI_WDT_INTR_SHIFT;
+ msg_data[1] |= conf.action & IPMI_WDT_ACTION_MASK;
+
+ msg_data[2] = conf.pretimeout;
+
+ msg_data[3] = conf.clear;
+
+ htoipmi16(conf.timeout, &msg_data[4]);
+
+ req.msg.netfn = IPMI_NETFN_APP;
+ req.msg.cmd = BMC_SET_WATCHDOG_TIMER;
+ req.msg.data_len = 6;
+ req.msg.data = msg_data;
+
+ lprintf(LOG_INFO,
+ "Sending Set Watchdog command [%02X %02X %02X %02X %02X %02X]:"
+ , msg_data[0], msg_data[1], msg_data[2]
+ , msg_data[3], msg_data[4], msg_data[5]
+ );
+ lprintf(LOG_INFO, " - nolog = %d", conf.nolog);
+ lprintf(LOG_INFO, " - dontstop = %d", conf.dontstop);
+ lprintf(LOG_INFO, " - use = 0x%02hhX", conf.use);
+ lprintf(LOG_INFO, " - intr = 0x%02hhX", conf.intr);
+ lprintf(LOG_INFO, " - action = 0x%02hhX", conf.action);
+ lprintf(LOG_INFO, " - pretimeout = %hhu", conf.pretimeout);
+ lprintf(LOG_INFO, " - clear = 0x%02hhX", conf.clear);
+ lprintf(LOG_INFO, " - timeout = %hu", conf.timeout);
+
+ rsp = intf->sendrecv(intf, &req);
+ if (!rsp) {
+ lprintf(LOG_ERR, "Set Watchdog Timer command failed");
+ goto out;
+ }
+
+ rc = rsp->ccode;
+ if (rc) {
+ lprintf(LOG_ERR, "Set Watchdog Timer command failed: %s",
+ CC_STRING(rsp->ccode));
+ goto out;
+ }
+
+ lprintf(LOG_NOTICE, "Watchdog Timer was successfully configured");
+
+out:
+ if (options_error) print_watchdog_usage();
+
+ return rc;
+}
+
/* ipmi_mc_shutoff_watchdog
*
* @intf: ipmi interface
@@ -737,14 +1213,14 @@ ipmi_mc_shutoff_watchdog(struct ipmi_intf * intf)
msg_data[5] = 0x0b; /* countdown msb - 5 mins */
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL) {
+ if (!rsp) {
lprintf(LOG_ERR, "Watchdog Timer Shutoff command failed!");
return -1;
}
if (rsp->ccode) {
lprintf(LOG_ERR, "Watchdog Timer Shutoff command failed! %s",
- val2str(rsp->ccode, completion_code_vals));
+ CC_STRING(rsp->ccode));
return -1;
}
@@ -772,16 +1248,16 @@ ipmi_mc_rst_watchdog(struct ipmi_intf * intf)
req.msg.data_len = 0;
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL) {
+ if (!rsp) {
lprintf(LOG_ERR, "Reset Watchdog Timer command failed!");
return -1;
}
if (rsp->ccode) {
lprintf(LOG_ERR, "Reset Watchdog Timer command failed: %s",
- (rsp->ccode == IPM_WATCHDOG_RESET_ERROR) ?
- "Attempt to reset uninitialized watchdog" :
- val2str(rsp->ccode, completion_code_vals));
+ (rsp->ccode == IPM_WATCHDOG_RESET_ERROR)
+ ? "Attempt to reset uninitialized watchdog"
+ : CC_STRING(rsp->ccode));
return -1;
}
@@ -808,24 +1284,24 @@ ipmi_mc_main(struct ipmi_intf * intf, int argc, char ** argv)
printf_mc_usage();
rc = (-1);
}
- else if (strncmp(argv[0], "help", 4) == 0) {
+ else if (!strcmp(argv[0], "help")) {
printf_mc_usage();
rc = 0;
}
- else if (strncmp(argv[0], "reset", 5) == 0) {
+ else if (!strcmp(argv[0], "reset")) {
if (argc < 2) {
lprintf(LOG_ERR, "Not enough parameters given.");
printf_mc_reset_usage();
rc = (-1);
}
- else if (strncmp(argv[1], "help", 4) == 0) {
+ else if (!strcmp(argv[1], "help")) {
printf_mc_reset_usage();
rc = 0;
}
- else if (strncmp(argv[1], "cold", 4) == 0) {
+ else if (!strcmp(argv[1], "cold")) {
rc = ipmi_mc_reset(intf, BMC_COLD_RESET);
}
- else if (strncmp(argv[1], "warm", 4) == 0) {
+ else if (!strcmp(argv[1], "warm")) {
rc = ipmi_mc_reset(intf, BMC_WARM_RESET);
}
else {
@@ -834,38 +1310,68 @@ ipmi_mc_main(struct ipmi_intf * intf, int argc, char ** argv)
rc = (-1);
}
}
- else if (strncmp(argv[0], "info", 4) == 0) {
+ else if (!strcmp(argv[0], "info")) {
rc = ipmi_mc_get_deviceid(intf);
}
- else if (strncmp(argv[0], "guid", 4) == 0) {
- rc = ipmi_mc_get_guid(intf);
+ else if (!strcmp(argv[0], "guid")) {
+ ipmi_guid_mode_t guid_mode = GUID_AUTO;
+
+ /* Allow for 'rfc' and 'rfc4122' */
+ if (argc > 1) {
+ if (!strcmp(argv[1], "rfc")) {
+ guid_mode = GUID_RFC4122;
+ }
+ else if (!strcmp(argv[1], "smbios")) {
+ guid_mode = GUID_SMBIOS;
+ }
+ else if (!strcmp(argv[1], "ipmi")) {
+ guid_mode = GUID_IPMI;
+ }
+ else if (!strcmp(argv[1], "auto")) {
+ guid_mode = GUID_AUTO;
+ }
+ else if (!strcmp(argv[1], "dump")) {
+ guid_mode = GUID_DUMP;
+ }
+ }
+ rc = ipmi_mc_print_guid(intf, guid_mode);
}
- else if (strncmp(argv[0], "getenables", 10) == 0) {
+ else if (!strcmp(argv[0], "getenables")) {
rc = ipmi_mc_get_enables(intf);
}
- else if (strncmp(argv[0], "setenables", 10) == 0) {
+ else if (!strcmp(argv[0], "setenables")) {
rc = ipmi_mc_set_enables(intf, argc-1, &(argv[1]));
}
- else if (!strncmp(argv[0], "selftest", 8)) {
+ else if (!strcmp(argv[0], "selftest")) {
rc = ipmi_mc_get_selftest(intf);
}
- else if (!strncmp(argv[0], "watchdog", 8)) {
+ else if (!strcmp(argv[0], "watchdog")) {
if (argc < 2) {
lprintf(LOG_ERR, "Not enough parameters given.");
print_watchdog_usage();
rc = (-1);
}
- else if (strncmp(argv[1], "help", 4) == 0) {
+ else if (!strcmp(argv[1], "help")) {
print_watchdog_usage();
rc = 0;
}
- else if (strncmp(argv[1], "get", 3) == 0) {
+ else if (!strcmp(argv[1], "set")) {
+ if (argc < 3) { /* Requires options */
+ lprintf(LOG_ERR, "Not enough parameters given.");
+ print_watchdog_usage();
+ rc = (-1);
+ }
+ else {
+ rc = ipmi_mc_set_watchdog(intf, argc - 2, &(argv[2]));
+ }
+ }
+ else if (!strcmp(argv[1], "get")) {
rc = ipmi_mc_get_watchdog(intf);
}
- else if(strncmp(argv[1], "off", 3) == 0) {
+ else if (!strcmp(argv[1], "off")) {
rc = ipmi_mc_shutoff_watchdog(intf);
}
- else if(strncmp(argv[1], "reset", 5) == 0) {
+ else if (!strcmp(argv[1], "reset")) {
rc = ipmi_mc_rst_watchdog(intf);
}
else {
@@ -874,10 +1380,10 @@ ipmi_mc_main(struct ipmi_intf * intf, int argc, char ** argv)
rc = (-1);
}
}
- else if (strncmp(argv[0], "getsysinfo", 10) == 0) {
+ else if (!strcmp(argv[0], "getsysinfo")) {
rc = ipmi_sysinfo_main(intf, argc, argv, 0);
}
- else if (strncmp(argv[0], "setsysinfo", 10) == 0) {
+ else if (!strcmp(argv[0], "setsysinfo")) {
rc = ipmi_sysinfo_main(intf, argc, argv, 1);
}
else {
@@ -969,10 +1475,10 @@ ipmi_mc_getsysinfo(struct ipmi_intf * intf, int param, int block, int set,
* u8 data0[14]
*/
rsp = intf->sendrecv(intf, &req);
- if (rsp == NULL)
+ if (!rsp)
return (-1);
- if (rsp->ccode == 0) {
+ if (!rsp->ccode) {
if (len > rsp->data_len)
len = rsp->data_len;
if (len && buffer)
@@ -1011,7 +1517,7 @@ ipmi_mc_setsysinfo(struct ipmi_intf * intf, int len, void *buffer)
* u8 data1[16]
*/
rsp = intf->sendrecv(intf, &req);
- if (rsp != NULL) {
+ if (rsp) {
return rsp->ccode;
}
return -1;
@@ -1022,10 +1528,10 @@ ipmi_sysinfo_main(struct ipmi_intf *intf, int argc, char ** argv, int is_set)
{
char *str;
unsigned char infostr[256];
- unsigned char paramdata[18];
+ char paramdata[18];
int len, maxset, param, pos, rc, set;
- if (argc == 2 && strcmp(argv[1], "help") == 0) {
+ if (argc == 2 && !strcmp(argv[1], "help")) {
printf_sysinfo_usage(1);
return 0;
}
@@ -1109,7 +1615,7 @@ ipmi_sysinfo_main(struct ipmi_intf *intf, int argc, char ** argv, int is_set)
}
else if (rc > 0) {
lprintf(LOG_ERR, "%s command failed: %s", argv[0],
- val2str(rc, completion_code_vals));
+ CC_STRING(rc));
}
return rc;
}