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);
}
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);
}
