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; }
static void mc_add(ipmi_mc_t *mc, struct oh_handler_state *handler) { struct ohoi_resource_info *ohoi_res_info; struct oh_event *e; struct ohoi_handler *ipmi_handler = handler->data; ohoi_res_info = g_malloc0(sizeof(*ohoi_res_info)); if (!ohoi_res_info) { dbg("Out of space"); return; } ohoi_res_info->type = OHOI_RESOURCE_MC; ohoi_res_info->u.mc_id = ipmi_mc_convert_to_id(mc); e = malloc(sizeof(*e)); if (!e) { dbg("Out of space"); return; } memset(e, 0, sizeof(*e)); e->type = OH_ET_RESOURCE; get_mc_entity_event(mc, &(e->u.res_event.entry), ipmi_handler); /* add to rptcache */ oh_add_resource(handler->rptcache, &(e->u.res_event.entry), ohoi_res_info, 1); }
void ohoi_mc_event(enum ipmi_update_e op, ipmi_domain_t *domain, ipmi_mc_t *mc, void *cb_data) { struct oh_handler_state *handler = cb_data; struct ohoi_handler *ipmi_handler = handler->data; int rv; if ((ipmi_mc_get_channel(mc) == 0) && (ipmi_mc_get_address(mc) == 32) && ipmi_handler->d_type == IPMI_DOMAIN_TYPE_ATCA) { ipmi_handler->virt_mcid = ipmi_mc_convert_to_id(mc); } g_static_rec_mutex_lock(&ipmi_handler->ohoih_lock); switch (op) { case IPMI_ADDED: /* if we get an MC but inactive, register a call to add it once it goes active */ rv = ipmi_mc_add_active_handler(mc, mc_active, handler); rv = ipmi_mc_set_sdrs_first_read_handler(mc, mc_processed, handler); if(!ipmi_mc_is_active(mc)) { trace_ipmi_mc("ADDED but inactive...we ignore", mc); break; } else { mc_add(mc, handler); break; } case IPMI_DELETED: trace_ipmi_mc("DELETED, but nothing done", mc); break; case IPMI_CHANGED: if(!ipmi_mc_is_active(mc)) { trace_ipmi("CHANGED and is inactive: (%d %x)\n", ipmi_mc_get_address(mc), ipmi_mc_get_channel(mc)); } else { mc_add(mc, handler); } break; } g_static_rec_mutex_unlock(&ipmi_handler->ohoih_lock); }
static void process_sel_support(ipmi_mc_t *mc, struct oh_handler_state *handler) { struct ohoi_resource_info *res_info; struct ohoi_handler *ipmi_handler = handler->data; ipmi_mcid_t mcid; SaHpiRptEntryT *rpt; mcid = ipmi_mc_convert_to_id(mc); rpt = ohoi_get_resource_by_mcid(handler->rptcache, &mcid); if (rpt == NULL) { trace_ipmi_mc("COULDN'T FIND RPT", mc); dbg("couldn't find out resource"); return; } res_info = oh_get_resource_data(handler->rptcache, rpt->ResourceId); if (ipmi_mc_sel_device_support(mc)) { rpt->ResourceCapabilities |= SAHPI_CAPABILITY_EVENT_LOG; entity_rpt_set_updated(res_info, ipmi_handler); } }
static void mc_remove(ipmi_mc_t *mc, struct oh_handler_state *handler) { struct ohoi_handler *ipmi_handler = handler->data; ipmi_mcid_t mcid; SaHpiRptEntryT *rpt; trace_ipmi_mc("REMOVED (not present)", mc); if (!IS_ATCA(ipmi_handler->d_type)) { return; } g_static_rec_mutex_lock(&ipmi_handler->ohoih_lock); mcid = ipmi_mc_convert_to_id(mc); ohoi_atca_delete_fru_rdrs(handler, mcid); rpt = ohoi_get_resource_by_mcid(handler->rptcache, &mcid); if (rpt == NULL) { trace_ipmi_mc("COULDN'T FIND RPT", mc); dbg("couldn't find out resource"); } else { rpt->ResourceCapabilities &= SAHPI_CAPABILITY_EVENT_LOG; } g_static_rec_mutex_unlock(&ipmi_handler->ohoih_lock); }
int ipmi_solparm_alloc(ipmi_mc_t *mc, unsigned int channel, ipmi_solparm_t **new_solparm) { ipmi_solparm_t *solparm = NULL; int rv = 0; ipmi_domain_t *domain = ipmi_mc_get_domain(mc); int p, len; locked_list_t *solparml; ipmi_domain_attr_t *attr; CHECK_MC_LOCK(mc); rv = ipmi_domain_register_attribute(domain, IPMI_SOLPARM_ATTR_NAME, solparm_attr_init, solparm_attr_destroy, NULL, &attr); if (rv) return rv; solparml = ipmi_domain_attr_get_data(attr); solparm = ipmi_mem_alloc(sizeof(*solparm)); if (!solparm) { rv = ENOMEM; goto out; } memset(solparm, 0, sizeof(*solparm)); solparm->refcount = 1; solparm->in_list = 1; solparm->mc = ipmi_mc_convert_to_id(mc); solparm->domain = ipmi_domain_convert_to_id(domain); len = sizeof(solparm->name); p = ipmi_domain_get_name(domain, solparm->name, len); len -= p; snprintf(solparm->name+p, len, ".%d", ipmi_domain_get_unique_num(domain)); solparm->os_hnd = ipmi_domain_get_os_hnd(domain); solparm->solparm_lock = NULL; solparm->channel = channel & 0xf; solparm->opq = opq_alloc(solparm->os_hnd); if (!solparm->opq) { rv = ENOMEM; goto out; } if (solparm->os_hnd->create_lock) { rv = solparm->os_hnd->create_lock(solparm->os_hnd, &solparm->solparm_lock); if (rv) goto out; } if (! locked_list_add(solparml, solparm, NULL)) { rv = ENOMEM; goto out; } out: if (rv) { if (solparm) { if (solparm->opq) opq_destroy(solparm->opq); if (solparm->solparm_lock) solparm->os_hnd->destroy_lock(solparm->os_hnd, solparm->solparm_lock); ipmi_mem_free(solparm); } } else { *new_solparm = solparm; } ipmi_domain_attr_put(attr); return rv; }
int ipmi_pet_create_mc(ipmi_mc_t *mc, unsigned int channel, struct in_addr ip_addr, unsigned char mac_addr[6], unsigned int eft_sel, unsigned int policy_num, unsigned int apt_sel, unsigned int lan_dest_sel, ipmi_pet_done_cb done, void *cb_data, ipmi_pet_t **ret_pet) { ipmi_pet_t *pet; int rv; os_handler_t *os_hnd; char domain_name[IPMI_MC_NAME_LEN]; ipmi_domain_t *domain = ipmi_mc_get_domain(mc); ipmi_domain_attr_t *attr; locked_list_t *pets; rv = ipmi_domain_register_attribute(domain, IPMI_PET_ATTR_NAME, pet_attr_init, pet_attr_destroy, NULL, &attr); if (rv) return rv; pets = ipmi_domain_attr_get_data(attr); pet = ipmi_mem_alloc(sizeof(*pet)); if (!pet) { ipmi_domain_attr_put(attr); return ENOMEM; } memset(pet, 0, sizeof(*pet)); ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); snprintf(pet->name, sizeof(pet->name), "%s.%d", domain_name, ipmi_domain_get_unique_num(domain)); pet->refcount = 1; pet->in_list = 1; pet->mc = ipmi_mc_convert_to_id(mc); pet->domain = ipmi_domain_convert_to_id(domain); pet->channel = channel; pet->ip_addr = ip_addr; pet->policy_num = policy_num; pet->eft_sel = eft_sel; pet->apt_sel = apt_sel; pet->lan_dest_sel = lan_dest_sel; pet->done = done; pet->cb_data = cb_data; memcpy(pet->mac_addr, mac_addr, sizeof(pet->mac_addr)); pet->in_progress = 0; /* Set up all the data we want in the PEF and LANPARMs configuration. */ pet->pef_check[0].conf_num = IPMI_PEFPARM_CONTROL; pet->pef_check[0].data_len = 1; pet->pef_check[0].data[0] = 1; pet->pef_check[0].mask[0] = 1; pet->pef_check[1].conf_num = IPMI_PEFPARM_ACTION_GLOBAL_CONTROL; pet->pef_check[1].data_len = 1; pet->pef_check[1].data[0] = 1; pet->pef_check[1].mask[0] = 1; pet->pef_check[2].conf_num = IPMI_PEFPARM_EVENT_FILTER_TABLE; pet->pef_check[2].set = eft_sel; pet->pef_check[2].data_len = 21; memset(pet->pef_check[2].data, 0xff, 10); memset(pet->pef_check[2].data+10, 0, 21-9); memset(pet->pef_check[2].mask, 0xff, 21); pet->pef_check[2].data[0] = eft_sel; pet->pef_check[2].mask[0] = 0x7f; pet->pef_check[2].data[1] = 0x80; pet->pef_check[2].mask[1] = 0x80; pet->pef_check[2].data[2] = 0x01; pet->pef_check[2].mask[2] = 0x3f; pet->pef_check[2].data[3] = policy_num; pet->pef_check[2].mask[3] = 0x0f; pet->pef_check[2].data[4] = 0; pet->pef_check[2].data[10] = 0xff; pet->pef_check[2].data[11] = 0xff; pet->pef_check[3].conf_num = IPMI_PEFPARM_ALERT_POLICY_TABLE; pet->pef_check[3].set = apt_sel; pet->pef_check[3].data_len = 4; pet->pef_check[3].data[0] = apt_sel; pet->pef_check[3].mask[0] = 0x7f; pet->pef_check[3].data[1] = 0x08 | (policy_num << 4); pet->pef_check[3].mask[1] = 0xff; pet->pef_check[3].data[2] = (channel << 4) | lan_dest_sel; pet->pef_check[3].mask[2] = 0xff; pet->pef_check[3].data[3] = 0; pet->pef_check[3].mask[3] = 0xff; pet->lanparm_check[0].conf_num = IPMI_LANPARM_DEST_TYPE; pet->lanparm_check[0].set = lan_dest_sel; pet->lanparm_check[0].data_len = 4; pet->lanparm_check[0].data[0] = lan_dest_sel; pet->lanparm_check[0].mask[0] = 0x0f; pet->lanparm_check[0].data[1] = 0x80; pet->lanparm_check[0].mask[1] = 0x87; pet->lanparm_check[0].data[2] = IPMI_LANPARM_DEFAULT_ALERT_RETRY_TIMEOUT; pet->lanparm_check[0].mask[2] = 0xff; pet->lanparm_check[0].data[3] = IPMI_LANPARM_DEFAULT_ALERT_RETRIES; pet->lanparm_check[0].mask[3] = 0x07; pet->lanparm_check[1].conf_num = IPMI_LANPARM_DEST_ADDR; pet->lanparm_check[1].set = lan_dest_sel; pet->lanparm_check[1].data_len = 13; pet->lanparm_check[1].data[0] = lan_dest_sel; pet->lanparm_check[1].mask[0] = 0x0f; pet->lanparm_check[1].data[1] = 0x00; pet->lanparm_check[1].mask[1] = 0xf0; pet->lanparm_check[1].data[2] = 0x00; pet->lanparm_check[1].mask[2] = 0x01; memset(pet->lanparm_check[1].mask+3, 0xff, 10); memcpy(pet->lanparm_check[1].data+3, &ip_addr, 4); memcpy(pet->lanparm_check[1].data+7, mac_addr, 6); os_hnd = ipmi_domain_get_os_hnd(domain); pet->os_hnd = os_hnd; /* Start a timer for this PET to periodically check it. */ pet->timer_info = ipmi_mem_alloc(sizeof(*(pet->timer_info))); if (!pet->timer_info) { rv = ENOMEM; goto out_err; } pet->timer_info->cancelled = 0; pet->timer_info->os_hnd = os_hnd; pet->timer_info->pet = pet; pet->timer_info->running = 0; pet->timer_info->lock = NULL; rv = os_hnd->alloc_timer(os_hnd, &pet->timer); if (rv) goto out_err; rv = ipmi_create_lock_os_hnd(os_hnd, &pet->timer_info->lock); if (rv) goto out_err; if (! locked_list_add(pets, pet, NULL)) { rv = ENOMEM; goto out_err; } ipmi_domain_attr_put(attr); rv = start_pet_setup(mc, pet); if (rv) goto out_err; if (ret_pet) *ret_pet = pet; return 0; out_err: locked_list_remove(pets, pet, NULL); ipmi_domain_attr_put(attr); if (pet->timer_info) { if (pet->timer) { if (os_hnd->stop_timer(os_hnd, pet->timer) == 0) { if (pet->timer_info->lock) ipmi_destroy_lock(pet->timer_info->lock); os_hnd->free_timer(os_hnd, pet->timer); ipmi_mem_free(pet->timer_info); } else { pet->timer_info->cancelled = 1; } } else ipmi_mem_free(pet->timer_info); } ipmi_mem_free(pet); return rv; }
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; }