static void set_thresholds_sensor_misc_event(ipmi_event_t *event, SaHpiSensorEventT *e) { unsigned int type; unsigned char *data; data = ipmi_event_get_data_ptr(event); type = data[10] >> 6; if (type == EVENT_DATA_1) { e->TriggerReading.IsSupported = SAHPI_TRUE; e->TriggerReading.Type = SAHPI_SENSOR_READING_TYPE_UINT64; e->TriggerReading.Value.SensorUint64 = data[11]; } else if (type == EVENT_DATA_2) e->Oem = data[11]; else if (type == EVENT_DATA_3) e->SensorSpecific = data[11]; type = (data[10] & 0x30) >> 4; if (type == EVENT_DATA_1) { e->TriggerReading.IsSupported = SAHPI_TRUE; e->TriggerReading.Type = SAHPI_SENSOR_READING_TYPE_UINT64; e->TriggerReading.Value.SensorUint64 = data[12]; } else if (type == EVENT_DATA_2) e->Oem = data[12]; else if (type == EVENT_DATA_3) e->SensorSpecific = data[12]; }
static void set_thresholds_sensor_misc_event(ipmi_event_t *event, SaHpiSensorEventT *e) { unsigned int type; unsigned char *data; data = ipmi_event_get_data_ptr(event); type = data[10] >> 6; if (type == EVENT_DATA_1) { e->TriggerReading.ValuesPresent = SAHPI_SRF_RAW; e->TriggerReading.Raw = data[11]; } else if (type == EVENT_DATA_2) e->Oem = data[11]; else if (type == EVENT_DATA_3) e->SensorSpecific = data[11]; type = (data[10] & 0x30) >> 4; if (type == EVENT_DATA_1) { e->TriggerThreshold.ValuesPresent = SAHPI_SRF_RAW; e->TriggerThreshold.Raw = data[12]; } else if (type == EVENT_DATA_2) e->Oem = data[12]; else if (type == EVENT_DATA_3) e->SensorSpecific = data[12]; }
static void sensor_discrete_event(ipmi_sensor_t *sensor, enum ipmi_event_dir_e dir, int offset, int severity, int prev_severity, void *cb_data, ipmi_event_t *event) { struct oh_event *e; struct oh_handler_state *handler; ipmi_entity_id_t entity_id; SaHpiRptEntryT *rpt_entry; 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)); rpt_entry = ohoi_get_resource_by_entityid(handler->rptcache, &entity_id); if (!rpt_entry) { dump_entity_id("Discrete Sensor without RPT?!", entity_id); 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 = rpt_entry->ResourceId; /* 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.Severity = (SaHpiSeverityT)severity; e->u.hpi_event.event.EventDataUnion.SensorEvent.SensorNum = 0; e->u.hpi_event.event.EventDataUnion.SensorEvent.SensorType = data[7]; e->u.hpi_event.event.EventDataUnion.SensorEvent.EventCategory = data[9] & 0x7f; e->u.hpi_event.event.EventDataUnion.SensorEvent.Assertion = !(dir); e->u.hpi_event.event.EventDataUnion.SensorEvent.EventState = severity; e->u.hpi_event.event.EventDataUnion.SensorEvent.PreviousState = prev_severity; set_discrete_sensor_misc_event (event, &e->u.hpi_event.event.EventDataUnion.SensorEvent); handler->eventq = g_slist_append(handler->eventq, e); }
ipmi_sensor_id_t ipmi_event_get_generating_sensor_id(ipmi_domain_t *domain, ipmi_mc_t *sel_mc, const ipmi_event_t *event) { ipmi_sensor_id_t id; ipmi_mc_t *mc; const unsigned char *data; unsigned int type = ipmi_event_get_type(event); if (type != 0x02) /* It's not a standard IPMI event. */ goto out_invalid; mc = _ipmi_event_get_generating_mc(domain, sel_mc, event); if (!mc) goto out_invalid; data = ipmi_event_get_data_ptr(event); id.mcid = ipmi_mc_convert_to_id(mc); id.lun = data[5] & 0x3; id.sensor_num = data[8]; _ipmi_mc_put(mc); return id; out_invalid: ipmi_sensor_id_set_invalid(&id); return id; }
void event_handler(ipmi_con_t *ipmi, const ipmi_addr_t *addr, unsigned int addr_len, ipmi_event_t *event, void *cb_data) { unsigned int record_id = ipmi_event_get_record_id(event); unsigned int type = ipmi_event_get_type(event); unsigned int data_len = ipmi_event_get_data_len(event); const unsigned char *data = ipmi_event_get_data_ptr(event); unsigned int i; printf("Got event:\n"); printf(" %4.4x (%2.2x):", record_id, type); for (i=0; i<data_len; i++) printf(" %2.2x", data[i]); printf("\n"); }
static void set_discrete_sensor_misc_event(ipmi_event_t *event, SaHpiSensorEventT *e) { enum ohoi_event_type type; unsigned char *data; data = ipmi_event_get_data_ptr(event); type = data[10] >> 6; if (type == EVENT_DATA_2) e->Oem = data[11]; else if (type == EVENT_DATA_3) e->SensorSpecific = data[11]; type = (data[10] & 0x30) >> 4; if (type == EVENT_DATA_2) e->Oem = data[12]; else if (type == EVENT_DATA_3) e->SensorSpecific = data[12]; }
ipmi_mc_t * _ipmi_event_get_generating_mc(ipmi_domain_t *domain, ipmi_mc_t *sel_mc, const ipmi_event_t *event) { ipmi_ipmb_addr_t addr; const unsigned char *data; unsigned int type = ipmi_event_get_type(event); if (type != 0x02) /* It's not a standard IPMI event. */ return NULL; data = ipmi_event_get_data_ptr(event); addr.addr_type = IPMI_IPMB_ADDR_TYPE; /* See if the MC has an OEM handler for this. */ if (data[6] == 0x03) { addr.channel = 0; } else { addr.channel = data[5] >> 4; } if ((data[4] & 0x01) == 0) { addr.slave_addr = data[4]; } else if (sel_mc) { /* A software ID, assume it comes from the MC where we go it. */ ipmi_addr_t iaddr; ipmi_mc_get_ipmi_address(sel_mc, &iaddr, NULL); addr.slave_addr = ipmi_addr_get_slave_addr(&iaddr); if (addr.slave_addr == 0) /* A system interface, just assume it's the BMC. */ addr.slave_addr = 0x20; } else { return NULL; } addr.lun = 0; return _ipmi_find_mc_by_addr(domain, (ipmi_addr_t *) &addr, sizeof(addr)); }
static void set_discrete_sensor_event_state(ipmi_event_t *event, SaHpiEventStateT *state) { enum ohoi_discrete_e e; unsigned char *data; data = ipmi_event_get_data_ptr(event); e = data[10] & 0x7; switch (e) { case IPMI_TRANS_IDLE: *state = SAHPI_ES_IDLE; break; case IPMI_TRANS_ACTIVE: *state = SAHPI_ES_ACTIVE; break; case IPMI_TRANS_BUSY: *state = SAHPI_ES_BUSY; break; } }
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); }
static void entity_presence(ipmi_entity_t *entity, int present, void *cb_data, ipmi_event_t *event) { struct oh_handler_state *handler = (struct oh_handler_state *)cb_data; SaHpiRptEntryT *rpt; SaHpiResourceIdT rid; ipmi_entity_id_t ent_id; ent_id = ipmi_entity_convert_to_id(entity); rpt = ohoi_get_resource_by_entityid(handler->rptcache, &ent_id); if (!rpt) { dbg("No rpt"); return; } rid = rpt->ResourceId; dbg("%s %s",ipmi_entity_get_entity_id_string(entity), present?"present":"not present"); entity_update_rpt(handler->rptcache, rid, present); #if 0 /* The following code is masked by Racing. The reasons are listed as: 1. The hotswap event is not populated to HPI 2. The param 3 is changed to handler in ipmi_entity_set_presence_handler(entity, entity_presence, handler); 3. The orignal param (&entry.ResourceID) is a bug. Because entity_presence is callback function and entry.ResourceID is local variable, it may cause segment fault */ struct oh_event *e; SaHpiResourceIdT *rid = cb_data; 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 = *rid; e->u.hpi_event.id = 0; e->u.hpi_event.event.Source = 0; /* Do not find EventType in IPMI */ e->u.hpi_event.event.EventType = SAHPI_ET_HOTSWAP; /* FIXIT! */ if (event) e->u.hpi_event.event.Timestamp = ipmi_get_uint32(ipmi_event_get_data_ptr(event)); /* Do not find the severity of hotswap event */ e->u.hpi_event.event.Severity = SAHPI_MAJOR; if (present) e->u.hpi_event.event.EventDataUnion.HotSwapEvent.HotSwapState = SAHPI_HS_STATE_ACTIVE_HEALTHY; else e->u.hpi_event.event.EventDataUnion.HotSwapEvent.HotSwapState = SAHPI_HS_STATE_NOT_PRESENT; #endif }