static sdata_t *
alloc_sdata(ipmi_sensor_t *sensor)
{
sdata_t *sdata;
sdata = malloc(sizeof(*sdata));
if (!sdata)
return NULL;
sdata->es = malloc(ipmi_event_state_size());
if (!sdata->es) {
free(sdata);
return NULL;
}
ipmi_event_state_init(sdata->es);
sdata->th = malloc(ipmi_thresholds_size());
if (!sdata->th) {
free(sdata->es);
free(sdata);
return NULL;
}
ipmi_thresholds_init(sdata->th);
sdata->refcount = 1;
sdata->sensor_id = ipmi_sensor_convert_to_id(sensor);
ipmi_sensor_get_name(sensor, sdata->name, sizeof(sdata->name));
sdata->next = sdata_list;
sdata->prev = NULL;
sdata_list = sdata;
return sdata;
}
static sdata_t *
find_sdata(ipmi_sensor_t *sensor)
{
ipmi_sensor_id_t id = ipmi_sensor_convert_to_id(sensor);
sdata_t *link;
link = sdata_list;
while (link) {
if (ipmi_cmp_sensor_id(id, link->sensor_id) == 0)
return link;
link = link->next;
}
return NULL;
}
static void add_sensor_event(ipmi_entity_t *ent,
ipmi_sensor_t *sensor,
struct oh_handler_state *handler,
SaHpiEntityPathT parent_ep,
SaHpiResourceIdT rid)
{
struct ohoi_sensor_info *sensor_info;
struct oh_event *e;
struct ohoi_resource_info *info;
sensor_info = malloc(sizeof(*sensor_info));
if (!sensor_info) {
dbg("Out of memory for sensor info");
return;
}
sensor_info->sensor_id = ipmi_sensor_convert_to_id(sensor);
sensor_info->valid = 0;
sensor_info->enable = SAHPI_TRUE;
e = malloc(sizeof(*e));
if (!e) {
free(sensor_info);
dbg("Out of space");
return;
}
memset(e, 0, sizeof(*e));
e->type = OH_ET_RDR;
add_sensor_event_rdr(sensor, &e->u.rdr_event.rdr, parent_ep, rid);
info = oh_get_resource_data(handler->rptcache, rid);
if (!info) {
free(e);
dbg("No info in resource(%d)\n", rid);
return;
}
e->u.rdr_event.rdr.RdrTypeUnion.SensorRec.Num = info->sensor_count;
info->sensor_count++;
rid = oh_uid_lookup(&e->u.rdr_event.rdr.Entity);
oh_add_rdr(handler->rptcache, rid, &e->u.rdr_event.rdr, sensor_info, 1);
}
static void sensor_threshold_event(ipmi_sensor_t *sensor,
enum ipmi_event_dir_e dir,
enum ipmi_thresh_e threshold,
enum ipmi_event_value_dir_e high_low,
enum ipmi_value_present_e value_present,
unsigned int raw_value,
double value,
void *cb_data,
ipmi_event_t *event)
{
struct oh_event *e;
struct oh_handler_state *handler;
ipmi_entity_id_t entity_id;
ipmi_sensor_id_t sensor_id;
SaHpiSeverityT severity;
SaHpiRptEntryT *rpt_entry;
SaHpiRdrT *rdr;
unsigned char *data;
data = ipmi_event_get_data_ptr(event);
handler = cb_data;
entity_id = ipmi_entity_convert_to_id(ipmi_sensor_get_entity(sensor));
sensor_id = ipmi_sensor_convert_to_id(sensor);
rpt_entry = ohoi_get_resource_by_entityid(handler->rptcache, &entity_id);
rdr = ohoi_get_rdr_by_data(handler->rptcache,
rpt_entry->ResourceId,
SAHPI_SENSOR_RDR,
&sensor_id);
if (!rdr) {
dbg("No rdr in resource:%d\n", rpt_entry->ResourceId);
return;
}
e = malloc(sizeof(*e));
if (!e) {
dbg("Out of space");
return;
}
memset(e, 0, sizeof(*e));
e->type = OH_ET_HPI;
e->u.hpi_event.parent = rpt_entry->ResourceId;
e->u.hpi_event.event.Source = 0;
/* Do not find EventType in IPMI */
e->u.hpi_event.event.EventType = SAHPI_ET_SENSOR;
e->u.hpi_event.event.Timestamp
= (SaHpiTimeT)ipmi_get_uint32(data) * 1000000000;
e->u.hpi_event.event.EventDataUnion.SensorEvent.SensorNum
= rdr->RdrTypeUnion.SensorRec.Num;
e->u.hpi_event.event.EventDataUnion.SensorEvent.SensorType
= data[7];
e->u.hpi_event.event.EventDataUnion.SensorEvent.EventCategory
= data[9] & 0x7f;
set_thresholed_sensor_event_state(threshold, dir, high_low,
&e->u.hpi_event.event.EventDataUnion.SensorEvent,
&severity);
e->u.hpi_event.event.Severity = severity;
set_thresholds_sensor_misc_event
(event, &e->u.hpi_event.event.EventDataUnion.SensorEvent);
handler->eventq = g_slist_append(handler->eventq, e);
}
