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