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 int
_find_sensor_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_find_sensor_sdr_callback *sdr_callback_arg;
ipmi_oem_state_data_t *state_data;
uint8_t sdr_sensor_number;
assert (sdr_ctx);
assert (sdr_record);
assert (sdr_record_len);
assert (arg);
sdr_callback_arg = (struct ipmi_oem_ibm_find_sensor_sdr_callback *)arg;
state_data = sdr_callback_arg->state_data;
/* achu: xCAT only checks for Full records, I'll check compact too though */
if (record_type != IPMI_SDR_FORMAT_FULL_SENSOR_RECORD
&& record_type != IPMI_SDR_FORMAT_COMPACT_SENSOR_RECORD)
return (0);
if (ipmi_sdr_parse_sensor_number (state_data->sdr_ctx,
sdr_record,
sdr_record_len,
&sdr_sensor_number) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_parse_sensor_number: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
return (-1);
}
if (sdr_callback_arg->sensor_number == sdr_sensor_number)
{
if (ipmi_sdr_parse_id_string (state_data->sdr_ctx,
sdr_record,
sdr_record_len,
sdr_callback_arg->id_string,
sdr_callback_arg->id_string_len) < 0)
return (-1);
sdr_callback_arg->found = 1;
return (1);
}
return (0);
}
config_err_t
create_section_name (ipmi_sensors_config_state_data_t *state_data,
char *section_name,
unsigned int section_name_len)
{
char id_string[IPMI_SDR_MAX_ID_STRING_LENGTH + 1];
uint16_t record_id;
config_err_t rv = CONFIG_ERR_FATAL_ERROR;
config_err_t ret;
assert (state_data);
assert (section_name);
assert (section_name_len);
memset (section_name, '\0', section_name_len);
memset (id_string, '\0', IPMI_SDR_MAX_ID_STRING_LENGTH + 1);
if (ipmi_sdr_parse_record_id_and_type (state_data->sdr_ctx,
NULL,
0,
&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));
goto cleanup;
}
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));
goto cleanup;
}
if ((ret = convert_id_string (state_data, id_string)) != CONFIG_ERR_SUCCESS)
{
if (state_data->prog_data->args->config_args.common_args.debug)
pstdout_fprintf (state_data->pstate,
stderr,
"convert_id_string: %s\n",
strerror (errno));
rv = ret;
goto cleanup;
}
/* We will name sections by record_id then name, since id_strings
* could be identical.
*/
if (strlen (id_string) > 0)
snprintf (section_name,
CONFIG_MAX_SECTION_NAME_LEN,
"%u_%s",
record_id,
id_string);
else
/* I guess its conceivable the sensor won't have a name, so we
* make one up.
*/
snprintf (section_name,
CONFIG_MAX_SECTION_NAME_LEN,
"%u_%s",
record_id,
"Unknown_Sensor_Name");
rv = CONFIG_ERR_SUCCESS;
cleanup:
return (rv);
}
int
ipmi_sdr_parse_entity_sensor_name (ipmi_sdr_ctx_t ctx,
const void *sdr_record,
unsigned int sdr_record_len,
uint8_t sensor_number,
unsigned int flags,
char *buf,
unsigned int buflen)
{
char id_string[IPMI_SDR_MAX_ID_STRING_LENGTH + 1];
char device_id_string[IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH + 1];
char entity_name_buf[IPMI_SDR_ENTITY_NAME_BUFLEN + 1];
char *id_string_ptr = NULL;
uint8_t entity_id, entity_instance, entity_instance_type;
const char *entity_id_str;
uint8_t record_type;
unsigned int flags_mask = (IPMI_SDR_SENSOR_NAME_FLAGS_IGNORE_SHARED_SENSORS
| IPMI_SDR_SENSOR_NAME_FLAGS_ALWAYS_OUTPUT_INSTANCE_NUMBER);
if (!ctx || ctx->magic != IPMI_SDR_CTX_MAGIC)
{
ERR_TRACE (ipmi_sdr_ctx_errormsg (ctx), ipmi_sdr_ctx_errnum (ctx));
return (-1);
}
if (ctx->operation != IPMI_SDR_OPERATION_READ_CACHE)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_CACHE_READ_INITIALIZATION);
return (-1);
}
if (((sdr_record_len && !sdr_record_len)
|| (!sdr_record && sdr_record_len))
|| (flags & ~flags_mask)
|| !buf
|| !buflen)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_PARAMETERS);
return (-1);
}
memset (buf, '\0', buflen);
memset (entity_name_buf, '\0', IPMI_SDR_ENTITY_NAME_BUFLEN + 1);
if (ipmi_sdr_parse_record_id_and_type (ctx,
sdr_record,
sdr_record_len,
NULL,
&record_type) < 0)
return (-1);
if (record_type == IPMI_SDR_FORMAT_FULL_SENSOR_RECORD
|| record_type == IPMI_SDR_FORMAT_COMPACT_SENSOR_RECORD
|| record_type == IPMI_SDR_FORMAT_EVENT_ONLY_RECORD)
{
memset (id_string, '\0', IPMI_SDR_MAX_ID_STRING_LENGTH + 1);
if (ipmi_sdr_parse_id_string (ctx,
sdr_record,
sdr_record_len,
id_string,
IPMI_SDR_MAX_ID_STRING_LENGTH) < 0)
return (-1);
id_string_ptr = id_string;
}
else if (record_type == IPMI_SDR_FORMAT_GENERIC_DEVICE_LOCATOR_RECORD
|| record_type == IPMI_SDR_FORMAT_MANAGEMENT_CONTROLLER_DEVICE_LOCATOR_RECORD)
{
memset (device_id_string, '\0', IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH + 1);
if (ipmi_sdr_parse_device_id_string (ctx,
sdr_record,
sdr_record_len,
device_id_string,
IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH) < 0)
return (-1);
id_string_ptr = device_id_string;
}
else
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_PARSE_INVALID_SDR_RECORD);
return (-1);
}
if (ipmi_sdr_parse_entity_id_instance_type (ctx,
sdr_record,
sdr_record_len,
&entity_id,
&entity_instance,
&entity_instance_type) < 0)
return (-1);
/* Table 39-1
*
* "It is recommended that console software subtract 60h when
* presenting device-relative Entity Instance values, and present
* the Entity Instance number along with an ID for the device
* providing the interface to the entity."
*
* achu: For the time being we do not output the device providing
* the interface, only the right instance number. Adjust later if
* necessary.
*/
if (IPMI_ENTITY_INSTANCE_DEVICE_RELATIVE (entity_instance))
entity_instance -= IPMI_ENTITY_INSTANCE_DEVICE_RELATIVE_MIN;
entity_id_str = ipmi_get_entity_id_string (entity_id);
/* a few special cases, for entity_ids are special, the vendor has
* specifically stated there is no "entity" associated with this sdr
* record
*/
if (entity_id == IPMI_ENTITY_ID_UNSPECIFIED
|| entity_id == IPMI_ENTITY_ID_OTHER
|| entity_id == IPMI_ENTITY_ID_UNKNOWN)
snprintf (buf,
buflen,
"%s",
id_string_ptr);
else
{
if (ipmi_sdr_stats_compile (ctx) < 0)
return (-1);
if (ipmi_sdr_stats_entity_instance_unique (ctx, entity_id) > 1)
{
/* special case if sensor sharing is involved */
if ((record_type == IPMI_SDR_FORMAT_COMPACT_SENSOR_RECORD
|| record_type == IPMI_SDR_FORMAT_EVENT_ONLY_RECORD)
&& !(flags & IPMI_SDR_SENSOR_NAME_FLAGS_IGNORE_SHARED_SENSORS))
{
uint8_t share_count;
uint8_t entity_instance_sharing;
char sensor_name_buf[IPMI_SDR_MAX_SENSOR_NAME_LENGTH + 1];
if (ipmi_sdr_parse_sensor_record_sharing (ctx,
sdr_record,
sdr_record_len,
&share_count,
NULL,
NULL,
&entity_instance_sharing) < 0)
return (-1);
if (share_count > 1
&& entity_instance_sharing == IPMI_SDR_ENTITY_INSTANCE_INCREMENTS_FOR_EACH_SHARED_RECORD)
{
uint8_t sensor_number_base;
if (ipmi_sdr_parse_sensor_number (ctx,
sdr_record,
sdr_record_len,
&sensor_number_base) < 0)
return (-1);
/* I guess it's a bug if the sensor number passed in is bad */
if (sensor_number >= sensor_number_base)
entity_instance += (sensor_number - sensor_number_base);
else
goto fallthrough;
}
memset (sensor_name_buf, '\0', IPMI_SDR_MAX_SENSOR_NAME_LENGTH + 1);
if (_get_shared_sensor_name (ctx,
sdr_record,
sdr_record_len,
sensor_number,
id_string_ptr,
sensor_name_buf,
IPMI_SDR_MAX_SENSOR_NAME_LENGTH) < 0)
return (-1);
snprintf (entity_name_buf,
IPMI_SDR_ENTITY_NAME_BUFLEN,
"%s %u",
entity_id_str,
entity_instance);
/* In odd chance the strings end up identical */
if (!strcasecmp (entity_name_buf, sensor_name_buf))
snprintf (buf,
buflen,
"%s",
sensor_name_buf);
else
snprintf (buf,
buflen,
"%s %s",
entity_name_buf,
sensor_name_buf);
}
else
{
fallthrough:
snprintf (entity_name_buf,
IPMI_SDR_ENTITY_NAME_BUFLEN,
"%s %u",
entity_id_str,
entity_instance);
/* In odd chance the strings end up identical */
if (!strcasecmp (entity_name_buf, id_string_ptr))
snprintf (buf,
buflen,
"%s",
id_string_ptr);
else
snprintf (buf,
buflen,
"%s %s",
entity_name_buf,
id_string_ptr);
}
}
else
{
if (flags & IPMI_SDR_SENSOR_NAME_FLAGS_ALWAYS_OUTPUT_INSTANCE_NUMBER)
{
snprintf (entity_name_buf,
IPMI_SDR_ENTITY_NAME_BUFLEN,
"%s %u",
entity_id_str,
entity_instance);
/* In odd chance the strings end up identical */
if (!strcasecmp (entity_name_buf, id_string_ptr))
snprintf (buf,
buflen,
"%s",
id_string_ptr);
else
snprintf (buf,
buflen,
"%s %s",
entity_name_buf,
id_string_ptr);
}
else
{
/* In odd chance the strings end up identical */
if (!strcasecmp (entity_id_str, id_string_ptr))
snprintf (buf,
buflen,
"%s",
id_string_ptr);
else
snprintf (buf,
buflen,
"%s %s",
entity_id_str,
id_string_ptr);
}
}
}
return (0);
}
int
ipmi_sdr_parse_sensor_name (ipmi_sdr_ctx_t ctx,
const void *sdr_record,
unsigned int sdr_record_len,
uint8_t sensor_number,
unsigned int flags,
char *buf,
unsigned int buflen)
{
char id_string[IPMI_SDR_MAX_ID_STRING_LENGTH + 1];
char device_id_string[IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH + 1];
char *id_string_ptr = NULL;
uint8_t record_type;
unsigned int flags_mask = (IPMI_SDR_SENSOR_NAME_FLAGS_IGNORE_SHARED_SENSORS);
if (!ctx || ctx->magic != IPMI_SDR_CTX_MAGIC)
{
ERR_TRACE (ipmi_sdr_ctx_errormsg (ctx), ipmi_sdr_ctx_errnum (ctx));
return (-1);
}
if (ctx->operation != IPMI_SDR_OPERATION_READ_CACHE)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_CACHE_READ_INITIALIZATION);
return (-1);
}
if (((sdr_record_len && !sdr_record_len)
|| (!sdr_record && sdr_record_len))
|| (flags & ~flags_mask)
|| !buf
|| !buflen)
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_PARAMETERS);
return (-1);
}
memset (buf, '\0', buflen);
if (ipmi_sdr_parse_record_id_and_type (ctx,
sdr_record,
sdr_record_len,
NULL,
&record_type) < 0)
return (-1);
if (record_type == IPMI_SDR_FORMAT_FULL_SENSOR_RECORD
|| record_type == IPMI_SDR_FORMAT_COMPACT_SENSOR_RECORD
|| record_type == IPMI_SDR_FORMAT_EVENT_ONLY_RECORD)
{
memset (id_string, '\0', IPMI_SDR_MAX_ID_STRING_LENGTH + 1);
if (ipmi_sdr_parse_id_string (ctx,
sdr_record,
sdr_record_len,
id_string,
IPMI_SDR_MAX_ID_STRING_LENGTH) < 0)
return (-1);
id_string_ptr = id_string;
}
else if (record_type == IPMI_SDR_FORMAT_GENERIC_DEVICE_LOCATOR_RECORD
|| record_type == IPMI_SDR_FORMAT_FRU_DEVICE_LOCATOR_RECORD
|| record_type == IPMI_SDR_FORMAT_MANAGEMENT_CONTROLLER_DEVICE_LOCATOR_RECORD)
{
memset (device_id_string, '\0', IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH + 1);
if (ipmi_sdr_parse_device_id_string (ctx,
sdr_record,
sdr_record_len,
device_id_string,
IPMI_SDR_MAX_DEVICE_ID_STRING_LENGTH) < 0)
return (-1);
id_string_ptr = device_id_string;
}
else
{
SDR_SET_ERRNUM (ctx, IPMI_SDR_ERR_PARSE_INVALID_SDR_RECORD);
return (-1);
}
/* special case if sensor sharing is involved */
if ((record_type == IPMI_SDR_FORMAT_COMPACT_SENSOR_RECORD
|| record_type == IPMI_SDR_FORMAT_EVENT_ONLY_RECORD)
&& !(flags & IPMI_SDR_SENSOR_NAME_FLAGS_IGNORE_SHARED_SENSORS))
{
if (_get_shared_sensor_name (ctx,
sdr_record,
sdr_record_len,
sensor_number,
id_string_ptr,
buf,
buflen) < 0)
return (-1);
}
else
snprintf (buf,
buflen,
"%s",
id_string_ptr);
return (0);
}
