int
ipmi_sensors_output_verbose_sensor_reading (ipmi_sensors_state_data_t *state_data,
uint8_t *sdr_record,
unsigned int sdr_record_len,
double *reading)
{
uint8_t sensor_unit;
assert(state_data);
assert(sdr_record);
assert(sdr_record_len);
if (sdr_cache_get_sensor_unit (state_data->pstate,
sdr_record,
sdr_record_len,
&sensor_unit) < 0)
return -1;
if (reading)
pstdout_printf (state_data->pstate,
"Sensor Reading: %f %s\n",
*reading,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Sensor Reading: %s\n",
"NA");
return 0;
}
ipmi_config_err_t
ipmi_config_diff (ipmi_config_state_data_t *state_data)
{
struct ipmi_config_section *s;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret = IPMI_CONFIG_ERR_SUCCESS;
ipmi_config_err_t this_ret;
assert (state_data);
s = state_data->sections;
while (s)
{
struct ipmi_config_keyvalue *kv = s->keyvalues;
while (kv)
{
assert (kv->value_input);
if ((this_ret = kv->key->checkout (state_data,
s->section_name,
kv)) == IPMI_CONFIG_ERR_FATAL_ERROR)
goto cleanup;
if (this_ret == IPMI_CONFIG_ERR_SUCCESS)
{
if (!same (kv->value_input, kv->value_output))
pstdout_printf (state_data->pstate,
"%s:%s - input=`%s':actual=`%s'\n",
s->section_name,
kv->key->key_name,
kv->value_input,
kv->value_output);
}
else
{
pstdout_printf (state_data->pstate,
"\t## ERROR: Unable to checkout %s:%s\n",
s->section_name,
kv->key->key_name);
ret = this_ret;
}
kv = kv->next;
}
s = s->next;
}
rv = ret;
cleanup:
return (rv);
}
static int
_ipmimonitoring_legacy_simple_output_compact_record (ipmi_sensors_state_data_t *state_data,
uint16_t record_id,
int event_message_output_type,
uint16_t sensor_event_bitmask,
char **event_message_list,
unsigned int event_message_list_len)
{
assert (state_data);
assert (IPMI_SENSORS_EVENT_VALID (event_message_output_type));
if (_ipmimonitoring_legacy_simple_output_header (state_data, record_id) < 0)
return (-1);
if (state_data->prog_data->args->output_sensor_state)
{
char *sensor_state_str = NULL;
if (ipmi_sensors_get_sensor_state (state_data,
event_message_output_type,
sensor_event_bitmask,
&sensor_state_str) < 0)
return (-1);
pstdout_printf (state_data->pstate,
" | %s",
sensor_state_str);
}
if (state_data->prog_data->args->quiet_readings)
return (0);
pstdout_printf (state_data->pstate,
" | %s | ",
IPMIMONITORING_NA_STRING_LEGACY);
if (ipmi_sensors_output_event_message_list (state_data,
event_message_output_type,
sensor_event_bitmask,
event_message_list,
event_message_list_len,
NULL,
0) < 0)
return (-1);
return (0);
}
int
ipmi_oem_fujitsu_get_power_off_source (ipmi_oem_state_data_t *state_data)
{
uint8_t source = 0;
char str[IPMI_OEM_STR_BUFLEN];
int rv = -1;
assert (state_data);
assert (!state_data->prog_data->args->oem_options_count);
if (_ipmi_oem_get_power_source (state_data,
IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_GET_POWER_OFF_SOURCE,
&source) < 0)
goto cleanup;
memset (str, '\0', IPMI_OEM_STR_BUFLEN);
switch (source)
{
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_SOFTWARE:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Software or command");
break;
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_POWER_SWITCH:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Power switch");
break;
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_AC_POWER_FAIL:
snprintf (str, IPMI_OEM_STR_BUFLEN, "AC power fail");
break;
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_CLOCK_OR_TIMER:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Clock or timer");
break;
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_FAN_FAILURE:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Fan failure");
break;
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_CRITICAL_TEMPERATURE:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Critical temperature");
break;
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_FINAL_POWER_OFF_AFTER_REPEATED_WATCHDOG_TIMEOUTS:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Final power-off after repeated watchdog timeouts");
break;
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_FINAL_POWER_OFF_AFTER_REPEATED_CPU_ERRORS:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Final power-off after repeated CPU errors");
break;
case IPMI_OEM_FUJITSU_POWER_OFF_SOURCE_POWERED_OFF_BY_REMOTE_CONTROL_VIA_REMOTE_MANAGER:
/* HLiebig: capitalized "remote manager" from doc */
snprintf (str, IPMI_OEM_STR_BUFLEN, "Powered off by remote control via Remote Manager");
break;
default:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Unrecognized source: %02Xh", source);
}
pstdout_printf (state_data->pstate,
"%s\n",
str);
rv = 0;
cleanup:
return (rv);
}
static int
_ipmimonitoring_legacy_simple_output_header (ipmi_sensors_state_data_t *state_data,
uint16_t record_id)
{
char id_string[IPMI_SDR_MAX_ID_STRING_LENGTH + 1];
uint8_t sensor_type;
uint8_t event_reading_type_code;
const char * sensor_type_string = NULL;
assert (state_data);
memset (id_string, '\0', IPMI_SDR_MAX_ID_STRING_LENGTH + 1);
if (ipmi_sdr_parse_id_string (state_data->sdr_ctx,
NULL,
0,
id_string,
IPMI_SDR_MAX_ID_STRING_LENGTH) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_id_string: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
if (ipmi_sdr_parse_sensor_type (state_data->sdr_ctx,
NULL,
0,
&sensor_type) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_sensor_type: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
if ((state_data->prog_data->args->interpret_oem_data)
&& (ipmi_sdr_parse_event_reading_type_code (state_data->sdr_ctx,
NULL,
0,
&event_reading_type_code) >= 0))
sensor_type_string = get_oem_sensor_type_output_string (sensor_type,
event_reading_type_code,
state_data->oem_data.manufacturer_id,
state_data->oem_data.product_id);
else
sensor_type_string = get_sensor_type_output_string (sensor_type);
pstdout_printf (state_data->pstate,
"%u | %s | %s",
record_id,
id_string,
sensor_type_string);
return (0);
}
static ipmi_config_err_t
front_panel_buttons_checkout (ipmi_config_state_data_t *state_data,
const char *section_name,
struct ipmi_config_keyvalue *kv)
{
struct front_panel_buttons data;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t enabled = 0;
char *enabled_str = NULL;
assert (state_data);
assert (section_name);
assert (kv);
memset (&data, '\0', sizeof (struct front_panel_buttons));
if ((ret = _get_front_panel_buttons (state_data, &data)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (!strcasecmp (kv->key->key_name, "Enable_Standby_Button_For_Entering_Standby"))
enabled = data.standby;
else if (!strcasecmp (kv->key->key_name, "Enable_Diagnostic_Interrupt_Button"))
enabled = data.diagnostic_interrupt;
else if (!strcasecmp (kv->key->key_name, "Enable_Reset_Button"))
enabled = data.reset;
else if (!strcasecmp (kv->key->key_name, "Enable_Power_Off_Button_For_Power_Off_Only"))
enabled = data.power_off;
else
{
if (state_data->prog_data->args->verbose_count)
pstdout_printf (state_data->pstate,
"## Unrecognized section:key_name: %s:%s\n",
section_name,
kv->key->key_name);
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
if (enabled == BUTTON_ENABLED)
enabled_str = "Yes";
else if (enabled == BUTTON_DISABLED)
enabled_str = "No";
else
enabled_str = "";
if (ipmi_config_section_update_keyvalue_output (state_data,
kv,
enabled_str) < 0)
return (IPMI_CONFIG_ERR_FATAL_ERROR);
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
return (rv);
}
static void
_ipmi_sensors_oem_intel_output_oem_record_fan_control_profile_support (ipmi_sensors_state_data_t *state_data,
uint8_t fan_control_profile_support,
unsigned int fan_control_profile_number)
{
assert (state_data);
assert (state_data->prog_data->args->verbose_count >= 2);
assert (state_data->prog_data->args->interpret_oem_data);
assert (state_data->oem_data.manufacturer_id == IPMI_IANA_ENTERPRISE_ID_INTEL);
pstdout_printf (state_data->pstate,
"Fan Control Profile %u Support: %s\n",
fan_control_profile_number,
fan_control_profile_support == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_VALID ? "Yes" : "No");
}
int
ipmi_sensors_output_event_message_list (ipmi_sensors_state_data_t *state_data,
char **event_message_list,
unsigned int event_message_list_len,
char *prefix,
unsigned int each_on_newline)
{
char spcbuf[IPMI_SENSORS_SPACE_BUFFER + 1];
int i;
assert(state_data);
if (prefix)
pstdout_printf (state_data->pstate, "%s", prefix);
memset(spcbuf, '\0', IPMI_SENSORS_SPACE_BUFFER + 1);
if (prefix && each_on_newline)
{
unsigned int len;
len = strlen(prefix);
if (len > IPMI_SENSORS_SPACE_BUFFER)
len = IPMI_SENSORS_SPACE_BUFFER;
for (i = 0; i < len; i++)
strcat(spcbuf, " ");
}
if (event_message_list)
{
if (event_message_list_len >= 1)
pstdout_printf (state_data->pstate,
"[%s]",
event_message_list[0]);
for (i = 1; i < event_message_list_len; i++)
{
if (each_on_newline)
pstdout_printf (state_data->pstate,
"\n");
pstdout_printf (state_data->pstate,
"%s[%s]",
spcbuf,
event_message_list[i]);
}
pstdout_printf (state_data->pstate,
"\n");
}
else
pstdout_printf (state_data->pstate,
"[%s]\n",
"Unknown");
return 0;
}
static int
_sun_get_led_sdr_callback (ipmi_sdr_ctx_t sdr_ctx,
uint8_t record_type,
const void *sdr_record,
unsigned int sdr_record_len,
void *arg)
{
struct ipmi_oem_sun_get_led_sdr_callback *sdr_callback_arg;
ipmi_oem_state_data_t *state_data;
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
int rs_len;
uint16_t record_id;
char fmt[IPMI_OEM_FMT_BUFLEN + 1];
char device_id_string[IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH + 1];
char sensor_name_buf[IPMI_SDR_MAX_SENSOR_NAME_LENGTH + 1];
char *sensor_name = NULL;
uint8_t entity_instance_type;
uint8_t led_mode;
char *led_mode_str = NULL;
assert (sdr_ctx);
assert (sdr_record);
assert (sdr_record_len);
assert (arg);
sdr_callback_arg = (struct ipmi_oem_sun_get_led_sdr_callback *)arg;
state_data = sdr_callback_arg->state_data;
/* Sun OEM
*
* From Ipmitool (http://ipmitool.sourceforge.net/)
*
* Get Led Request
*
* 0x2E - OEM network function (is IPMI_NET_FN_OEM_GROUP_RQ)
* 0x21 - OEM cmd
* 0x?? - Device Slave Address (in General Device Locator Record)
* - Note that the IPMI command requires the entire
* byte of the slave address.
* 0x?? - LED Type (see below [1])
* - 0 - ok2rm
* - 1 - service
* - 2 - activity
* - 3 - locate
* 0x?? - Controller Address / Device Access Address (in General Device Locator Record)
* - 0x20 if the LED is local
* - Note that the IPMI command requires the entire
* byte of the access address.
* 0x?? - HW Info (OEM field in General Device Locator Record)
* 0x?? - Force
* - 0 - Go thru controller
* - 1 - Directly access device
*
* An alternate format is described in the ipmitool comments for Sun
* Blade Moduler Systems.
*
* 0x2E - OEM network function (is IPMI_NET_FN_OEM_GROUP_RQ)
* 0x21 - OEM cmd
* 0x?? - Device Slave Address (in General Device Locator Record)
* 0x?? - LED Type
* 0x?? - Controller Address / Device Access Address (in General Device Locator Record)
* 0x?? - HW Info (OEM field in General Device Locator Record)
* 0x?? - Entity ID
* 0x?? - Entity Instance
* - 7 bit version
* 0x?? - Force
* - 0 - Go thru controller
* - 1 - Directly access device
*
* Get Led Response
*
* 0x21 - OEM cmd
* 0x?? - Completion Code
* 0x?? - LED mode
*
* achu notes:
*
* [1] - As far as I can tell, the LED type field is useless. My
* assumption is that on older Sun systems, or other motherboards I
* don't have access to, one can specify an LED type, which allows
* you to enable/disable a particular LED amongst many. On my Sun
* Fire 4140, it appears to do nothing and affect nothing. I will
* add in a new option later if it becomes necessary for the user to
* specify an LED type. In the meantime, I will copy the code use
* in ipmitool and set this field to the OEM field.
*/
if (record_type != IPMI_SDR_FORMAT_GENERIC_DEVICE_LOCATOR_RECORD)
return (0);
if (ipmi_sdr_parse_entity_id_instance_type (state_data->sdr_ctx,
sdr_record,
sdr_record_len,
NULL,
NULL,
&entity_instance_type) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_entity_id_and_instance: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
/* if it isn't a physical instance, don't continue on */
if (entity_instance_type == IPMI_SDR_LOGICAL_CONTAINER_ENTITY)
return (0);
if (ipmi_sdr_parse_record_id_and_type (state_data->sdr_ctx,
sdr_record,
sdr_record_len,
&record_id,
NULL) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_record_id_and_type: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
/* achu: the sun oem commands want the full byte, not just the
* sub-field, so use indexes instead of sdr-parse lib.
*/
bytes_rq[0] = IPMI_CMD_OEM_SUN_GET_LED;
bytes_rq[1] = ((uint8_t *)sdr_record)[IPMI_SDR_RECORD_GENERIC_DEVICE_LOCATOR_DEVICE_SLAVE_ADDRESS_INDEX];
bytes_rq[2] = ((uint8_t *)sdr_record)[IPMI_SDR_RECORD_GENERIC_DEVICE_LOCATOR_OEM_INDEX];
bytes_rq[3] = ((uint8_t *)sdr_record)[IPMI_SDR_RECORD_GENERIC_DEVICE_LOCATOR_DEVICE_ACCESS_ADDRESS_INDEX];
bytes_rq[4] = ((uint8_t *)sdr_record)[IPMI_SDR_RECORD_GENERIC_DEVICE_LOCATOR_OEM_INDEX];
bytes_rq[5] = IPMI_OEM_SUN_LED_FORCE_GO_THRU_CONTROLLER;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_GROUP_RQ, /* network function */
bytes_rq, /* data */
6, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
return (-1);
}
/* achu: there are probably 1 or 2 completion codes that are
* acceptable to ignore and continue on, but who knows what they
* are.
*/
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
3,
IPMI_CMD_OEM_SUN_GET_LED,
IPMI_NET_FN_OEM_GROUP_RS,
NULL) < 0)
return (-1);
if (!sdr_callback_arg->header_output_flag)
{
memset (fmt, '\0', IPMI_OEM_FMT_BUFLEN + 1);
snprintf (fmt,
IPMI_OEM_FMT_BUFLEN,
"%%-%ds | %%-%ds | LED Mode\n",
sdr_callback_arg->column_width->record_id,
sdr_callback_arg->column_width->sensor_name);
pstdout_printf (state_data->pstate,
fmt,
SENSORS_HEADER_RECORD_ID_STR,
SENSORS_HEADER_NAME_STR);
sdr_callback_arg->header_output_flag++;
}
led_mode = bytes_rs[2];
if (state_data->prog_data->args->verbose_count)
{
memset (sensor_name_buf, '\0', IPMI_SDR_MAX_SENSOR_NAME_LENGTH + 1);
if (ipmi_sdr_parse_entity_sensor_name (state_data->sdr_ctx,
NULL,
0,
0, /* sensor number */
IPMI_SDR_SENSOR_NAME_FLAGS_IGNORE_SHARED_SENSORS, /* flags */
sensor_name_buf,
IPMI_SDR_MAX_SENSOR_NAME_LENGTH) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_entity_sensor_name: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
sensor_name = sensor_name_buf;
}
else
{
memset (device_id_string, '\0', IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH + 1);
if (ipmi_sdr_parse_device_id_string (state_data->sdr_ctx,
sdr_record,
sdr_record_len,
device_id_string,
IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_device_id_string: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
sensor_name = device_id_string;
}
switch (led_mode)
{
case IPMI_OEM_SUN_LED_MODE_OFF:
led_mode_str = "Off";
break;
case IPMI_OEM_SUN_LED_MODE_ON:
led_mode_str = "On";
break;
case IPMI_OEM_SUN_LED_MODE_STANDBY:
led_mode_str = "Standby";
break;
case IPMI_OEM_SUN_LED_MODE_SLOW:
led_mode_str = "Slow";
break;
case IPMI_OEM_SUN_LED_MODE_FAST:
led_mode_str = "Fast";
break;
default:
led_mode_str = "Unknown";
}
snprintf (fmt,
IPMI_OEM_FMT_BUFLEN,
"%%-%du | %%-%ds | %s\n",
sdr_callback_arg->column_width->record_id,
sdr_callback_arg->column_width->sensor_name,
led_mode_str);
pstdout_printf (state_data->pstate,
fmt,
record_id,
sensor_name);
return (0);
}
int
ipmi_oem_fujitsu_get_identify_led (ipmi_oem_state_data_t *state_data)
{
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
uint8_t state;
int rs_len;
int rv = -1;
assert (state_data);
assert (!state_data->prog_data->args->oem_options_count);
/* Fujitsu OEM
*
* http://manuals.ts.fujitsu.com/file/4390/irmc_s2-en.pdf
*
* Request
*
* 0x2E - OEM network function
* 0xF5 - OEM cmd
* 0x?? - Fujitsu IANA (LSB first)
* 0x?? - Fujitsu IANA
* 0x?? - Fujitsu IANA
* 0xB1 - Command Specifier
*
* Response
*
* 0xF5 - OEM cmd
* 0x?? - Completion code
* 0x?? - Fujitsu IANA (LSB first)
* 0x?? - Fujitsu IANA
* 0x?? - Fujitsu IANA
* 0x?? - led on/off state (0 == off, 1 == on)
*/
bytes_rq[0] = IPMI_CMD_OEM_FUJITSU_SYSTEM;
bytes_rq[1] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x0000FF);
bytes_rq[2] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x00FF00) >> 8;
bytes_rq[3] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0xFF0000) >> 16;
bytes_rq[4] = IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_GET_IDENTIFY_LED;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_GROUP_RQ, /* network function */
bytes_rq, /* data */
5, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
6,
IPMI_CMD_OEM_FUJITSU_SYSTEM,
IPMI_NET_FN_OEM_GROUP_RS,
NULL) < 0)
goto cleanup;
state = (bytes_rs[5] & IPMI_OEM_FUJITSU_IDENTIFY_LED_BITMASK);
state >>= IPMI_OEM_FUJITSU_IDENTIFY_LED_SHIFT;
if (state == IPMI_OEM_FUJITSU_IDENTIFY_LED_ON)
pstdout_printf (state_data->pstate, "on\n");
else
pstdout_printf (state_data->pstate, "off\n");
rv = 0;
cleanup:
return (rv);
}
int
ipmi_oem_fujitsu_get_eeprom_version_info (ipmi_oem_state_data_t *state_data)
{
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
int rs_len;
uint8_t eeprom_number;
uint8_t status;
uint8_t major_firmware_revision;
uint8_t minor_firmware_revision;
uint8_t aux_firmware_revision_major;
uint8_t aux_firmware_revision_minor;
uint8_t aux_firmware_revision_res;
char major_firmware_revision_char;
uint8_t major_sdrr_revision;
uint8_t minor_sdrr_revision;
char major_sdrr_revision_char;
uint16_t sdrr_id;
uint8_t major_booter_revision;
uint8_t minor_booter_revision;
uint8_t aux_booter_revision_major;
uint8_t aux_booter_revision_minor;
long tmp;
char *endptr;
int rv = -1;
assert (state_data);
assert (state_data->prog_data->args->oem_options_count == 1);
errno = 0;
tmp = strtol (state_data->prog_data->args->oem_options[0],
&endptr,
0);
if (errno
|| endptr[0] != '\0'
|| tmp < 0
|| tmp > UCHAR_MAX)
{
pstdout_fprintf (state_data->pstate,
stderr,
"%s:%s invalid OEM option argument '%s'\n",
state_data->prog_data->args->oem_id,
state_data->prog_data->args->oem_command,
state_data->prog_data->args->oem_options[0]);
goto cleanup;
}
if (!(tmp >= IPMI_OEM_FUJITSU_EEPROM_NUMBER_MIN
&& tmp <= IPMI_OEM_FUJITSU_EEPROM_NUMBER_MAX))
{
pstdout_fprintf (state_data->pstate,
stderr,
"%s:%s invalid OEM option argument '%s' : out of range\n",
state_data->prog_data->args->oem_id,
state_data->prog_data->args->oem_command,
state_data->prog_data->args->oem_options[0]);
goto cleanup;
}
eeprom_number = tmp;
/* Fujitsu OEM
*
* http://manuals.ts.fujitsu.com/file/4390/irmc_s2-en.pdf
*
* Request
*
* 0x2E - OEM network function
* 0xF5 - OEM cmd
* 0x?? - Fujitsu IANA (LSB first)
* 0x?? - Fujitsu IANA
* 0x?? - Fujitsu IANA
* 0x12 - Command Specifier
*
* Response
*
* 0xF5 - OEM cmd
* 0x?? - Completion code
* 0x?? - Fujitsu IANA (LSB first)
* 0x?? - Fujitsu IANA
* 0x?? - Fujitsu IANA
* 0x?? - status
* 0x00 - checksum error
* 0x01 - ok
* 0x?? - major fw revision - binary coded
* 0x?? - minor fw revision - binary - 2 char field coded (HLiebig: listed incorrectly as BCD in doc)
* 0x?? - aux fw revision (lsb first) - binary coded, major/minor/res.
* 0x?? - aux fw revision
* 0x?? - aux fw revision
* 0x?? - major fw char - ascii char
* 0x?? - major sdrr revision - binary coded (HLiebig: listed incorrectly as BCD in doc)
* 0x?? - minor sdrr revision - bcd coded
* 0x?? - major sdrr char - ascii char
* 0x?? - sdrr-ID (lsb) - hex coded (HLiebig: listed incorrectly as binary in doc)
* 0x?? - sdrr-ID (msb) - hex coded (HLiebig: listed incorrectly as binary in doc)
* 0x?? - major booter revision - binary coded
* 0x?? - minor booter revision - binary - 2 char field coded (HLiebig: listed incorrectly as BCD in doc)
* 0x?? - aux booter revision (lsb first) - binary coded, major/minor
* 0x?? - aux booter revision
*/
bytes_rq[0] = IPMI_CMD_OEM_FUJITSU_SYSTEM;
bytes_rq[1] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x0000FF);
bytes_rq[2] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x00FF00) >> 8;
bytes_rq[3] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0xFF0000) >> 16;
bytes_rq[4] = IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_GET_EEPROM_VERSION_INFO;
bytes_rq[5] = eeprom_number;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_GROUP_RQ, /* network function */
bytes_rq, /* data */
6, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
21,
IPMI_CMD_OEM_FUJITSU_SYSTEM,
IPMI_NET_FN_OEM_GROUP_RS,
NULL) < 0)
goto cleanup;
status = bytes_rs[5];
if (status != IPMI_OEM_FUJITSU_EEPROM_CHECKSUM_OK)
{
pstdout_fprintf (state_data->pstate,
stderr,
"Check Error Runtime\n");
goto cleanup;
}
major_firmware_revision = bytes_rs[6];
minor_firmware_revision = bytes_rs[7];
aux_firmware_revision_major = bytes_rs[8];
aux_firmware_revision_minor = bytes_rs[9];
aux_firmware_revision_res = bytes_rs[10];
major_firmware_revision_char = (char)bytes_rs[11];
major_sdrr_revision = bytes_rs[12];
minor_sdrr_revision = bytes_rs[13];
major_sdrr_revision_char = (char)bytes_rs[14];
sdrr_id = bytes_rs[15];
sdrr_id |= (bytes_rs[16] << 8);
major_booter_revision = bytes_rs[17];
minor_booter_revision = bytes_rs[18];
aux_booter_revision_major = bytes_rs[19];
aux_booter_revision_minor = bytes_rs[20];
/* make sure char is atleast legit */
/* HLiebig: minor_firmware_revision listed incorrectly as BCD in doc */
if (isalnum(major_firmware_revision_char))
pstdout_printf (state_data->pstate,
"Firmware Revision : %u.%02u%c (%u.%02u)\n",
aux_firmware_revision_major,
aux_firmware_revision_minor,
major_firmware_revision_char,
major_firmware_revision,
minor_firmware_revision);
else
pstdout_printf (state_data->pstate,
"Firmware Revision : %u.%02u (%u.%02u)\n",
aux_firmware_revision_major,
aux_firmware_revision_minor,
major_firmware_revision,
minor_firmware_revision);
/* HLiebig: major_sdrr_revision listed incorrectly as BCD in doc */
if (isalnum (major_sdrr_revision_char))
pstdout_printf (state_data->pstate,
"SDRR Revision : %u.%02X%c\n",
major_sdrr_revision,
minor_sdrr_revision,
major_sdrr_revision_char);
else
pstdout_printf (state_data->pstate,
"SDRR Revision : %u.%02X\n",
major_sdrr_revision,
minor_sdrr_revision);
/* HLiebig: sdrr_id listed incorrectly as binary in doc */
pstdout_printf (state_data->pstate,
"SDRR ID : %X\n",
sdrr_id);
/* HLiebig: minor_booter_revision listed incorrectly as BCD in doc */
pstdout_printf (state_data->pstate,
"Booter Revision : %u.%02u (%u.%02u)\n",
aux_booter_revision_major,
aux_booter_revision_minor,
major_booter_revision,
minor_booter_revision);
rv = 0;
cleanup:
return (rv);
}
int
ipmi_oem_supermicro_extra_firmware_info (ipmi_oem_state_data_t *state_data)
{
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
uint32_t firmware_major_version;
uint32_t firmware_minor_version;
uint32_t firmware_sub_version;
uint32_t firmware_build_number;
uint8_t firmware_hardware_id;
char firmware_tag[IPMI_OEM_SUPERMICRO_STRING_MAX+1];
int rs_len;
int rv = -1;
assert (state_data);
assert (!state_data->prog_data->args->oem_options_count);
memset (firmware_tag, '\0', IPMI_OEM_SUPERMICRO_STRING_MAX + 1);
/* Supermicro OEM
*
* From post by ipmitool developer.
*
* http://sourceforge.net/mailarchive/message.php?msg_name=49ABCCC3.4040004%40cern.ch
*
* Request
*
* 0x3C - OEM network function
* 0x20 - OEM cmd
*
* Response
* 0x20 - OEM cmd
* 0x?? - Completion Code
* 4 bytes - firmware major version (LSB first)
* 4 bytes - firmware minor version (LSB first)
* 4 bytes - firmware sub version (LSB first)
* 4 bytes - firmware build number (LSB first)
* 1 byte - hardware ID
* ? bytes - firmware tag, null terminated string
*/
bytes_rq[0] = IPMI_CMD_OEM_SUPERMICRO_EXTRA_FIRMWARE_INFO;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_SUPERMICRO_PEPPERCON_RQ, /* network function */
bytes_rq, /* data */
1, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
19,
IPMI_CMD_OEM_SUPERMICRO_EXTRA_FIRMWARE_INFO,
IPMI_NET_FN_OEM_SUPERMICRO_PEPPERCON_RS,
NULL) < 0)
goto cleanup;
firmware_major_version = bytes_rs[2];
firmware_major_version |= (bytes_rs[3] << 8);
firmware_major_version |= (bytes_rs[4] << 16);
firmware_major_version |= (bytes_rs[5] << 24);
firmware_minor_version = bytes_rs[6];
firmware_minor_version |= (bytes_rs[7] << 8);
firmware_minor_version |= (bytes_rs[8] << 16);
firmware_minor_version |= (bytes_rs[9] << 24);
firmware_sub_version = bytes_rs[10];
firmware_sub_version |= (bytes_rs[11] << 8);
firmware_sub_version |= (bytes_rs[12] << 16);
firmware_sub_version |= (bytes_rs[13] << 24);
firmware_build_number = bytes_rs[14];
firmware_build_number |= (bytes_rs[15] << 8);
firmware_build_number |= (bytes_rs[16] << 16);
firmware_build_number |= (bytes_rs[17] << 24);
firmware_hardware_id = bytes_rs[18];
if (rs_len > 19)
memcpy (firmware_tag, &bytes_rs[19], rs_len - 19);
/* assume minor version is BCD, just like in Get Device ID command */
/* assume sub version is also BCD */
pstdout_printf (state_data->pstate,
"Firmware Version : %u.%02x.%02x\n",
firmware_major_version,
firmware_minor_version,
firmware_sub_version);
pstdout_printf (state_data->pstate,
"Firmware Build Number : %u\n",
firmware_build_number);
pstdout_printf (state_data->pstate,
"Firmware Hardware ID : %u\n",
firmware_hardware_id);
pstdout_printf (state_data->pstate,
"Firmware Tag : %s\n",
firmware_tag);
rv = 0;
cleanup:
return (rv);
}
static int
_ipmimonitoring_legacy_simple_output_full_record (ipmi_sensors_state_data_t *state_data,
uint16_t record_id,
double *sensor_reading,
int event_message_output_type,
uint16_t sensor_event_bitmask,
char **event_message_list,
unsigned int event_message_list_len)
{
int rv = -1;
assert (state_data);
assert (IPMI_SENSORS_EVENT_VALID (event_message_output_type));
if (_ipmimonitoring_legacy_simple_output_header (state_data, record_id) < 0)
goto cleanup;
if (state_data->prog_data->args->output_sensor_state)
{
char *sensor_state_str = NULL;
if (ipmi_sensors_get_sensor_state (state_data,
event_message_output_type,
sensor_event_bitmask,
&sensor_state_str) < 0)
goto cleanup;
pstdout_printf (state_data->pstate,
" | %s",
sensor_state_str);
}
if (!state_data->prog_data->args->quiet_readings)
{
uint8_t event_reading_type_code;
if (ipmi_sdr_parse_event_reading_type_code (state_data->sdr_ctx,
NULL,
0,
&event_reading_type_code) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_event_reading_type_code: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
goto cleanup;
}
switch (ipmi_event_reading_type_code_class (event_reading_type_code))
{
case IPMI_EVENT_READING_TYPE_CODE_CLASS_THRESHOLD:
{
char sensor_units_buf[IPMI_SENSORS_UNITS_BUFLEN+1];
memset (sensor_units_buf, '\0', IPMI_SENSORS_UNITS_BUFLEN+1);
if (get_sensor_units_output_string (state_data->pstate,
state_data->sdr_ctx,
sensor_units_buf,
IPMI_SENSORS_UNITS_BUFLEN,
0) < 0)
goto cleanup;
if (sensor_reading)
pstdout_printf (state_data->pstate,
" | %s | %f\n",
sensor_units_buf,
*sensor_reading);
else
pstdout_printf (state_data->pstate,
" | %s | %s\n",
sensor_units_buf,
IPMIMONITORING_NA_STRING_LEGACY);
}
break;
case IPMI_EVENT_READING_TYPE_CODE_CLASS_GENERIC_DISCRETE:
case IPMI_EVENT_READING_TYPE_CODE_CLASS_SENSOR_SPECIFIC_DISCRETE:
case IPMI_EVENT_READING_TYPE_CODE_CLASS_OEM:
default:
/* sensor units */
pstdout_printf (state_data->pstate,
" | %s | ",
IPMIMONITORING_NA_STRING_LEGACY);
if (ipmi_sensors_output_event_message_list (state_data,
event_message_output_type,
sensor_event_bitmask,
event_message_list,
event_message_list_len,
NULL,
0) < 0)
goto cleanup;
break;
}
}
else
pstdout_printf (state_data->pstate,
"\n");
rv = 0;
cleanup:
return (rv);
}
static int
_sections_sdr_callback (ipmi_sdr_ctx_t sdr_ctx,
uint8_t record_type,
const void *sdr_record,
unsigned int sdr_record_len,
void *arg)
{
struct ipmi_sensors_config_sdr_callback *sdr_callback_arg;
ipmi_sensors_config_state_data_t *state_data;
struct config_section *section = NULL;
uint8_t event_reading_type_code;
int event_reading_type_code_class;
config_err_t ret;
assert (sdr_ctx);
assert (sdr_record);
assert (sdr_record_len);
assert (arg);
sdr_callback_arg = (struct ipmi_sensors_config_sdr_callback *)arg;
state_data = sdr_callback_arg->state_data;
/* achu:
*
* Technically, the IPMI spec lists that compact record formats
* also support settable thresholds. However, since compact
* records don't contain any information for interpreting
* threshold sensors (e.g. R exponent) I don't know how they
* could be of any use. No vendor that I know of supports
* threshold sensors via a compact record (excluding possible
* OEM ones).
*
* There's a part of me that believes the readable/setting
* threshold masks for compact sensor records is a cut and paste
* typo. It shouldn't be there.
*/
if (record_type != IPMI_SDR_FORMAT_FULL_SENSOR_RECORD
&& record_type != IPMI_SDR_FORMAT_COMPACT_SENSOR_RECORD)
{
if (state_data->prog_data->args->config_args.verbose_count)
pstdout_fprintf (state_data->pstate,
stderr,
"## Cannot handle SDR record format '0x%X'\n",
record_type);
return (0);
}
if (ipmi_sdr_parse_event_reading_type_code (state_data->sdr_ctx,
sdr_record,
sdr_record_len,
&event_reading_type_code) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_event_reading_type_code: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
event_reading_type_code_class = ipmi_event_reading_type_code_class (event_reading_type_code);
if (event_reading_type_code_class == IPMI_EVENT_READING_TYPE_CODE_CLASS_THRESHOLD)
{
if (record_type != IPMI_SDR_FORMAT_FULL_SENSOR_RECORD)
{
if (state_data->prog_data->args->config_args.verbose_count)
pstdout_printf (state_data->pstate,
"## Unable to handle threshold sensor with compact SDR record\n");
return (0);
}
if ((ret = ipmi_sensors_config_threshold_section (state_data,
§ion)) != CONFIG_ERR_SUCCESS)
{
if (ret == CONFIG_ERR_FATAL_ERROR)
return (-1);
return (0);
}
}
else if (event_reading_type_code_class == IPMI_EVENT_READING_TYPE_CODE_CLASS_GENERIC_DISCRETE
|| event_reading_type_code_class == IPMI_EVENT_READING_TYPE_CODE_CLASS_SENSOR_SPECIFIC_DISCRETE)
{
if ((ret = ipmi_sensors_config_discrete_section (state_data,
§ion)) != CONFIG_ERR_SUCCESS)
{
if (ret == CONFIG_ERR_FATAL_ERROR)
return (-1);
return (0);
}
}
else
{
if (state_data->prog_data->args->config_args.common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"## Cannot handle SDR with event reading type code '0x%X'\n",
event_reading_type_code);
return (0);
}
if (config_section_append (&sdr_callback_arg->sections, section) < 0)
return (-1);
return (0);
}
/* return (0) - no OEM match
* return (1) - OEM match
* return (-1) - error, cleanup and return error
*/
int
ipmi_sensors_oem_intel_node_manager_output_oem_record (ipmi_sensors_state_data_t *state_data)
{
assert (state_data);
assert (state_data->prog_data->args->verbose_count >= 2);
assert (state_data->prog_data->args->interpret_oem_data);
if (state_data->intel_node_manager.node_manager_data_found)
{
uint8_t nm_device_slave_address;
uint8_t sensor_owner_lun;
uint8_t channel_number;
uint8_t nm_health_event_sensor_number;
uint8_t nm_exception_event_sensor_number;
uint8_t nm_operational_capabilities_sensor_number;
uint8_t nm_alert_threshold_exceeded_sensor_number;
int ret;
if ((ret = ipmi_sdr_oem_parse_intel_node_manager (state_data->sdr_ctx,
NULL,
0,
&nm_device_slave_address,
&sensor_owner_lun,
&channel_number,
&nm_health_event_sensor_number,
&nm_exception_event_sensor_number,
&nm_operational_capabilities_sensor_number,
&nm_alert_threshold_exceeded_sensor_number)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_oem_parse_intel_node_manager: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
if (ret)
{
pstdout_printf (state_data->pstate,
"Node Manager Device Slave Address: %Xh\n",
nm_device_slave_address);
pstdout_printf (state_data->pstate,
"Sensor Owner LUN: %Xh\n",
sensor_owner_lun);
pstdout_printf (state_data->pstate,
"Channel Number: %Xh\n",
channel_number);
pstdout_printf (state_data->pstate,
"Node Manager Health Event Sensor Number: %u\n",
nm_health_event_sensor_number);
pstdout_printf (state_data->pstate,
"Node Manager Exception Event Sensor Number: %u\n",
nm_exception_event_sensor_number);
pstdout_printf (state_data->pstate,
"Node Manager Operational Capabilities Sensor Number: %u\n",
nm_operational_capabilities_sensor_number);
pstdout_printf (state_data->pstate,
"Node Manager Alert Threshold Exceeded Sensor Number: %u\n",
nm_alert_threshold_exceeded_sensor_number);
return (1);
}
}
return (0);
}
int
ipmi_sensors_output_verbose_sensor_reading_ranges (ipmi_sensors_state_data_t *state_data,
uint8_t *sdr_record,
unsigned int sdr_record_len)
{
double *nominal_reading = NULL;
double *normal_maximum = NULL;
double *normal_minimum = NULL;
double *sensor_maximum_reading = NULL;
double *sensor_minimum_reading = NULL;
uint8_t sensor_unit;
int rv = -1;
assert(state_data);
assert(sdr_record);
assert(sdr_record_len);
if (sdr_cache_get_sensor_unit (state_data->pstate,
sdr_record,
sdr_record_len,
&sensor_unit) < 0)
goto cleanup;
if (sdr_cache_get_sensor_reading_ranges (state_data->pstate,
sdr_record,
sdr_record_len,
&nominal_reading,
&normal_maximum,
&normal_minimum,
&sensor_maximum_reading,
&sensor_minimum_reading) < 0)
goto cleanup;
/* don't output at all if there isn't atleast 1 threshold to output */
if (!sensor_minimum_reading
&& !sensor_maximum_reading
&& !normal_minimum
&& !normal_maximum
&& !nominal_reading)
{
rv = 0;
goto cleanup;
}
if (sensor_minimum_reading)
pstdout_printf (state_data->pstate,
"Sensor Min. Reading: %f %s\n",
*sensor_minimum_reading,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Sensor Min. Reading: %s\n",
"NA");
if (sensor_maximum_reading)
pstdout_printf (state_data->pstate,
"Sensor Max. Reading: %f %s\n",
*sensor_maximum_reading,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Sensor Max. Reading: %s\n",
"NA");
if (normal_minimum)
pstdout_printf (state_data->pstate,
"Normal Min.: %f %s\n",
*normal_minimum,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Normal Min.: %s\n",
"NA");
if (normal_maximum)
pstdout_printf (state_data->pstate,
"Normal Max.: %f %s\n",
*normal_maximum,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Normal Max.: %s\n",
"NA");
if (nominal_reading)
pstdout_printf (state_data->pstate,
"Nominal reading: %f %s\n",
*nominal_reading,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Nominal reading: %s\n",
"NA");
rv = 0;
cleanup:
if (nominal_reading)
free(nominal_reading);
if (normal_maximum)
free(normal_maximum);
if (normal_minimum)
free(normal_minimum);
if (sensor_maximum_reading)
free(sensor_maximum_reading);
if (sensor_minimum_reading)
free(sensor_minimum_reading);
return rv;
}
int
ipmi_sensors_output_verbose_thresholds (ipmi_sensors_state_data_t *state_data,
uint8_t *sdr_record,
unsigned int sdr_record_len)
{
double *lower_non_critical_threshold = NULL;
double *lower_critical_threshold = NULL;
double *lower_non_recoverable_threshold = NULL;
double *upper_non_critical_threshold = NULL;
double *upper_critical_threshold = NULL;
double *upper_non_recoverable_threshold = NULL;
uint8_t sensor_unit;
int rv = -1;
assert(state_data);
assert(sdr_record);
assert(sdr_record_len);
if (sdr_cache_get_sensor_unit (state_data->pstate,
sdr_record,
sdr_record_len,
&sensor_unit) < 0)
goto cleanup;
if (ipmi_sensors_get_thresholds (state_data,
sdr_record,
sdr_record_len,
&lower_non_critical_threshold,
&lower_critical_threshold,
&lower_non_recoverable_threshold,
&upper_non_critical_threshold,
&upper_critical_threshold,
&upper_non_recoverable_threshold) < 0)
goto cleanup;
/* don't output at all if there isn't atleast 1 threshold to output */
if (!lower_critical_threshold
&& !upper_critical_threshold
&& !lower_non_critical_threshold
&& !upper_non_critical_threshold
&& !lower_non_recoverable_threshold
&& !upper_non_recoverable_threshold)
{
rv = 0;
goto cleanup;
}
if (lower_critical_threshold)
pstdout_printf (state_data->pstate,
"Lower Critical Threshold: %f %s\n",
*lower_critical_threshold,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Lower Critical Threshold: %s\n",
"NA");
if (upper_critical_threshold)
pstdout_printf (state_data->pstate,
"Upper Critical Threshold: %f %s\n",
*upper_critical_threshold,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Upper Critical Threshold: %s\n",
"NA");
if (lower_non_critical_threshold)
pstdout_printf (state_data->pstate,
"Lower Non-Critical Threshold: %f %s\n",
*lower_non_critical_threshold,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Lower Non-Critical Threshold: %s\n",
"NA");
if (upper_non_critical_threshold)
pstdout_printf (state_data->pstate,
"Upper Non-Critical Threshold: %f %s\n",
*upper_non_critical_threshold,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Upper Non-Critical Threshold: %s\n",
"NA");
if (lower_non_recoverable_threshold)
pstdout_printf (state_data->pstate,
"Lower Non-Recoverable Threshold: %f %s\n",
*lower_non_recoverable_threshold,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Lower Non-Recoverable Threshold: %s\n",
"NA");
if (upper_non_recoverable_threshold)
pstdout_printf (state_data->pstate,
"Upper Non-Recoverable Threshold: %f %s\n",
*upper_non_recoverable_threshold,
ipmi_sensor_units[sensor_unit]);
else
pstdout_printf (state_data->pstate,
"Upper Non-Recoverable Threshold: %s\n",
"NA");
rv = 0;
cleanup:
if (lower_non_critical_threshold)
free(lower_non_critical_threshold);
if (lower_critical_threshold)
free(lower_critical_threshold);
if (lower_non_recoverable_threshold)
free(lower_non_recoverable_threshold);
if (upper_non_critical_threshold)
free(upper_non_critical_threshold);
if (upper_critical_threshold)
free(upper_critical_threshold);
if (upper_non_recoverable_threshold)
free(upper_non_recoverable_threshold);
return rv;
}
static int
_simple_output_compact_record (ipmi_sensors_state_data_t *state_data,
uint16_t record_id,
uint8_t sensor_number,
int event_message_output_type,
uint16_t sensor_event_bitmask,
char **event_message_list,
unsigned int event_message_list_len)
{
assert (state_data);
assert (IPMI_SENSORS_EVENT_VALID (event_message_output_type));
if (_simple_output_header (state_data,
record_id,
sensor_number,
event_message_output_type,
sensor_event_bitmask) < 0)
return (-1);
if (!state_data->prog_data->args->quiet_readings)
{
char fmt[IPMI_SENSORS_FMT_BUFLEN + 1];
memset (fmt, '\0', IPMI_SENSORS_FMT_BUFLEN + 1);
if (state_data->prog_data->args->comma_separated_output)
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
",%%s,%%s");
else
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
" | %%-10s | %%-%ds",
state_data->column_width.sensor_units);
pstdout_printf (state_data->pstate,
fmt,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING);
}
if (state_data->prog_data->args->output_sensor_thresholds)
{
if (state_data->prog_data->args->comma_separated_output)
pstdout_printf (state_data->pstate,
",%s,%s,%s,%s,%s,%s",
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING);
else
pstdout_printf (state_data->pstate,
" | %-10s | %-10s | %-10s | %-10s | %-10s | %-10s",
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING);
}
if (state_data->prog_data->args->comma_separated_output)
pstdout_printf (state_data->pstate, ",");
else
pstdout_printf (state_data->pstate, " | ");
if (ipmi_sensors_output_event_message_list (state_data,
event_message_output_type,
sensor_event_bitmask,
event_message_list,
event_message_list_len,
NULL,
0) < 0)
return (-1);
return (0);
}
static int
_simple_output_full_record (ipmi_sensors_state_data_t *state_data,
uint16_t record_id,
uint8_t sensor_number,
double *sensor_reading,
int event_message_output_type,
uint16_t sensor_event_bitmask,
char **event_message_list,
unsigned int event_message_list_len)
{
char fmt[IPMI_SENSORS_FMT_BUFLEN + 1];
uint8_t event_reading_type_code;
double *lower_non_critical_threshold = NULL;
double *upper_non_critical_threshold = NULL;
double *lower_critical_threshold = NULL;
double *upper_critical_threshold = NULL;
double *lower_non_recoverable_threshold = NULL;
double *upper_non_recoverable_threshold = NULL;
int rv = -1;
assert (state_data);
assert (IPMI_SENSORS_EVENT_VALID (event_message_output_type));
if (_simple_output_header (state_data,
record_id,
sensor_number,
event_message_output_type,
sensor_event_bitmask) < 0)
goto cleanup;
if (ipmi_sdr_parse_event_reading_type_code (state_data->sdr_ctx,
NULL,
0,
&event_reading_type_code) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_event_reading_type_code: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
goto cleanup;
}
switch (ipmi_event_reading_type_code_class (event_reading_type_code))
{
case IPMI_EVENT_READING_TYPE_CODE_CLASS_THRESHOLD:
if (!state_data->prog_data->args->quiet_readings)
{
char sensor_units_buf[IPMI_SENSORS_UNITS_BUFLEN+1];
memset (sensor_units_buf, '\0', IPMI_SENSORS_UNITS_BUFLEN+1);
if (get_sensor_units_output_string (state_data->pstate,
state_data->sdr_ctx,
sensor_units_buf,
IPMI_SENSORS_UNITS_BUFLEN,
state_data->prog_data->args->non_abbreviated_units) < 0)
goto cleanup;
memset (fmt, '\0', IPMI_SENSORS_FMT_BUFLEN + 1);
if (sensor_reading)
{
if (state_data->prog_data->args->comma_separated_output)
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
",%%.2f,%%s");
else
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
" | %%-10.2f | %%-%ds",
state_data->column_width.sensor_units);
pstdout_printf (state_data->pstate,
fmt,
_round_double2 (*sensor_reading),
sensor_units_buf);
}
else
{
if (state_data->prog_data->args->comma_separated_output)
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
",%%s,%%s");
else
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
" | %%-10s | %%-%ds",
state_data->column_width.sensor_units);
pstdout_printf (state_data->pstate,
fmt,
IPMI_SENSORS_NA_STRING,
sensor_units_buf);
}
}
if (state_data->prog_data->args->output_sensor_thresholds)
{
char thresholdfmt[IPMI_SENSORS_FMT_BUFLEN + 1];
char nafmt[IPMI_SENSORS_FMT_BUFLEN + 1];
if (ipmi_sensors_get_thresholds (state_data,
&lower_non_critical_threshold,
&lower_critical_threshold,
&lower_non_recoverable_threshold,
&upper_non_critical_threshold,
&upper_critical_threshold,
&upper_non_recoverable_threshold) < 0)
goto cleanup;
memset (fmt, '\0', IPMI_SENSORS_FMT_BUFLEN + 1);
if (state_data->prog_data->args->comma_separated_output)
{
snprintf (thresholdfmt,
IPMI_SENSORS_FMT_BUFLEN,
",%%.2f");
snprintf (nafmt,
IPMI_SENSORS_FMT_BUFLEN,
",%%s");
}
else
{
snprintf (thresholdfmt,
IPMI_SENSORS_FMT_BUFLEN,
" | %%-10.2f");
snprintf (nafmt,
IPMI_SENSORS_FMT_BUFLEN,
" | %%-10s");
}
if (lower_non_recoverable_threshold)
pstdout_printf (state_data->pstate,
thresholdfmt,
*lower_non_recoverable_threshold);
else
pstdout_printf (state_data->pstate,
nafmt,
IPMI_SENSORS_NA_STRING);
if (lower_critical_threshold)
pstdout_printf (state_data->pstate,
thresholdfmt,
*lower_critical_threshold);
else
pstdout_printf (state_data->pstate,
nafmt,
IPMI_SENSORS_NA_STRING);
if (lower_non_critical_threshold)
pstdout_printf (state_data->pstate,
thresholdfmt,
*lower_non_critical_threshold);
else
pstdout_printf (state_data->pstate,
nafmt,
IPMI_SENSORS_NA_STRING);
if (upper_non_critical_threshold)
pstdout_printf (state_data->pstate,
thresholdfmt,
*upper_non_critical_threshold);
else
pstdout_printf (state_data->pstate,
nafmt,
IPMI_SENSORS_NA_STRING);
if (upper_critical_threshold)
pstdout_printf (state_data->pstate,
thresholdfmt,
*upper_critical_threshold);
else
pstdout_printf (state_data->pstate,
nafmt,
IPMI_SENSORS_NA_STRING);
if (upper_non_recoverable_threshold)
pstdout_printf (state_data->pstate,
thresholdfmt,
*upper_non_recoverable_threshold);
else
pstdout_printf (state_data->pstate,
nafmt,
IPMI_SENSORS_NA_STRING);
}
if (state_data->prog_data->args->comma_separated_output)
pstdout_printf (state_data->pstate, ",");
else
pstdout_printf (state_data->pstate, " | ");
if (ipmi_sensors_output_event_message_list (state_data,
event_message_output_type,
sensor_event_bitmask,
event_message_list,
event_message_list_len,
NULL,
0) < 0)
goto cleanup;
break;
case IPMI_EVENT_READING_TYPE_CODE_CLASS_GENERIC_DISCRETE:
case IPMI_EVENT_READING_TYPE_CODE_CLASS_SENSOR_SPECIFIC_DISCRETE:
case IPMI_EVENT_READING_TYPE_CODE_CLASS_OEM:
default:
if (!state_data->prog_data->args->quiet_readings)
{
if (state_data->prog_data->args->common_args.section_specific_workaround_flags & IPMI_PARSE_SECTION_SPECIFIC_WORKAROUND_FLAGS_DISCRETE_READING
&& sensor_reading)
{
char sensor_units_buf[IPMI_SENSORS_UNITS_BUFLEN+1];
memset (sensor_units_buf, '\0', IPMI_SENSORS_UNITS_BUFLEN+1);
if (get_sensor_units_output_string (state_data->pstate,
state_data->sdr_ctx,
sensor_units_buf,
IPMI_SENSORS_UNITS_BUFLEN,
state_data->prog_data->args->non_abbreviated_units) < 0)
goto cleanup;
memset (fmt, '\0', IPMI_SENSORS_FMT_BUFLEN + 1);
if (state_data->prog_data->args->comma_separated_output)
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
",%%.2f,%%s");
else
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
" | %%-10.2f | %%-%ds",
state_data->column_width.sensor_units);
pstdout_printf (state_data->pstate,
fmt,
_round_double2 (*sensor_reading),
sensor_units_buf);
}
else
{
memset (fmt, '\0', IPMI_SENSORS_FMT_BUFLEN + 1);
if (state_data->prog_data->args->comma_separated_output)
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
",%%s,%%s");
else
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
" | %%-10s | %%-%ds",
state_data->column_width.sensor_units);
pstdout_printf (state_data->pstate,
fmt,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING);
}
}
if (state_data->prog_data->args->output_sensor_thresholds)
{
if (state_data->prog_data->args->comma_separated_output)
pstdout_printf (state_data->pstate,
",%s,%s,%s,%s,%s,%s",
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING);
else
pstdout_printf (state_data->pstate,
" | %-10s | %-10s | %-10s | %-10s | %-10s | %-10s",
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING,
IPMI_SENSORS_NA_STRING);
}
if (state_data->prog_data->args->comma_separated_output)
pstdout_printf (state_data->pstate, ",");
else
pstdout_printf (state_data->pstate, " | ");
if (ipmi_sensors_output_event_message_list (state_data,
event_message_output_type,
sensor_event_bitmask,
event_message_list,
event_message_list_len,
NULL,
0) < 0)
goto cleanup;
break;
}
rv = 0;
cleanup:
free (lower_non_critical_threshold);
free (upper_non_critical_threshold);
free (lower_critical_threshold);
free (upper_critical_threshold);
free (lower_non_recoverable_threshold);
free (upper_non_recoverable_threshold);
return (rv);
}
static int
_simple_output_header (ipmi_sensors_state_data_t *state_data,
uint16_t record_id,
uint8_t sensor_number,
int event_message_output_type,
uint16_t sensor_event_bitmask)
{
char fmt[IPMI_SENSORS_FMT_BUFLEN + 1];
char sensor_name[IPMI_SDR_MAX_SENSOR_NAME_LENGTH + 1];
unsigned int sensor_name_flags = 0;
const char *sensor_type_string;
uint8_t event_reading_type_code;
assert (state_data);
assert (IPMI_SENSORS_EVENT_VALID (event_message_output_type));
memset (sensor_name, '\0', IPMI_SDR_MAX_SENSOR_NAME_LENGTH + 1);
if (!state_data->prog_data->args->shared_sensors)
sensor_name_flags |= IPMI_SDR_SENSOR_NAME_FLAGS_IGNORE_SHARED_SENSORS;
if (state_data->prog_data->args->entity_sensor_names)
{
if (ipmi_sdr_parse_entity_sensor_name (state_data->sdr_ctx,
NULL,
0,
sensor_number,
sensor_name_flags,
sensor_name,
IPMI_SDR_MAX_SENSOR_NAME_LENGTH) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_entity_sensor_name: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
}
else
{
if (ipmi_sdr_parse_sensor_name (state_data->sdr_ctx,
NULL,
0,
sensor_number,
sensor_name_flags,
sensor_name,
IPMI_SDR_MAX_SENSOR_NAME_LENGTH) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_sensor_name: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
}
memset (fmt, '\0', IPMI_SENSORS_FMT_BUFLEN + 1);
if (state_data->prog_data->args->no_sensor_type_output)
{
if (state_data->prog_data->args->comma_separated_output)
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
"%%u,%%s");
else
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
"%%-%du | %%-%ds",
state_data->column_width.record_id,
state_data->column_width.sensor_name);
pstdout_printf (state_data->pstate,
fmt,
record_id,
sensor_name);
}
else
{
uint8_t sensor_type;
if (ipmi_sdr_parse_sensor_type (state_data->sdr_ctx,
NULL,
0,
&sensor_type) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_sensor_type: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
if (state_data->prog_data->args->comma_separated_output)
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
"%%u,%%s,%%s");
else
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
"%%-%du | %%-%ds | %%-%ds",
state_data->column_width.record_id,
state_data->column_width.sensor_name,
state_data->column_width.sensor_type);
if ((state_data->prog_data->args->interpret_oem_data)
&& (ipmi_sdr_parse_event_reading_type_code (state_data->sdr_ctx,
NULL,
0,
&event_reading_type_code) >= 0))
sensor_type_string = get_oem_sensor_type_output_string (sensor_type,
event_reading_type_code,
state_data->oem_data.manufacturer_id,
state_data->oem_data.product_id);
else
sensor_type_string = get_sensor_type_output_string (sensor_type);
pstdout_printf (state_data->pstate,
fmt,
record_id,
sensor_name,
sensor_type_string);
}
if (state_data->prog_data->args->output_sensor_state)
{
char *sensor_state_str = NULL;
if (ipmi_sensors_get_sensor_state (state_data,
event_message_output_type,
sensor_event_bitmask,
&sensor_state_str) < 0)
return (-1);
if (state_data->prog_data->args->comma_separated_output)
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
",%%s");
else
snprintf (fmt,
IPMI_SENSORS_FMT_BUFLEN,
" | %%-8s");
pstdout_printf (state_data->pstate,
fmt,
sensor_state_str);
}
return (0);
}
static ipmi_config_err_t
front_panel_buttons_commit (ipmi_config_state_data_t *state_data,
const char *section_name,
const struct ipmi_config_keyvalue *kv)
{
struct front_panel_buttons data;
ipmi_config_err_t rv = IPMI_CONFIG_ERR_FATAL_ERROR;
ipmi_config_err_t ret;
uint8_t enable_or_disable;
uint8_t disable_allowed;
assert (state_data);
assert (section_name);
assert (kv);
memset (&data, '\0', sizeof (struct front_panel_buttons));
if ((ret = _get_front_panel_buttons (state_data, &data)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
if (!strcasecmp (kv->key->key_name, "Enable_Standby_Button_For_Entering_Standby"))
{
data.standby = same (kv->value_input, "yes") ? BUTTON_ENABLED : BUTTON_DISABLED;
enable_or_disable = data.standby;
disable_allowed = data.standby_disable_allowed;
}
else if (!strcasecmp (kv->key->key_name, "Enable_Diagnostic_Interrupt_Button"))
{
data.diagnostic_interrupt = same (kv->value_input, "yes") ? BUTTON_ENABLED : BUTTON_DISABLED;
enable_or_disable = data.diagnostic_interrupt;
disable_allowed = data.diagnostic_interrupt_disable_allowed;
}
else if (!strcasecmp (kv->key->key_name, "Enable_Reset_Button"))
{
data.reset = same (kv->value_input, "yes") ? BUTTON_ENABLED : BUTTON_DISABLED;
enable_or_disable = data.reset;
disable_allowed = data.reset_disable_allowed;
}
else if (!strcasecmp (kv->key->key_name, "Enable_Power_Off_Button_For_Power_Off_Only"))
{
data.power_off = same (kv->value_input, "yes") ? BUTTON_ENABLED : BUTTON_DISABLED;
enable_or_disable = data.power_off;
disable_allowed = data.power_off_disable_allowed;
}
else
{
if (state_data->prog_data->args->verbose_count)
pstdout_printf (state_data->pstate,
"## Unrecognized section:key_name: %s:%s\n",
section_name,
kv->key->key_name);
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
if (enable_or_disable == BUTTON_DISABLED
&& disable_allowed == BUTTON_DISABLE_NOT_ALLOWED)
{
if (state_data->prog_data->args->verbose_count > 1)
pstdout_printf (state_data->pstate,
"## Button disable on section:key_name '%s:%s' not allowed\n",
section_name,
kv->key->key_name);
rv = IPMI_CONFIG_ERR_NON_FATAL_ERROR;
goto cleanup;
}
if (data.standby == BUTTON_UNKNOWN)
{
if (state_data->front_panel_enable_standby_button_for_entering_standby_initialized)
data.standby = state_data->front_panel_enable_standby_button_for_entering_standby;
else
data.standby = BUTTON_ENABLED;
}
if (data.diagnostic_interrupt == BUTTON_UNKNOWN)
{
if (state_data->front_panel_enable_diagnostic_interrupt_button_initialized)
data.diagnostic_interrupt = state_data->front_panel_enable_diagnostic_interrupt_button;
else
data.diagnostic_interrupt = BUTTON_ENABLED;
}
if (data.reset == BUTTON_UNKNOWN)
{
if (state_data->front_panel_enable_reset_button_initialized)
data.reset = state_data->front_panel_enable_reset_button;
else
data.reset = BUTTON_ENABLED;
}
if (data.power_off == BUTTON_UNKNOWN)
{
if (state_data->front_panel_enable_power_off_button_for_power_off_only_initialized)
data.power_off = state_data->front_panel_enable_power_off_button_for_power_off_only;
else
data.power_off = BUTTON_ENABLED;
}
if ((ret = _set_front_panel_buttons (state_data, &data)) != IPMI_CONFIG_ERR_SUCCESS)
{
rv = ret;
goto cleanup;
}
rv = IPMI_CONFIG_ERR_SUCCESS;
cleanup:
return (rv);
}
int
ipmi_oem_fujitsu_get_error_led (ipmi_oem_state_data_t *state_data)
{
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
uint8_t state;
int rs_len;
int rv = -1;
assert (state_data);
assert (!state_data->prog_data->args->oem_options_count);
/* Fujitsu OEM
*
* http://manuals.ts.fujitsu.com/file/4390/irmc_s2-en.pdf
*
* Request
*
* 0x2E - OEM network function
* 0xF5 - OEM cmd
* 0x?? - Fujitsu IANA (LSB first)
* 0x?? - Fujitsu IANA
* 0x?? - Fujitsu IANA
* 0xB3 - Command Specifier
*
* Response
*
* 0xF5 - OEM cmd
* 0x?? - Completion code
* 0x?? - Fujitsu IANA (LSB first)
* 0x?? - Fujitsu IANA
* 0x?? - Fujitsu IANA
* 0x?? - error led state
*
* GEL - Global Error LED
* CSS - Customer Self Service LED
*
* 0 - CSS off / GEL off
* 1 - CSS off / GEL on
* 2 - CSS off / GEL blink
* 3 - CSS on / GEL off
* 4 - CSS on / GEL on
* 5 - CSS on / GEL blink
* 6 - CSS blink / GEL off
* 7 - CSS blink / GEL on
* 8 - CSS blink / GEL blink
*/
bytes_rq[0] = IPMI_CMD_OEM_FUJITSU_SYSTEM;
bytes_rq[1] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x0000FF);
bytes_rq[2] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x00FF00) >> 8;
bytes_rq[3] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0xFF0000) >> 16;
bytes_rq[4] = IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_GET_ERROR_LED;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_GROUP_RQ, /* network function */
bytes_rq, /* data */
5, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
6,
IPMI_CMD_OEM_FUJITSU_SYSTEM,
IPMI_NET_FN_OEM_GROUP_RS,
NULL) < 0)
goto cleanup;
state = bytes_rs[5];
switch (state)
{
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_OFF_GEL_OFF:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_OFF_GEL_ON:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_OFF_GEL_BLINK:
pstdout_printf (state_data->pstate, "CSS LED: off\n");
break;
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_ON_GEL_OFF:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_ON_GEL_ON:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_ON_GEL_BLINK:
pstdout_printf (state_data->pstate, "CSS LED: on\n");
break;
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_BLINK_GEL_OFF:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_BLINK_GEL_ON:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_BLINK_GEL_BLINK:
pstdout_printf (state_data->pstate, "CSS LED: blink\n");
break;
default:
pstdout_printf (state_data->pstate,
"Unrecognized LED state: %02Xh\n",
state);
goto cleanup;
}
switch (state)
{
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_OFF_GEL_OFF:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_ON_GEL_OFF:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_BLINK_GEL_OFF:
pstdout_printf (state_data->pstate, "GEL LED: off\n");
break;
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_OFF_GEL_ON:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_ON_GEL_ON:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_BLINK_GEL_ON:
pstdout_printf (state_data->pstate, "GEL LED: on\n");
break;
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_OFF_GEL_BLINK:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_ON_GEL_BLINK:
case IPMI_OEM_FUJITSU_ERROR_LED_CSS_BLINK_GEL_BLINK:
pstdout_printf (state_data->pstate, "GEL LED: blink\n");
break;
default:
pstdout_printf (state_data->pstate,
"Unrecognized LED state: %02Xh\n",
state);
goto cleanup;
}
rv = 0;
cleanup:
return (rv);
}
static int
_get_led_sdr_callback (ipmi_sdr_ctx_t sdr_ctx,
uint8_t record_type,
const void *sdr_record,
unsigned int sdr_record_len,
void *arg)
{
struct ipmi_oem_ibm_get_led_sdr_callback *sdr_callback_arg;
ipmi_oem_state_data_t *state_data;
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
int rs_len;
uint8_t oem_data_buf[IPMI_SDR_MAX_RECORD_LENGTH];
int oem_data_buf_len;
uint16_t record_id;
char fmt[IPMI_OEM_FMT_BUFLEN + 1];
char led_name[IPMI_OEM_IBM_LED_NAME_BUFLEN + 1];
char led_pointer_name[IPMI_OEM_IBM_LED_NAME_BUFLEN + 1];
char id_string[IPMI_OEM_IBM_LED_ID_STRING_BUFLEN + 1];
char led_info[IPMI_OEM_IBM_LED_INFO_BUFLEN + 1];
char *led_state_str = NULL;
uint8_t sensor_type;
uint8_t led_id_ls;
uint8_t led_id_ms;
uint16_t led_id;
uint8_t led_state;
uint8_t led_active_type;
uint16_t led_pointer_id;
uint8_t sensor_number;
int available_led;
assert (sdr_ctx);
assert (sdr_record);
assert (sdr_record_len);
assert (arg);
sdr_callback_arg = (struct ipmi_oem_ibm_get_led_sdr_callback *)arg;
state_data = sdr_callback_arg->state_data;
/* IBM OEM
*
* From xCAT (http://xcat.sourceforge.net/)
*
* Get Led Request
*
* 0x3A - OEM network function (is IPMI_NET_FN_OEM_IBM_LED_RQ)
* 0xC0 - OEM cmd
* 0x?? - LED ID (MS Byte)
* 0x?? - LED ID (LS Byte)
*
* Get Led Response
*
* 0xC0 - OEM cmd
* 0x?? - Completion Code
* 0x?? - ??
* 0x?? - LED Active vs. Inactive
* - non-zero = active
* - 0 = inactive
* 0x?? - ??
* 0x?? - LED Pointer ID (MS Byte)
* 0x?? - LED Pointer ID (LS Byte) / Sensor Number
* - Pointer ID means indicating problem elsewhere
* 0x?? - LED Active Type
* - 1 - Indicates LED Active to indicate LED Pointer ID Active
* - 2 - Indicates LED Active due to Sensor w/ Sensor Number
* - 3 - User manually activated LED
* - 4 - BIOS or Administrator lit LED
*/
if (record_type != IPMI_SDR_FORMAT_OEM_RECORD)
return (0);
if (ipmi_sdr_parse_record_id_and_type (state_data->sdr_ctx,
sdr_record,
sdr_record_len,
&record_id,
NULL) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_record_id_and_type: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
if ((oem_data_buf_len = ipmi_sdr_parse_oem_data (state_data->sdr_ctx,
sdr_record,
sdr_record_len,
oem_data_buf,
IPMI_SDR_MAX_RECORD_LENGTH)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_oem_data: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
/* If not enough data, skip it */
if (oem_data_buf_len < IPMI_SDR_RECORD_OEM_IBM_LED_OEM_DATA_MIN_LENGTH)
return (0);
sensor_type = oem_data_buf[IPMI_SDR_RECORD_OEM_IBM_SENSOR_TYPE_OEM_DATA_INDEX];
/* If not LED sensor type, skip it */
if (sensor_type != IPMI_SDR_RECORD_OEM_IBM_LED_SENSOR_TYPE)
return (0);
/* IBM systems use inconsistent endian, guess endian by assuming
* LED IDs are numerically started at 0
*/
if (oem_data_buf[IPMI_SDR_RECORD_OEM_IBM_LED_ID_LS_OEM_DATA_INDEX] > oem_data_buf[IPMI_SDR_RECORD_OEM_IBM_LED_ID_MS_OEM_DATA_INDEX])
{
led_id_ls = oem_data_buf[IPMI_SDR_RECORD_OEM_IBM_LED_ID_LS_OEM_DATA_INDEX];
led_id_ms = oem_data_buf[IPMI_SDR_RECORD_OEM_IBM_LED_ID_MS_OEM_DATA_INDEX];
}
else
{
led_id_ls = oem_data_buf[IPMI_SDR_RECORD_OEM_IBM_LED_ID_MS_OEM_DATA_INDEX];
led_id_ms = oem_data_buf[IPMI_SDR_RECORD_OEM_IBM_LED_ID_LS_OEM_DATA_INDEX];
}
led_id = led_id_ls | (led_id_ms << 8);
bytes_rq[0] = IPMI_CMD_OEM_IBM_GET_LED;
bytes_rq[1] = led_id_ms;
bytes_rq[2] = led_id_ls;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_IBM_LED_RQ, /* network function */
bytes_rq, /* data */
3, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
return (-1);
}
/* If get parameter out of range, assume LED ID endian wrong and try again */
if (rs_len >= 2 && bytes_rs[1] == IPMI_COMP_CODE_PARAMETER_OUT_OF_RANGE)
{
bytes_rq[0] = IPMI_CMD_OEM_IBM_GET_LED;
bytes_rq[1] = led_id_ls;
bytes_rq[2] = led_id_ms;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_IBM_LED_RQ, /* network function */
bytes_rq, /* data */
3, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
return (-1);
}
}
/* achu: there are probably 1 or 2 completion codes that are
* acceptable to ignore and continue on, but who knows what they
* are.
*/
/* Assume this error code means LED not available */
if (rs_len >= 2 && bytes_rs[1] == IPMI_COMP_CODE_PARAMETER_OUT_OF_RANGE)
available_led = 0;
else
{
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
8,
IPMI_CMD_OEM_IBM_GET_LED,
IPMI_NET_FN_OEM_IBM_LED_RS,
NULL) < 0)
return (-1);
available_led = 1;
}
if (!sdr_callback_arg->header_output_flag)
{
memset (fmt, '\0', IPMI_OEM_FMT_BUFLEN + 1);
snprintf (fmt,
IPMI_OEM_FMT_BUFLEN,
"%%-%ds | LED | State | LED Information\n",
sdr_callback_arg->column_width->record_id);
pstdout_printf (state_data->pstate,
fmt,
SENSORS_HEADER_RECORD_ID_STR);
sdr_callback_arg->header_output_flag++;
}
memset (led_name, '\0', IPMI_OEM_IBM_LED_NAME_BUFLEN + 1);
memset (led_pointer_name, '\0', IPMI_OEM_IBM_LED_NAME_BUFLEN + 1);
memset (id_string, '\0', IPMI_OEM_IBM_LED_ID_STRING_BUFLEN + 1);
memset (led_info, '\0', IPMI_OEM_IBM_LED_INFO_BUFLEN + 1);
if (_get_led_name (state_data,
sdr_callback_arg->oem_data,
led_id,
led_name,
IPMI_OEM_IBM_LED_NAME_BUFLEN) < 0)
return (-1);
if (available_led)
{
led_state = bytes_rs[3];
led_active_type = bytes_rs[7];
led_pointer_id = (bytes_rs[5] << 8) | bytes_rs[6];
sensor_number = bytes_rs[6];
if (led_state == IPMI_OEM_IBM_LED_STATE_INACTIVE)
led_state_str = "Inactive";
else
led_state_str = "Active";
if (led_state != IPMI_OEM_IBM_LED_STATE_INACTIVE)
{
/* Location LED special case */
if (!led_id)
{
snprintf (led_info,
IPMI_OEM_IBM_LED_INFO_BUFLEN,
"System Error Condition");
}
else if (led_active_type == IPMI_OEM_IBM_LED_ACTIVE_BY_LED)
{
if (_get_led_name (state_data,
sdr_callback_arg->oem_data,
led_pointer_id,
led_pointer_name,
IPMI_OEM_IBM_LED_NAME_BUFLEN) < 0)
return (-1);
snprintf (led_info,
IPMI_OEM_IBM_LED_INFO_BUFLEN,
"'%s' Active",
led_pointer_name);
}
else if (led_active_type == IPMI_OEM_IBM_LED_ACTIVE_BY_SENSOR)
{
/* achu: sensor numbers may not be unique. I'm copying
* this algorithm from xCAT so I assume it's safe for
* IBM machines b/c IBM lays out their SDRs in a fashion
* that this search is safe and won't result in an
* incorrect output.
*/
if (_find_sensor (state_data,
sensor_number,
id_string,
IPMI_OEM_IBM_LED_ID_STRING_BUFLEN) < 0)
return (-1);
snprintf (led_info,
IPMI_OEM_IBM_LED_INFO_BUFLEN,
"Sensor '%s' error",
id_string);
}
else if (led_active_type == IPMI_OEM_IBM_LED_ACTIVE_BY_USER)
{
snprintf (led_info,
IPMI_OEM_IBM_LED_INFO_BUFLEN,
"LED Activated by User");
}
else if (led_active_type == IPMI_OEM_IBM_LED_ACTIVE_BY_BIOS_OR_ADMINISTRATOR)
{
snprintf (led_info,
IPMI_OEM_IBM_LED_INFO_BUFLEN,
"LED Activated by BIOS or Administrator");
}
}
}
else
led_state_str = "N/A";
snprintf (fmt,
IPMI_OEM_FMT_BUFLEN,
"%%-%du | %%-%ds | %%-%ds | %s\n",
sdr_callback_arg->column_width->record_id,
IPMI_OEM_IBM_LED_NAME_COLUMN_SIZE,
IPMI_OEM_IBM_LED_STATE_COLUMN_SIZE,
led_info);
pstdout_printf (state_data->pstate,
fmt,
record_id,
led_name,
led_state_str,
led_info);
return (0);
}
int
ipmi_oem_fujitsu_get_power_on_source (ipmi_oem_state_data_t *state_data)
{
uint8_t source = 0;
char str[IPMI_OEM_STR_BUFLEN];
int rv = -1;
assert (state_data);
assert (!state_data->prog_data->args->oem_options_count);
if (_ipmi_oem_get_power_source (state_data,
IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_GET_POWER_ON_SOURCE,
&source) < 0)
goto cleanup;
memset (str, '\0', IPMI_OEM_STR_BUFLEN);
switch (source)
{
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_SOFTWARE_OR_COMMAND:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Software or command");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_POWER_SWITCH:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Power switch");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_AUTOMATIC_RESTART_AFTER_POWER_FAILURE:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Automatic restart after power failure");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_CLOCK_OR_TIMER:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Clock or timer");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_AUTOMATIC_RESTART_AFTER_FAN_FAILURE_SHUTDOWN:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Automatic restart after fan failure shutdown");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_AUTOMATIC_RESTART_AFTER_CRITICAL_TEMPERATURE_SHUTDOWN:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Automatic restart after critical temperature shutdown");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_REBOOT_AFTER_WATCHDOG_TIMEOUT:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Reboot after watchdog timeout");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_REMOTE_ON:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Remote on");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_REBOOT_AFTER_A_CPU_ERROR:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Reboot after a CPU error");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_REBOOT_BY_HARDWARE_RESET:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Reboot by hardware reset");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_REBOOT_AFTER_WARM_START:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Reboot after warm start");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_POWERED_ON_BY_A_PCI_BUS_POWER_MANAGEMENT_EVENT:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Powered on by a PCI Bus Power Management Event");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_POWERED_ON_BY_REMOTE_CONTROL_VIA_REMOTE_MANAGER:
/* HLiebig: capitalized "remote manager" from doc */
snprintf (str, IPMI_OEM_STR_BUFLEN, "Powered on by remote control via Remote Manager");
break;
case IPMI_OEM_FUJITSU_POWER_ON_SOURCE_REBOOT_RESET_BY_REMOTE_CONTROL_VIA_REMOTE_MANAGER:
/* HLiebig: capitalized "remote manager" from doc */
snprintf (str, IPMI_OEM_STR_BUFLEN, "Reboot/reset by remote control via Remote Manager");
break;
default:
snprintf (str, IPMI_OEM_STR_BUFLEN, "Unrecognized source: %02Xh", source);
}
pstdout_printf (state_data->pstate,
"%s\n",
str);
rv = 0;
cleanup:
return (rv);
}
/* return (0) - no OEM match
* return (1) - OEM match
* return (-1) - error, cleanup and return error
*/
int
ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record (ipmi_sensors_state_data_t *state_data,
uint32_t oem_record_manufacturer_id,
const uint8_t *oem_data,
unsigned int oem_data_len)
{
int ret;
assert (state_data);
assert (oem_data);
assert (oem_data_len);
assert (state_data->prog_data->args->verbose_count >= 2);
assert (state_data->prog_data->args->interpret_oem_data);
assert (state_data->oem_data.manufacturer_id == IPMI_IANA_ENTERPRISE_ID_INTEL);
assert (state_data->oem_data.product_id == IPMI_INTEL_PRODUCT_ID_QUANTA_QSSC_S4R);
/*
* Quanta QSSC-S4R/Appro GB812X-CN
* (Quanta motherboard contains Intel manufacturer ID)
*/
if ((ret = ipmi_sensors_oem_intel_node_manager_output_oem_record (state_data)) < 0)
return (-1);
if (ret)
return (1);
if (oem_record_manufacturer_id == IPMI_IANA_ENTERPRISE_ID_INTEL)
{
uint8_t record_subtype;
record_subtype = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_SUBTYPE_INDEX];
if (record_subtype == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_SUBTYPE
&& oem_data_len >= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_OEM_DATA_LENGTH)
{
uint8_t memory_throttling_mode;
uint8_t fan_control_profile_support_0;
uint8_t fan_control_profile_support_1;
uint8_t fan_control_profile_support_2;
uint8_t fan_control_profile_support_3;
uint8_t fan_control_profile_support_4;
uint8_t fan_control_profile_support_5;
uint8_t fan_control_profile_support_6;
uint8_t fan_control_profile_support_7;
uint8_t tempinlet;
uint8_t temprise;
uint16_t airflow;
uint16_t dimmpitch;
uint8_t throttle_mode;
uint8_t thermal_register_lock;
uint8_t hysteresis;
uint8_t control_event_mode;
char *memory_throttling_mode_str;
char *throttle_mode_str;
char *hysteresis_str;
char *control_event_mode_str;
memory_throttling_mode = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_MEMORY_THROTTLING_MODE_INDEX];
memory_throttling_mode &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_MEMORY_THROTTLING_MODE_BITMASK;
memory_throttling_mode >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_MEMORY_THROTTLING_MODE_SHIFT;
fan_control_profile_support_0 = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_INDEX];
fan_control_profile_support_0 &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE0_BITMASK;
fan_control_profile_support_0 >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE0_SHIFT;
fan_control_profile_support_1 = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_INDEX];
fan_control_profile_support_1 &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE1_BITMASK;
fan_control_profile_support_1 >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE1_SHIFT;
fan_control_profile_support_2 = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_INDEX];
fan_control_profile_support_2 &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE2_BITMASK;
fan_control_profile_support_2 >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE2_SHIFT;
fan_control_profile_support_3 = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_INDEX];
fan_control_profile_support_3 &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE3_BITMASK;
fan_control_profile_support_3 >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE3_SHIFT;
fan_control_profile_support_4 = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_INDEX];
fan_control_profile_support_4 &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE4_BITMASK;
fan_control_profile_support_4 >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE4_SHIFT;
fan_control_profile_support_5 = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_INDEX];
fan_control_profile_support_5 &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE5_BITMASK;
fan_control_profile_support_5 >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE5_SHIFT;
fan_control_profile_support_6 = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_INDEX];
fan_control_profile_support_6 &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE6_BITMASK;
fan_control_profile_support_6 >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE6_SHIFT;
fan_control_profile_support_7 = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE_INDEX];
fan_control_profile_support_7 &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE7_BITMASK;
fan_control_profile_support_7 >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_FAN_PROFILE7_SHIFT;
tempinlet = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_TEMPINLET_INDEX];
temprise = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_TEMPRISE_INDEX];
airflow = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_AIRFLOW_INDEX_START];
airflow |= (oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_AIRFLOW_INDEX_START + 1] << 8);
dimmpitch = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_DIMMPITCH_INDEX_START];
dimmpitch |= (oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_DIMMPITCH_INDEX_START + 1] << 8);
throttle_mode = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THROTTLE_MODE_INDEX];
throttle_mode &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THROTTLE_MODE_BITMASK;
throttle_mode >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THROTTLE_MODE_SHIFT;
thermal_register_lock = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THERMAL_REGISTER_LOCK_INDEX];
thermal_register_lock &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THERMAL_REGISTER_LOCK_BITMASK;
thermal_register_lock >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THERMAL_REGISTER_LOCK_SHIFT;
hysteresis = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_HYSTERESIS_INDEX];
hysteresis &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_HYSTERESIS_BITMASK;
hysteresis >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_HYSTERESIS_SHIFT;
control_event_mode = oem_data[IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_CONTROL_EVENT_MODE_INDEX];
control_event_mode &= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_CONTROL_EVENT_MODE_BITMASK;
control_event_mode >>= IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_CONTROL_EVENT_MODE_SHIFT;
if (memory_throttling_mode == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_MEMORY_THROTTLING_MODE_NONE_SUPPORTED)
memory_throttling_mode_str = "None Supported";
else if (memory_throttling_mode == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_MEMORY_THROTTLING_MODE_OPEN_LOOP_THROUGHPUT_THROTTLING)
memory_throttling_mode_str = "Open-loop throughput throttling (OLTT)";
else if (memory_throttling_mode == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_MEMORY_THROTTLING_MODE_CLOSE_LOOP_THERMAL_THROTTLING)
memory_throttling_mode_str = "Close-loop thermal throttling (CLTT)";
else
memory_throttling_mode_str = "Unspecified";
pstdout_printf (state_data->pstate,
"Memory Throttling Mode: %s\n",
memory_throttling_mode_str);
_ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record_fan_control_profile_support (state_data, fan_control_profile_support_0, 0);
_ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record_fan_control_profile_support (state_data, fan_control_profile_support_1, 1);
_ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record_fan_control_profile_support (state_data, fan_control_profile_support_2, 2);
_ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record_fan_control_profile_support (state_data, fan_control_profile_support_3, 3);
_ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record_fan_control_profile_support (state_data, fan_control_profile_support_4, 4);
_ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record_fan_control_profile_support (state_data, fan_control_profile_support_5, 5);
_ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record_fan_control_profile_support (state_data, fan_control_profile_support_6, 6);
_ipmi_sensors_oem_intel_quanta_qssc_s4r_output_oem_record_fan_control_profile_support (state_data, fan_control_profile_support_7, 7);
/* Stored in .5 C units */
pstdout_printf (state_data->pstate,
"Temperature at Chassis Inlet: %u C\n",
tempinlet/2);
/* Stored in .5 C units */
pstdout_printf (state_data->pstate,
"Temperature rise from Chassis Inlet to DIMM Local Ambient: %u C\n",
temprise/2);
/* Stored in mm/sec units */
pstdout_printf (state_data->pstate,
"Average air flow velocity in DIMM channel: %u m/sec\n",
(float)airflow/1000);
/* Stored in 1/1000 in units */
pstdout_printf (state_data->pstate,
"Pitch between DIMMS: %.2f in\n",
(float)dimmpitch/1000);
if (throttle_mode == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THROTTLE_MODE_DISABLED)
throttle_mode_str = "Disabled";
else if (throttle_mode == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THROTTLE_MODE_VTS_ONLY)
throttle_mode_str = "VTS Only (OLTT)";
else if (throttle_mode == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_THROTTLE_MODE_SOFTWARE_MODE)
throttle_mode_str = "Software Mode";
else
throttle_mode_str = "EXTTS CLTT";
pstdout_printf (state_data->pstate,
"Throttle Mode: %s\n",
throttle_mode_str);
pstdout_printf (state_data->pstate,
"Thermal Register Lock: %s\n",
thermal_register_lock ? "Enabled" : "Disabled");
if (hysteresis == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_HYSTERESIS_DISABLE)
hysteresis_str = "disable hysteresis";
else if (hysteresis == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_HYSTERESIS_1_5C)
hysteresis_str = "1.5C";
else if (hysteresis == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_HYSTERESIS_3C)
hysteresis_str = "3C";
else
hysteresis_str = "6C";
pstdout_printf (state_data->pstate,
"Hysteresis: %s\n",
hysteresis_str);
if (control_event_mode == IPMI_SDR_OEM_INTEL_QUANTA_QSSC_S4R_THERMAL_PROFILE_DATA_RECORD_CONTROL_EVENT_MODE_ASSERT_NOT_ONLY_CRITICAL)
control_event_mode_str = "Events asserted above high or low in addition to critical";
else
control_event_mode_str = "Events asserted only if above critical";
pstdout_printf (state_data->pstate,
"Control Event Mode: %s\n",
control_event_mode_str);
return (1);
}
int
ipmi_oem_fujitsu_get_remote_storage_status (ipmi_oem_state_data_t *state_data)
{
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
int rs_len;
uint8_t connection;
uint8_t storage_status;
uint8_t storage_type;
char *storage_status_str;
char *storage_type_str;
long tmp;
char *endptr;
int rv = -1;
assert (state_data);
assert (state_data->prog_data->args->oem_options_count == 1);
errno = 0;
tmp = strtol (state_data->prog_data->args->oem_options[0],
&endptr,
0);
if (errno
|| endptr[0] != '\0'
|| tmp < 0
|| tmp > UCHAR_MAX)
{
pstdout_fprintf (state_data->pstate,
stderr,
"%s:%s invalid OEM option argument '%s'\n",
state_data->prog_data->args->oem_id,
state_data->prog_data->args->oem_command,
state_data->prog_data->args->oem_options[0]);
goto cleanup;
}
if (!(tmp >= IPMI_OEM_FUJITSU_REMOTE_STORAGE_CONNECTION_MIN
&& tmp <= IPMI_OEM_FUJITSU_REMOTE_STORAGE_CONNECTION_MAX))
{
pstdout_fprintf (state_data->pstate,
stderr,
"%s:%s invalid OEM option argument '%s' : out of range\n",
state_data->prog_data->args->oem_id,
state_data->prog_data->args->oem_command,
state_data->prog_data->args->oem_options[0]);
goto cleanup;
}
connection = tmp;
/* Fujitsu OEM
*
* http://manuals.ts.fujitsu.com/file/4390/irmc_s2-en.pdf
*
* Request
*
* 0x30 - OEM network function
* 0x19 - OEM cmd
* 0x?? - "Command Specifier"
* - 0x01 - determine if storage media are connected
* - 0x02 - get remote storage status
* 0x?? - no apparent use
* 0x?? - if command specifier == 0x01
* - 0x00
* if command specifier == 0x02
* - 0x00 - connection 0
* - 0x01 - connection 2 ("2" - is this a typo in the document??)
*
* Response
*
* 0x19 - OEM cmd
* 0x?? - Completion code
* 0x?? - "Command Specifier"
* 0x?? - if command specifier == 0x01
* - connection status
* - 0x00 = no, 0x01 = yes
* - if command specifier == 0x02
* - 0x00
* 0x?? - if command specifier == 0x01
* - 0x00
* - if command specifier == 0x02
* - 0x00
* 0x?? - if command specifier == 0x01
* - 0x00
* - if command specifier == 0x02
* - remote storage status
* 0x?? - if command specifier == 0x01
* - N/A - not returned??
* - if command specifier == 0x02
* - remote storage type
*/
/* achu: we won't bother checking if there are any remote
* connections, just check the connection indicated by the user
*/
bytes_rq[0] = IPMI_CMD_OEM_FUJITSU_GET_REMOTE_STORAGE_CONNECTION_OR_STATUS;
bytes_rq[1] = IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_REMOTE_STORAGE_STATUS;
bytes_rq[2] = 0x00;
bytes_rq[3] = connection;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_FUJITSU_GENERIC_RQ, /* network function */
bytes_rq, /* data */
4, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
6,
IPMI_CMD_OEM_FUJITSU_GET_REMOTE_STORAGE_CONNECTION_OR_STATUS,
IPMI_NET_FN_OEM_FUJITSU_GENERIC_RS,
NULL) < 0)
goto cleanup;
storage_status = bytes_rs[4];
storage_type = bytes_rs[5];
switch (storage_status)
{
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_STATUS_INVALID_UNKNOWN:
storage_status_str = "Invalid / unknown";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_STATUS_IDLE:
storage_status_str = "idle";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_STATUS_CONNECTION_ATTEMPT_PENDING:
storage_status_str = "Connection Attempt pending";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_STATUS_CONNECTED:
storage_status_str = "Connected";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_STATUS_CONNECTION_ATTEMPTS_RETRIES_EXHAUSTED_FAILED:
storage_status_str = "Connection Attempts retries exhausted / failed";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_STATUS_CONNECTION_LOST:
storage_status_str = "Connection lost";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_STATUS_DISCONNECT_PENDING:
storage_status_str = "Disconnect pending";
break;
default:
storage_status_str = "Unknown Storage Status";
}
pstdout_printf (state_data->pstate,
"Storage Status : %s\n",
storage_status_str);
switch (storage_type)
{
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_TYPE_INVALID_UNKNOWN:
storage_type_str = "Invalid / unknown";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_TYPE_STORAGE_SERVER_IPMI:
storage_type_str = "Storage Server / IPMI";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_TYPE_APPLET:
storage_type_str = "Applet";
break;
case IPMI_OEM_FUJITSU_REMOTE_STORAGE_TYPE_NONE_NOT_CONNECTED:
storage_type_str = "None / Not connected";
break;
default:
storage_type_str = "Unknown Storage Type";
}
pstdout_printf (state_data->pstate,
"Storage Type : %s\n",
storage_type_str);
rv = 0;
cleanup:
return (rv);
}
int
ipmi_oem_supermicro_get_bmc_services_status (ipmi_oem_state_data_t *state_data)
{
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
int rs_len;
int rv = -1;
assert (state_data);
assert (!state_data->prog_data->args->oem_options_count);
/* Supermicro OEM
*
* Request
*
* 0x30 - OEM network function
* 0x70 - OEM cmd
* 0xF0 - Sub-command
* 0x?? - action
* - 0x00 - disable
* - 0x01 - enable
* - 0x02 - status
*
* Response
*
* 0x70 - OEM cmd
* 0x?? - Completion Code
* 0x?? - if action == status
* - 0x00 - disabled
* - 0x01 - enabled
*/
bytes_rq[0] = IPMI_CMD_OEM_SUPERMICRO_GENERIC_EXTENSION;
bytes_rq[1] = IPMI_OEM_SUPERMICRO_SUB_COMMAND_BMC_SERVICES;
bytes_rq[2] = IPMI_OEM_SUPERMICRO_BMC_SERVICES_ACTION_STATUS;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_SUPERMICRO_GENERIC_RQ, /* network function */
bytes_rq, /* data */
3, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
3,
IPMI_CMD_OEM_SUPERMICRO_GENERIC_EXTENSION,
IPMI_NET_FN_OEM_SUPERMICRO_GENERIC_RS,
NULL) < 0)
goto cleanup;
if (bytes_rs[2] == IPMI_OEM_SUPERMICRO_BMC_SERVICES_STATUS_DISABLED)
pstdout_printf (state_data->pstate, "disabled\n");
else if (bytes_rs[2] == IPMI_OEM_SUPERMICRO_BMC_SERVICES_STATUS_ENABLED)
pstdout_printf (state_data->pstate, "enabled\n");
else
pstdout_fprintf (state_data->pstate,
stderr,
"Unknown Non-IPMI Ports Status\n");
rv = 0;
cleanup:
return (rv);
}
int
ipmi_oem_fujitsu_get_system_status (ipmi_oem_state_data_t *state_data)
{
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
uint8_t system_status;
uint8_t signaling;
uint8_t post_code;
uint8_t system_power;
uint8_t sel_entries_available;
uint8_t watchdog_active;
uint8_t agent_connected;
uint8_t post_state;
uint8_t identify_led; /* rename from "localize" */
uint8_t css_led;
uint8_t global_error_led;
char *css_led_str = NULL;
char *global_error_led_str = NULL;
struct timeval t;
int rs_len;
int rv = -1;
assert (state_data);
assert (!state_data->prog_data->args->oem_options_count);
/* Fujitsu OEM
*
* http://manuals.ts.fujitsu.com/file/4390/irmc_s2-en.pdf
*
* Request
*
* 0x2E - OEM network function
* 0xF5 - OEM cmd
* 0x?? - Fujitsu IANA (LSB first)
* 0x?? - Fujitsu IANA
* 0x?? - Fujitsu IANA
* 0x10 - Command Specifier
* 0x?? - timestamp (LSB first)
* 0x?? - timestamp
* 0x?? - timestamp
* 0x?? - timestamp
*
* Response
*
* 0xF5 - OEM cmd
* 0x?? - Completion code
* 0x?? - Fujitsu IANA (LSB first)
* 0x?? - Fujitsu IANA
* 0x?? - Fujitsu IANA
* 0x?? - System Status
* bit 7 - System ON
* bit 6 -
* bit 5 -
* bit 4 - SEL entries available
* bit 3 -
* bit 2 - Watchdog active
* bit 1 - Agent connected
* bit 0 - Post State
* 0x?? - Signaling
* bit 7 - Identify LED (sometimes refered as "Localize")
* bit 6 -
* bit 5 -
* bit 4 -
* bit 3 - CSS LED (Customer Self Service LED)
* bit 2 - CSS LED (Customer Self Service LED)
* bit 1 - Global Error LED
* bit 0 - Global Error LED
* 0x?? - Notifications
* bit 7 - SEL Modified (New SEL Entry)
* bit 6 - SEL Modified (SEL Cleared)
* bit 5 - SDR Modified
* bit 4 - Nonvolatile IPMI Variable Modified
* bit 3 - ConfigSpace Modified
* bit 2 -
* bit 1 -
* bit 0 - New Output on LocalView display
* 0x?? - Last POST Code (Port 80) (HLiebig: renamed from "Post Code" in doc)
*
* achu: Docs say "timestamp is only relevant for evaluating the
* Notifications Byte". I assume this is because the Notifications
* timestamp indicates if things have changed in the SEL/SDR.
*/
if (gettimeofday (&t, NULL) < 0)
{
pstdout_perror (state_data->pstate, "gettimeofday");
goto cleanup;
}
bytes_rq[0] = IPMI_CMD_OEM_FUJITSU_SYSTEM;
bytes_rq[1] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x0000FF);
bytes_rq[2] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0x00FF00) >> 8;
bytes_rq[3] = (IPMI_IANA_ENTERPRISE_ID_FUJITSU & 0xFF0000) >> 16;
bytes_rq[4] = IPMI_OEM_FUJITSU_COMMAND_SPECIFIER_GET_SYSTEM_STATUS;
bytes_rq[5] = (t.tv_sec & 0x000000FF);
bytes_rq[6] = (t.tv_sec & 0x0000FF00) >> 8;
bytes_rq[7] = (t.tv_sec & 0x00FF0000) >> 16;
bytes_rq[8] = (t.tv_sec & 0xFF000000) >> 24;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_OEM_GROUP_RQ, /* network function */
bytes_rq, /* data */
9, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
9,
IPMI_CMD_OEM_FUJITSU_SYSTEM,
IPMI_NET_FN_OEM_GROUP_RS,
NULL) < 0)
goto cleanup;
/* achu: the "Notifications" are dependent on the timestamp input,
* we won't bother outputting them
*/
system_status = bytes_rs[5];
signaling = bytes_rs[6];
post_code = bytes_rs[8];
system_power = (system_status & IPMI_OEM_FUJITSU_SYSTEM_STATUS_SYSTEM_POWER_BITMASK);
system_power >>= IPMI_OEM_FUJITSU_SYSTEM_STATUS_SYSTEM_POWER_SHIFT;
sel_entries_available = (system_status & IPMI_OEM_FUJITSU_SYSTEM_STATUS_SEL_ENTRIES_AVAILABLE_BITMASK);
sel_entries_available >>= IPMI_OEM_FUJITSU_SYSTEM_STATUS_SEL_ENTRIES_AVAILABLE_SHIFT;
watchdog_active = (system_status & IPMI_OEM_FUJITSU_SYSTEM_STATUS_WATCHDOG_ACTIVE_BITMASK);
watchdog_active >>= IPMI_OEM_FUJITSU_SYSTEM_STATUS_WATCHDOG_ACTIVE_SHIFT;
agent_connected = (system_status & IPMI_OEM_FUJITSU_SYSTEM_STATUS_AGENT_CONNECTED_BITMASK);
agent_connected >>= IPMI_OEM_FUJITSU_SYSTEM_STATUS_AGENT_CONNECTED_SHIFT;
post_state = (system_status & IPMI_OEM_FUJITSU_SYSTEM_STATUS_POST_STATE_BITMASK);
post_state >>= IPMI_OEM_FUJITSU_SYSTEM_STATUS_POST_STATE_SHIFT;
identify_led = (signaling & IPMI_OEM_FUJITSU_SYSTEM_STATUS_SIGNALING_LOCAL_LED_BITMASK);
identify_led >>= IPMI_OEM_FUJITSU_SYSTEM_STATUS_SIGNALING_LOCAL_LED_SHIFT;
css_led = (signaling & IPMI_OEM_FUJITSU_SYSTEM_STATUS_SIGNALING_CSS_LED_BITMASK);
css_led >>= IPMI_OEM_FUJITSU_SYSTEM_STATUS_SIGNALING_CSS_LED_SHIFT;
global_error_led = (signaling & IPMI_OEM_FUJITSU_SYSTEM_STATUS_SIGNALING_GLOBAL_ERROR_LED_BITMASK);
global_error_led >>= IPMI_OEM_FUJITSU_SYSTEM_STATUS_SIGNALING_GLOBAL_ERROR_LED_SHIFT;
pstdout_printf (state_data->pstate,
"System Power : %s\n",
system_power ? "On" : "Off");
pstdout_printf (state_data->pstate,
"SEL Entries Available : %s\n",
sel_entries_available ? "Yes" : "No");
pstdout_printf (state_data->pstate,
"Watchdog Active : %s\n",
watchdog_active ? "Yes" : "No");
pstdout_printf (state_data->pstate,
"Agent Connected : %s\n",
agent_connected ? "Yes" : "No");
/* HLiebig: renamed from "Post State" in doc */
pstdout_printf (state_data->pstate,
"System in POST : %s\n",
post_state ? "Yes" : "No");
pstdout_printf (state_data->pstate,
"Identify LED : %s\n",
identify_led ? "On" : "Off");
switch (css_led)
{
case IPMI_OEM_FUJITSU_CSS_LED_OFF:
css_led_str = "Off";
break;
case IPMI_OEM_FUJITSU_CSS_LED_ON:
css_led_str = "On";
break;
case IPMI_OEM_FUJITSU_CSS_LED_BLINK:
css_led_str = "Blink";
break;
default:
css_led_str = "Unknown LED State";
}
pstdout_printf (state_data->pstate,
"CSS LED : %s\n",
css_led_str);
switch (global_error_led)
{
case IPMI_OEM_FUJITSU_GLOBAL_ERROR_LED_OFF:
global_error_led_str = "Off";
break;
case IPMI_OEM_FUJITSU_GLOBAL_ERROR_LED_ON:
global_error_led_str = "On";
break;
case IPMI_OEM_FUJITSU_GLOBAL_ERROR_LED_BLINK:
global_error_led_str = "Blink";
break;
default:
global_error_led_str = "Unknown LED State";
}
pstdout_printf (state_data->pstate,
"Global Error LED : %s\n",
global_error_led_str);
/* HLiebig: renamed from "Post Code" in doc */
pstdout_printf (state_data->pstate,
"Last POST Code (Port 80) : %02Xh\n",
post_code);
rv = 0;
cleanup:
return (rv);
}
int
ipmi_oem_supermicro_get_pmbus_power_supply_status (ipmi_oem_state_data_t *state_data)
{
uint8_t bytes_rq[IPMI_OEM_MAX_BYTES];
uint8_t bytes_rs[IPMI_OEM_MAX_BYTES];
int rs_len;
int rv = -1;
assert (state_data);
assert (state_data->prog_data->args->oem_options_count == 1);
if (strcasecmp (state_data->prog_data->args->oem_options[0], "1")
&& strcasecmp (state_data->prog_data->args->oem_options[0], "2")
&& strcasecmp (state_data->prog_data->args->oem_options[0], "3"))
{
pstdout_fprintf (state_data->pstate,
stderr,
"%s:%s invalid OEM option argument '%s'\n",
state_data->prog_data->args->oem_id,
state_data->prog_data->args->oem_command,
state_data->prog_data->args->oem_options[0]);
goto cleanup;
}
/* Supermicro OEM
* From Supermicro Engineer
*
* Request
*
* 0x06 - network function
* 0x52 - cmd (master read/write)
* 0x07 - (channel = 0, bus id = 3, bus type = private)
* 0x?? - slave address
* - 0x78 - ps 1
* - 0x7a - ps 2
* - 0x7c - ps 3
* 0x01 - read count
* 0x78 - data to write ... no idea why 0x78
*
* Response
*
* 0x52 - cmd
* 0x?? - Completion Code
* 0x?? - 0x01 - good
* - 0x00 - bad
*/
bytes_rq[0] = IPMI_CMD_MASTER_WRITE_READ;
bytes_rq[1] = IPMI_OEM_SUPERMICRO_GET_PMBUS_POWER_SUPPLY_STATUS_CHANNEL;
if (!strcasecmp (state_data->prog_data->args->oem_options[0], "1"))
bytes_rq[2] = IPMI_OEM_SUPERMICRO_GET_PMBUS_POWER_SUPPLY_STATUS_PS1;
else if (!strcasecmp (state_data->prog_data->args->oem_options[0], "2"))
bytes_rq[2] = IPMI_OEM_SUPERMICRO_GET_PMBUS_POWER_SUPPLY_STATUS_PS2;
else /* !strcasecmp (state_data->prog_data->args->oem_options[0], "3") */
bytes_rq[2] = IPMI_OEM_SUPERMICRO_GET_PMBUS_POWER_SUPPLY_STATUS_PS3;
bytes_rq[3] = 1;
bytes_rq[4] = IPMI_OEM_SUPERMICRO_GET_PMBUS_POWER_SUPPLY_STATUS_MAGIC;
if ((rs_len = ipmi_cmd_raw (state_data->ipmi_ctx,
0, /* lun */
IPMI_NET_FN_APP_RQ,
bytes_rq, /* data */
5, /* num bytes */
bytes_rs,
IPMI_OEM_MAX_BYTES)) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_cmd_raw: %s\n",
ipmi_ctx_errormsg (state_data->ipmi_ctx));
goto cleanup;
}
if (ipmi_oem_check_response_and_completion_code (state_data,
bytes_rs,
rs_len,
3,
IPMI_CMD_MASTER_WRITE_READ,
IPMI_NET_FN_APP_RQ,
NULL) < 0)
goto cleanup;
if (bytes_rs[2] == IPMI_OEM_SUPERMICRO_GET_PMBUS_POWER_SUPPLY_STATUS_GOOD)
pstdout_printf (state_data->pstate, "good\n");
else if (bytes_rs[2] == IPMI_OEM_SUPERMICRO_GET_PMBUS_POWER_SUPPLY_STATUS_BAD)
pstdout_printf (state_data->pstate, "bad\n");
else
pstdout_printf (state_data->pstate, "unknown\n");
rv = 0;
cleanup:
return (rv);
}
static int
_legacy_simple_output_full_record (ipmi_sensors_state_data_t *state_data,
uint16_t record_id,
double *sensor_reading,
int event_message_output_type,
uint16_t sensor_event_bitmask,
char **event_message_list,
unsigned int event_message_list_len)
{
uint8_t event_reading_type_code;
double *lower_non_critical_threshold = NULL;
double *upper_non_critical_threshold = NULL;
double *lower_critical_threshold = NULL;
double *upper_critical_threshold = NULL;
double *lower_non_recoverable_threshold = NULL;
double *upper_non_recoverable_threshold = NULL;
int rv = -1;
assert (state_data);
assert (IPMI_SENSORS_EVENT_VALID (event_message_output_type));
if (_legacy_simple_output_header (state_data, record_id) < 0)
goto cleanup;
if (ipmi_sdr_parse_event_reading_type_code (state_data->sdr_ctx,
NULL,
0,
&event_reading_type_code) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_event_reading_type_code: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
goto cleanup;
}
switch (ipmi_event_reading_type_code_class (event_reading_type_code))
{
case IPMI_EVENT_READING_TYPE_CODE_CLASS_THRESHOLD:
if (!state_data->prog_data->args->quiet_readings)
{
char sensor_units_buf[IPMI_SENSORS_UNITS_BUFLEN+1];
double *lower_output_threshold = NULL;
double *upper_output_threshold = NULL;
memset (sensor_units_buf, '\0', IPMI_SENSORS_UNITS_BUFLEN+1);
if (get_sensor_units_output_string (state_data->pstate,
state_data->sdr_ctx,
sensor_units_buf,
IPMI_SENSORS_UNITS_BUFLEN,
0) < 0)
goto cleanup;
if (ipmi_sensors_get_thresholds (state_data,
&lower_non_critical_threshold,
&lower_critical_threshold,
&lower_non_recoverable_threshold,
&upper_non_critical_threshold,
&upper_critical_threshold,
&upper_non_recoverable_threshold) < 0)
goto cleanup;
if (sensor_reading)
pstdout_printf (state_data->pstate,
"%.2f %s ",
_round_double2 (*sensor_reading),
sensor_units_buf);
else
pstdout_printf (state_data->pstate,
"%s ",
IPMI_SENSORS_NA_STRING_LEGACY);
/* default output is critical thresholds, if those aren't
* available, move to non-recoverable, and if those aren't
* available, move on to non-critical.
*/
if (lower_critical_threshold || upper_critical_threshold)
{
lower_output_threshold = lower_critical_threshold;
upper_output_threshold = upper_critical_threshold;
}
else if (lower_non_recoverable_threshold || upper_non_recoverable_threshold)
{
lower_output_threshold = lower_non_recoverable_threshold;
upper_output_threshold = upper_non_recoverable_threshold;
}
else if (lower_non_critical_threshold || upper_non_critical_threshold)
{
lower_output_threshold = lower_non_critical_threshold;
upper_output_threshold = upper_non_critical_threshold;
}
if (lower_output_threshold)
pstdout_printf (state_data->pstate,
"(%.2f/",
_round_double2 (*lower_output_threshold));
else
pstdout_printf (state_data->pstate, "(%s/", IPMI_SENSORS_NA_STRING_LEGACY);
if (upper_output_threshold)
pstdout_printf (state_data->pstate,
"%.2f): ",
_round_double2 (*upper_output_threshold));
else
pstdout_printf (state_data->pstate, "%s): ", IPMI_SENSORS_NA_STRING_LEGACY);
}
/* fall through and also output event messages */
case IPMI_EVENT_READING_TYPE_CODE_CLASS_GENERIC_DISCRETE:
case IPMI_EVENT_READING_TYPE_CODE_CLASS_SENSOR_SPECIFIC_DISCRETE:
case IPMI_EVENT_READING_TYPE_CODE_CLASS_OEM:
default:
if (ipmi_sensors_output_event_message_list (state_data,
event_message_output_type,
sensor_event_bitmask,
event_message_list,
event_message_list_len,
NULL,
0) < 0)
goto cleanup;
break;
}
rv = 0;
cleanup:
free (lower_non_critical_threshold);
free (upper_non_critical_threshold);
free (lower_critical_threshold);
free (upper_critical_threshold);
free (lower_non_recoverable_threshold);
free (upper_non_recoverable_threshold);
return (rv);
}
