static void add_sensor_event_rdr(ipmi_sensor_t *sensor,
SaHpiRdrT *rdr,
SaHpiEntityPathT parent_ep,
SaHpiResourceIdT res_id)
{
char name[32];
//SaHpiEntityPathT rdr_ep;
memset(name,'\0',32);
rdr->RecordId = 0;
rdr->RdrType = SAHPI_SENSOR_RDR;
//rdr->Entity.Entry[0].EntityType = (SaHpiEntityTypeT)id;
//rdr->Entity.Entry[0].EntityInstance = (SaHpiEntityInstanceT)instance;
//rdr->Entity.Entry[1].EntityType = 0;
//rdr->Entity.Entry[1].EntityInstance = 0;
rdr->Entity = parent_ep;
/* append ep */
//string2entitypath(entity_root, &rdr_ep);
//ep_concat (&rdr->Entity, &rdr_ep);
add_sensor_event_sensor_rec(sensor, &rdr->RdrTypeUnion.SensorRec);
ipmi_sensor_get_id(sensor, name, 32);
rdr->IdString.DataType = SAHPI_TL_TYPE_ASCII6;
rdr->IdString.Language = SAHPI_LANG_ENGLISH;
rdr->IdString.DataLength = 32;
memcpy(rdr->IdString.Data,name, strlen(name) + 1);
}
static zbx_ipmi_sensor_t *allocate_ipmi_sensor(zbx_ipmi_host_t *h, ipmi_sensor_t *sensor)
{
const char *__function_name = "allocate_ipmi_sensor";
size_t sz;
zbx_ipmi_sensor_t *s;
char *s_name = NULL;
sz = (size_t)ipmi_sensor_get_id_length(sensor);
s_name = zbx_malloc(s_name, sz + 1);
ipmi_sensor_get_id(sensor, s_name, sz);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() sensor:'%s@[%s]:%d'", __function_name, s_name, h->ip, h->port);
h->sensor_count++;
sz = h->sensor_count * sizeof(zbx_ipmi_sensor_t);
if (NULL == h->sensors)
h->sensors = zbx_malloc(h->sensors, sz);
else
h->sensors = zbx_realloc(h->sensors, sz);
s = &h->sensors[h->sensor_count - 1];
memset(s, 0, sizeof(zbx_ipmi_sensor_t));
s->sensor = sensor;
s->s_name = s_name;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%p", __function_name, s);
return s;
}
static void
sensor_change(enum ipmi_update_e op,
ipmi_entity_t *ent,
ipmi_sensor_t *sensor,
void *cb_data)
{
int id, instance, rv;
char name[50];
id = ipmi_entity_get_entity_id(ent);
instance = ipmi_entity_get_entity_instance(ent);
ipmi_sensor_get_id(sensor, name, 50);
if (op == IPMI_ADDED) {
if (!strncmp(name, sname, 15)) {
int val;
val = ipmi_sensor_get_hysteresis_support(sensor);
if (val == IPMI_HYSTERESIS_SUPPORT_SETTABLE) {
printf("setting %s 's hysteresis...\n", name);
rv = ipmi_sensor_set_hysteresis(sensor, 1, 1,
set_data, &done);
if (rv)
printf("ipmi_sensor_set_hysteresis return :%d\n", rv);
}else {
printf("sensor don't support hysteresis set capability\n");
}
}
}
}
static void add_sensor_event_rdr(ipmi_sensor_t *sensor,
SaHpiRdrT *rdr,
SaHpiEntityPathT parent_ep,
SaHpiResourceIdT res_id)
{
char name[32];
//SaHpiEntityPathT rdr_ep;
memset(name,'\0',32);
rdr->RecordId = 0;
rdr->RdrType = SAHPI_SENSOR_RDR;
//rdr->Entity.Entry[0].EntityType = (SaHpiEntityTypeT)id;
//rdr->Entity.Entry[0].EntityLocation = (SaHpiEntityLocationT)instance;
//rdr->Entity.Entry[1].EntityType = 0;
//rdr->Entity.Entry[1].EntityLocation = 0;
rdr->Entity = parent_ep;
/* append ep */
//string2entitypath(entity_root, &rdr_ep);
//ep_concat (&rdr->Entity, &rdr_ep);
add_sensor_event_sensor_rec(sensor, &rdr->RdrTypeUnion.SensorRec);
ipmi_sensor_get_id(sensor, name, 32);
rdr->IdString.DataType = SAHPI_TL_TYPE_ASCII6;
rdr->IdString.Language = SAHPI_LANG_ENGLISH;
rdr->IdString.DataLength = 32;
switch ( ipmi_sensor_get_event_support(sensor) ) {
case IPMI_EVENT_SUPPORT_PER_STATE:
rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_PER_EVENT;
break;
/*Fix Me*/
#if 0
case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR:
rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_ENTIRE_SENSOR;
break;
case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE:
rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_GLOBAL_DISABLE;
break;
case IPMI_EVENT_SUPPORT_NONE:
rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_NO_EVENTS;
break;
#else
case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR:
case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE:
rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_READ_ONLY_MASKS;
break;
case IPMI_EVENT_SUPPORT_NONE:
rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_READ_ONLY;
break;
#endif
}
memcpy(rdr->IdString.Data,name, strlen(name) + 1);
}
static void set_data(ipmi_sensor_t *sensor, int err, void *cb_data)
{
int *done = cb_data;
char name[50];
ipmi_sensor_get_id(sensor, name, 50);
if (err)
printf("Something wrong in setting %s 's hysteresis", name);
*done = 1;
}
void ohoi_sensor_event(enum ipmi_update_e op,
ipmi_entity_t *ent,
ipmi_sensor_t *sensor,
void *cb_data)
{
char name[33];
int rv;
struct oh_handler_state *handler = cb_data;
ipmi_entity_id_t entity_id;
SaHpiRptEntryT *rpt_entry;
ipmi_sensor_get_id(sensor, name, 32);
entity_id = ipmi_entity_convert_to_id(ent);
rpt_entry = ohoi_get_resource_by_entityid(
handler->rptcache,
&entity_id);
if (!rpt_entry) {
dump_entity_id("Sensor without RPT Entry?!", entity_id);
return;
}
if ( op == IPMI_ADDED ) {
rpt_entry->ResourceCapabilities |= SAHPI_CAPABILITY_RDR
| SAHPI_CAPABILITY_SENSOR;
/* fill in the sensor data, add it to ipmi_event_list
* and finally to the rpt-cache
*/
add_sensor_event(ent, sensor, handler,
rpt_entry->ResourceEntity,
rpt_entry->ResourceId);
if (ipmi_sensor_get_event_reading_type(sensor) ==
IPMI_EVENT_READING_TYPE_THRESHOLD)
rv = ipmi_sensor_threshold_set_event_handler(
sensor, sensor_threshold_event, handler);
else
rv = ipmi_sensor_discrete_set_event_handler(
sensor, sensor_discrete_event, handler);
if (rv)
dbg("Unable to reg sensor event handler: %#x\n", rv);
}
}
static zbx_ipmi_sensor_t *allocate_ipmi_sensor(zbx_ipmi_host_t *h, ipmi_sensor_t *sensor)
{
const char *__function_name = "allocate_ipmi_sensor";
char id_str[2 * IPMI_SENSOR_ID_SZ + 1];
zbx_ipmi_sensor_t *s;
char id[IPMI_SENSOR_ID_SZ];
enum ipmi_str_type_e id_type;
int id_sz, sz;
char full_name[MAX_STRING_LEN];
id_sz = ipmi_sensor_get_id_length(sensor);
memset(id, 0, sizeof(id));
ipmi_sensor_get_id(sensor, id, sizeof(id));
id_type = ipmi_sensor_get_id_type(sensor);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() sensor:'%s@[%s]:%d'", __function_name,
sensor_id_to_str(id_str, sizeof(id_str), id, id_type, id_sz), h->ip, h->port);
h->sensor_count++;
sz = h->sensor_count * sizeof(zbx_ipmi_sensor_t);
if (NULL == h->sensors)
h->sensors = zbx_malloc(h->sensors, sz);
else
h->sensors = zbx_realloc(h->sensors, sz);
s = &h->sensors[h->sensor_count - 1];
s->sensor = sensor;
memcpy(s->id, id, sizeof(id));
s->id_type = id_type;
s->id_sz = id_sz;
memset(&s->value, 0, sizeof(s->value));
s->reading_type = ipmi_sensor_get_event_reading_type(sensor);
s->type = ipmi_sensor_get_sensor_type(sensor);
ipmi_sensor_get_name(s->sensor, full_name, sizeof(full_name));
zabbix_log(LOG_LEVEL_DEBUG, "Added sensor: host:'%s:%d' id_type:%d id_sz:%d id:'%s'"
" reading_type:0x%x ('%s') type:0x%x ('%s') full_name:'%s'", h->ip, h->port,
s->id_type, s->id_sz, sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz),
s->reading_type, ipmi_sensor_get_event_reading_type_string(s->sensor), s->type,
ipmi_sensor_get_sensor_type_string(s->sensor), full_name);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%p", __function_name, s);
return s;
}
static void
sensor_dump(ipmi_sensor_t *sensor, ipmi_cmd_info_t *cmd_info)
{
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
int num, lun;
char *str;
const char *cstr;
int event_support;
int event_reading_type;
int len;
int rv;
int val;
event_reading_type = ipmi_sensor_get_event_reading_type(sensor);
ipmi_sensor_get_num(sensor, &lun, &num);
ipmi_cmdlang_out_int(cmd_info, "LUN", lun);
ipmi_cmdlang_out_int(cmd_info, "Number", num);
ipmi_cmdlang_out_int(cmd_info, "Event Reading Type",
ipmi_sensor_get_event_reading_type(sensor));
ipmi_cmdlang_out(cmd_info, "Event Reading Type Name",
ipmi_sensor_get_event_reading_type_string(sensor));
ipmi_cmdlang_out_int(cmd_info, "Type",
ipmi_sensor_get_sensor_type(sensor));
ipmi_cmdlang_out(cmd_info, "Type Name",
ipmi_sensor_get_sensor_type_string(sensor));
val = ipmi_sensor_get_sensor_direction(sensor);
if (val != IPMI_SENSOR_DIRECTION_UNSPECIFIED)
ipmi_cmdlang_out(cmd_info, "Direction",
ipmi_get_sensor_direction_string(val));
event_support = ipmi_sensor_get_event_support(sensor);
switch (event_support) {
case IPMI_EVENT_SUPPORT_PER_STATE:
ipmi_cmdlang_out(cmd_info, "Event Support", "per state");
break;
case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR:
ipmi_cmdlang_out(cmd_info, "Event Support", "entire sensor");
break;
case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE:
ipmi_cmdlang_out(cmd_info, "Event Support", "global");
break;
default:
break;
}
ipmi_cmdlang_out_bool(cmd_info, "Init Scanning",
ipmi_sensor_get_sensor_init_scanning(sensor));
ipmi_cmdlang_out_bool(cmd_info, "Init Events",
ipmi_sensor_get_sensor_init_events(sensor));
ipmi_cmdlang_out_bool(cmd_info, "Init Thresholds",
ipmi_sensor_get_sensor_init_thresholds(sensor));
ipmi_cmdlang_out_bool(cmd_info, "Init Hysteresis",
ipmi_sensor_get_sensor_init_hysteresis(sensor));
ipmi_cmdlang_out_bool(cmd_info, "Init Type",
ipmi_sensor_get_sensor_init_type(sensor));
ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Events",
ipmi_sensor_get_sensor_init_pu_events(sensor));
ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Scanning",
ipmi_sensor_get_sensor_init_pu_scanning(sensor));
ipmi_cmdlang_out_bool(cmd_info, "Ignore If No Entity",
ipmi_sensor_get_ignore_if_no_entity(sensor));
ipmi_cmdlang_out_bool(cmd_info, "Auto Rearm",
ipmi_sensor_get_supports_auto_rearm(sensor));
ipmi_cmdlang_out_int(cmd_info, "OEM1",
ipmi_sensor_get_oem1(sensor));
len = ipmi_sensor_get_id_length(sensor);
if (len) {
str = ipmi_mem_alloc(len);
if (!str) {
cmdlang->err = ENOMEM;
cmdlang->errstr = "Out of memory";
goto out_err;
}
len = ipmi_sensor_get_id(sensor, str, len);
ipmi_cmdlang_out_type(cmd_info, "Id",
ipmi_sensor_get_id_type(sensor),
str, len);
ipmi_mem_free(str);
}
if (event_reading_type == IPMI_EVENT_READING_TYPE_THRESHOLD) {
int access = ipmi_sensor_get_threshold_access(sensor);
enum ipmi_thresh_e thresh;
enum ipmi_event_value_dir_e value_dir;
enum ipmi_event_dir_e dir;
int rv;
char th_name[50];
double dval;
ipmi_cmdlang_out(cmd_info, "Threshold Access",
ipmi_get_threshold_access_support_string(access));
for (thresh = IPMI_LOWER_NON_CRITICAL;
thresh <= IPMI_UPPER_NON_RECOVERABLE;
thresh++)
{
rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &val);
if ((rv) || !val)
continue;
ipmi_cmdlang_out(cmd_info, "Threshold", NULL);
ipmi_cmdlang_down(cmd_info);
ipmi_cmdlang_out(cmd_info, "Name",
ipmi_get_threshold_string(thresh));
rv = ipmi_sensor_threshold_readable(sensor, thresh, &val);
if (rv)
val = 0;
ipmi_cmdlang_out_bool(cmd_info, "Readable", val);
rv = ipmi_sensor_threshold_settable(sensor, thresh, &val);
if (rv)
val = 0;
ipmi_cmdlang_out_bool(cmd_info, "Settable", val);
for (value_dir = IPMI_GOING_LOW;
value_dir <= IPMI_GOING_HIGH;
value_dir++)
{
for (dir = IPMI_ASSERTION;
dir <= IPMI_DEASSERTION;
dir++)
{
rv = ipmi_sensor_threshold_event_supported(sensor,
thresh,
value_dir,
dir,
&val);
if (rv || !val) continue;
snprintf(th_name, sizeof(th_name), "%s %s",
ipmi_get_value_dir_string(value_dir),
ipmi_get_event_dir_string(dir));
ipmi_cmdlang_out(cmd_info, "Supports", th_name);
}
}
ipmi_cmdlang_up(cmd_info);
}
val = ipmi_sensor_get_hysteresis_support(sensor);
ipmi_cmdlang_out(cmd_info, "Hysteresis Support",
ipmi_get_hysteresis_support_string(val));
#if 0
/* FIXME - no accuracy handling */
int ipmi_sensor_get_accuracy(ipmi_sensor_t *sensor, int val,
double *accuracy);
#endif
rv = ipmi_sensor_get_nominal_reading(sensor, &dval);
if (!rv)
ipmi_cmdlang_out_double(cmd_info, "Nominal Reading", dval);
rv = ipmi_sensor_get_normal_max(sensor, &dval);
if (!rv)
ipmi_cmdlang_out_double(cmd_info, "Normal Max", dval);
rv = ipmi_sensor_get_normal_min(sensor, &dval);
if (!rv)
ipmi_cmdlang_out_double(cmd_info, "Normal Min", dval);
rv = ipmi_sensor_get_sensor_max(sensor, &dval);
if (!rv)
ipmi_cmdlang_out_double(cmd_info, "Sensor Max", dval);
rv = ipmi_sensor_get_sensor_min(sensor, &dval);
if (!rv)
ipmi_cmdlang_out_double(cmd_info, "Sensor Min", dval);
ipmi_cmdlang_out_int(cmd_info, "Base Unit",
ipmi_sensor_get_base_unit(sensor));
ipmi_cmdlang_out(cmd_info, "Base Unit Name",
ipmi_sensor_get_base_unit_string(sensor));
cstr = ipmi_sensor_get_rate_unit_string(sensor);
if (strlen(cstr)) {
ipmi_cmdlang_out_int(cmd_info, "Rate Unit",
ipmi_sensor_get_rate_unit(sensor));
ipmi_cmdlang_out(cmd_info, "Rate Unit Name", cstr);
}
switch (ipmi_sensor_get_modifier_unit_use(sensor)) {
case IPMI_MODIFIER_UNIT_BASE_DIV_MOD:
ipmi_cmdlang_out(cmd_info, "Modifier Use", "/");
ipmi_cmdlang_out_int(cmd_info, "Modifier Unit",
ipmi_sensor_get_modifier_unit(sensor));
ipmi_cmdlang_out(cmd_info, "Modifier Unit Name",
ipmi_sensor_get_modifier_unit_string(sensor));
break;
case IPMI_MODIFIER_UNIT_BASE_MULT_MOD:
ipmi_cmdlang_out(cmd_info, "Modifier Use", "*");
ipmi_cmdlang_out_int(cmd_info, "Modifier Unit",
ipmi_sensor_get_modifier_unit(sensor));
ipmi_cmdlang_out(cmd_info, "Modifier Unit Name",
ipmi_sensor_get_modifier_unit_string(sensor));
break;
default:
break;
}
if (ipmi_sensor_get_percentage(sensor))
ipmi_cmdlang_out(cmd_info, "Percentage", "%");
} else {
int event;
enum ipmi_event_dir_e dir;
for (event=0; event<15; event++) {
rv = ipmi_sensor_discrete_event_readable(sensor, event, &val);
if (rv || !val)
continue;
ipmi_cmdlang_out(cmd_info, "Event", NULL);
ipmi_cmdlang_down(cmd_info);
ipmi_cmdlang_out_int(cmd_info, "Offset", event);
cstr = ipmi_sensor_reading_name_string(sensor, event);
if (strcmp(cstr, "unknown") != 0)
ipmi_cmdlang_out(cmd_info, "Name", cstr);
for (dir = IPMI_ASSERTION;
dir <= IPMI_DEASSERTION;
dir++)
{
rv = ipmi_sensor_discrete_event_supported(sensor,
event,
dir,
&val);
if (rv || !val) continue;
ipmi_cmdlang_out(cmd_info, "Supports",
ipmi_get_event_dir_string(dir));
}
ipmi_cmdlang_up(cmd_info);
}
}
return;
out_err:
ipmi_sensor_get_name(sensor, cmdlang->objstr,
cmdlang->objstr_len);
cmdlang->location = "cmd_sensor.c(sensor_dump)";
}