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);
}
static int
rakp_get_msg_tag(unsigned char *tmsg,
unsigned int data_len,
unsigned char *tag)
{
if (data_len < 8)
return EINVAL;
*tag = ipmi_get_uint32(tmsg+4) - 1; /* session id */
return 0;
}
static int
handle_rakp4(ipmi_con_t *ipmi, ipmi_msgi_t *rspi)
{
ipmi_msg_t *msg = &rspi->msg;
rakp_info_t *info = rspi->data1;
int addr_num = (long) rspi->data4;
int rv;
uint32_t session_id;
/* In this function, there's not way to report the error to the
managed system, just report it locally. */
rv = check_rakp_rsp(ipmi, info, msg, "handle_rakp4", 8, addr_num);
if (rv)
goto out;
if (info->check4) {
rv = info->check4(info, msg->data, msg->data_len);
if (rv)
goto out;
}
session_id = ipmi_get_uint32(msg->data+4);
if (session_id != ipmi_rmcpp_auth_get_my_session_id(info->ainfo)) {
ipmi_log(IPMI_LOG_ERR_INFO,
"rakp.c(handle_rakp4): "
" Got wrong session id: 0x%x",
session_id);
rv = EINVAL;
goto out;
}
rakp_done(info, ipmi, addr_num, 0);
return IPMI_MSG_ITEM_NOT_USED;
out:
rakp_done(info, ipmi, addr_num, rv);
return IPMI_MSG_ITEM_NOT_USED;
}
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
}
static int
test_event_handler_0(ipmi_mc_t *mc,
ipmi_event_t *event,
void *cb_data)
{
unsigned char data[13];
ipmi_domain_t *domain = ipmi_mc_get_domain(mc);
ipmi_mc_t *src_mc;
ipmi_ipmb_addr_t addr;
if (ipmi_event_get_type(event) == 0xc0) {
ipmi_control_id_t id;
event_info_t info;
int rv;
ipmi_time_t timestamp;
if (ipmi_event_get_data(event, data, 0, 13) != 13)
return 0;
timestamp = ipmi_get_uint32(&data[0]);
if (timestamp < ipmi_mc_get_startup_SEL_time(mc))
/* It's an old event, ignore it. */
return 0;
if (data[6] != 1)
/* Wrong version */
return 0;
addr.addr_type = IPMI_IPMB_ADDR_TYPE;
addr.channel = 0;
addr.lun = 0;
addr.slave_addr = data[4];
/* Find the MC. */
src_mc = _ipmi_find_mc_by_addr(domain,
(ipmi_addr_t *) &addr,
sizeof(addr));
if (!src_mc)
return 0;
id.mcid = ipmi_mc_convert_to_id(src_mc);
id.lun = 4;
id.control_num = POWER_CONTROL(data[8]);
info.err = 0;
info.event = event;
info.valid_vals[0] = 1;
info.vals[0] = data[10];
info.handled = IPMI_EVENT_NOT_HANDLED;
rv = ipmi_control_pointer_cb(id, event_control_cb, &info);
if (!rv)
rv = info.err;
_ipmi_mc_put(src_mc);
if (!rv)
return 1;
}
return 0;
}
static int
handle_rakp2(ipmi_con_t *ipmi, ipmi_msgi_t *rspi)
{
ipmi_msg_t *msg = &rspi->msg;
rakp_info_t *info = rspi->data1;
int addr_num = (long) rspi->data4;
int rv;
uint32_t session_id;
int err = 0;
unsigned char *p;
unsigned int plen;
int rv2;
rv = check_rakp_rsp(ipmi, info, msg, "handle_rakp2", 40, addr_num);
if (rv) {
err = IPMI_RMCPP_ILLEGAL_PARAMETER;
goto out;
}
p = ipmi_rmcpp_auth_get_mgsys_rand(info->ainfo, &plen);
if (plen < 16)
return EINVAL;
memcpy(p, msg->data+8, 16);
ipmi_rmcpp_auth_set_mgsys_rand_len(info->ainfo, 16);
p = ipmi_rmcpp_auth_get_mgsys_guid(info->ainfo, &plen);
if (plen < 16)
return EINVAL;
memcpy(p, msg->data+24, 16);
ipmi_rmcpp_auth_set_mgsys_guid_len(info->ainfo, 16);
session_id = ipmi_get_uint32(msg->data+4);
if (session_id != ipmi_rmcpp_auth_get_my_session_id(info->ainfo)) {
ipmi_log(IPMI_LOG_ERR_INFO,
"rakp.c(handle_rakp2): "
" Got wrong session id: 0x%x",
session_id);
err = IPMI_RMCPP_INVALID_SESSION_ID;
goto out;
}
if (info->check2) {
rv = info->check2(info, msg->data, msg->data_len);
if (rv) {
if (DEBUG_RAWMSG || DEBUG_MSG_ERR)
ipmi_log(IPMI_LOG_DEBUG, "Integrity check fail for rakp 2");
err = IPMI_RMCPP_INVALID_INTEGRITY_CHECK_VALUE;
goto out;
}
}
rv = info->set(ipmi, addr_num, info->ainfo, info->cb_data);
if (rv) {
if (DEBUG_RAWMSG || DEBUG_MSG_ERR)
ipmi_log(IPMI_LOG_DEBUG, "Error setting values from rakp 2");
err = IPMI_RMCPP_INSUFFICIENT_RESOURCES_FOR_SESSION;
goto out;
}
rv = send_rakp3(ipmi, info, rspi, addr_num, 0);
if (rv) {
if (DEBUG_RAWMSG || DEBUG_MSG_ERR)
ipmi_log(IPMI_LOG_DEBUG, "Error sending rakp 3");
err = IPMI_RMCPP_INSUFFICIENT_RESOURCES_FOR_SESSION;
goto out;
}
return IPMI_MSG_ITEM_USED;
out:
rv2 = EINVAL;
if (ipmi)
rv2 = send_rakp3(ipmi, info, rspi, addr_num, err);
rakp_done(info, ipmi, addr_num, rv);
if (rv2)
return IPMI_MSG_ITEM_NOT_USED;
else
/* Yes, we use it to send the error response. */
return IPMI_MSG_ITEM_USED;
}
