/**
* rpt_diff
* @cur_rpt: IN. Pointer to RPTable that represents the current state of resources
* and rdrs.
* @new_rpt: IN. Pointer to RPTable that contains rpt entries and rdrs just recently
* discovered.
* @res_new: OUT. List of new or changed rpt entries
* @rdr_new: OUT. List of new or changed rdrs
* @res_gone: OUT. List of old and not present resources.
* @rdr_gone: OUT. List of old and not present rdrs.
*
* Extracts from current the resources and rdrs that are not found
* in new and puts them in res_gone and rdr_gone. Also, puts in res_new and rdr_new
* the resources and rdrs that are not already in current Or that are not identical
* to the ones in current.
*
* Returns: void.
**/
void rpt_diff(RPTable *cur_rpt, RPTable *new_rpt,
GSList **res_new, GSList **rdr_new,
GSList **res_gone, GSList **rdr_gone) {
SaHpiRptEntryT *res = NULL;
if (!cur_rpt || !new_rpt ||
!res_new || !rdr_new || !res_gone || !rdr_gone) return;
/* Look for absent resources and rdrs */
for (res = oh_get_resource_by_id(cur_rpt, SAHPI_FIRST_ENTRY);
res != NULL;
res = oh_get_resource_next(cur_rpt, res->ResourceId)) {
SaHpiRptEntryT *tmp_res = oh_get_resource_by_id(new_rpt, res->ResourceId);
if (tmp_res == NULL) *res_gone = g_slist_append(*res_gone, (gpointer)res);
else {
SaHpiRdrT *rdr = NULL;
for (rdr = oh_get_rdr_by_id(cur_rpt, res->ResourceId, SAHPI_FIRST_ENTRY);
rdr != NULL;
rdr = oh_get_rdr_next(cur_rpt, res->ResourceId, rdr->RecordId)) {
SaHpiRdrT *tmp_rdr =
oh_get_rdr_by_id(new_rpt, res->ResourceId, rdr->RecordId);
if (tmp_rdr == NULL)
*rdr_gone = g_slist_append(*rdr_gone, (gpointer)rdr);
}
}
}
/* Look for new resources and rdrs*/
for (res = oh_get_resource_by_id(new_rpt, SAHPI_FIRST_ENTRY);
res != NULL;
res = oh_get_resource_next(new_rpt, res->ResourceId)) {
SaHpiRptEntryT *tmp_res = oh_get_resource_by_id(cur_rpt, res->ResourceId);
SaHpiRdrT *rdr = NULL;
if (tmp_res == NULL || memcmp(res, tmp_res, sizeof(SaHpiRptEntryT))) {
*res_new = g_slist_append(*res_new, (gpointer)res);
}
for (rdr = oh_get_rdr_by_id(new_rpt, res->ResourceId, SAHPI_FIRST_ENTRY);
rdr != NULL;
rdr = oh_get_rdr_next(new_rpt, res->ResourceId, rdr->RecordId)) {
SaHpiRdrT *tmp_rdr = NULL;
if (tmp_res != NULL)
tmp_rdr = oh_get_rdr_by_id(cur_rpt, res->ResourceId, rdr->RecordId);
if (tmp_rdr == NULL || memcmp(rdr, tmp_rdr, sizeof(SaHpiRdrT)))
*rdr_new = g_slist_append(*rdr_new, (gpointer)rdr);
}
}
}
/**
* main: Starts with an RPTable of 10 resources, multiple rdrs
* on some resources. Remove resource. Check if resource was removed
* searching for it in sequence. If not fail, else passed test.
*
* Return value: 0 on success, 1 on failure
**/
int main(int argc, char **argv)
{
RPTable *rptable = (RPTable *)g_malloc0(sizeof(RPTable));
SaHpiRptEntryT *tmpentry = NULL;
guint i = 0;
for (i = 0; rptentries[i].ResourceId != 0; i++) {
if (oh_add_resource(rptable, rptentries + i, NULL, 0))
return 1;
}
for (i = 0; i < 5; i++) {
if (oh_add_rdr(rptable, SAHPI_FIRST_ENTRY, rdrs + i, NULL,0))
return 1;
}
for (; i < 7; i++) {
if (oh_add_rdr(rptable, rptentries[9].ResourceId, rdrs + i, NULL,0))
return 1;
}
oh_remove_resource(rptable, rptentries[0].ResourceId);
for (tmpentry = oh_get_resource_by_id(rptable, SAHPI_FIRST_ENTRY);
tmpentry;
tmpentry = oh_get_resource_next(rptable, tmpentry->ResourceId)) {
if (tmpentry->ResourceId == rptentries[0].ResourceId)
return 1;
}
return 0;
}
/**
* oHpiHandlerDestroy
* @sid: IN. a valid session id
* @id: IN. The id of the handler to destroy
*
* Destroys a handler. Calls the plugin's abi close function.
*
* Returns: SA_OK on success. Minus SA_OK on error.
**/
SaErrorT SAHPI_API oHpiHandlerDestroy (
SAHPI_IN SaHpiSessionIdT sid,
SAHPI_IN oHpiHandlerIdT id )
{
SaHpiDomainIdT did;
struct oh_domain *d = NULL;
SaErrorT error = SA_OK;
if (sid == 0)
return SA_ERR_HPI_INVALID_SESSION;
if (id == 0)
return SA_ERR_HPI_INVALID_PARAMS;
OH_CHECK_INIT_STATE(sid);
OH_GET_DID(sid, did);
OH_GET_DOMAIN(did, d); /* Lock domain */
if (oh_init()) error = SA_ERR_HPI_INTERNAL_ERROR;
if (error == SA_OK)
if (oh_destroy_handler(id)) error = SA_ERR_HPI_ERROR;
if (error == SA_OK) {
// Remove all handler remaing resources from the Domain RPT
SaHpiRptEntryT *rpte;
SaHpiResourceIdT rid;
GSList *events = 0;
rid = SAHPI_FIRST_ENTRY;
while ((rpte = oh_get_resource_next(&(d->rpt), rid)) != 0) {
const void * data;
data = oh_get_resource_data(&(d->rpt), rpte->ResourceId);
if (data) {
const unsigned int hid = *(const unsigned int*)(data);
if (hid == id) {
struct oh_event * e = g_new0(struct oh_event, 1);
e->hid = id;
e->resource = *rpte;
e->rdrs = 0;
e->rdrs_to_remove = 0;
e->event.Source = rpte->ResourceId;
e->event.EventType = SAHPI_ET_RESOURCE;
oh_gettimeofday(&e->event.Timestamp);
e->event.Severity = SAHPI_MAJOR;
e->event.EventDataUnion.ResourceEvent.ResourceEventType
= SAHPI_RESE_RESOURCE_REMOVED;
events = g_slist_prepend(events, e);
}
}
rid = rpte->ResourceId;
}
GSList *iter = events;
while (iter) {
oh_evt_queue_push(oh_process_q, iter->data);
iter = g_slist_next(iter);
}
g_slist_free(events);
}
int sim_util_get_res_id(RPTable *table, char *filename, SaHpiResourceIdT *rid)
{
SaHpiRptEntryT *entry;
SaHpiResourceIdT id;
for (id = RPT_ENTRY_BEGIN, entry = oh_get_resource_next(table, id);
entry; entry = oh_get_resource_next(table, entry->ResourceId)) {
char* data;
data = (char*) oh_get_resource_data(table, entry->ResourceId);
if (data == NULL) continue;
if (!strcmp(data, filename)) {
*rid = entry->ResourceId;
return 0;
}
}
return -1;
}
int eventq_event_add(struct oh_handler_state *oh_hnd)
{
struct oh_event event;
SaHpiRptEntryT *rpt_entry;
SaHpiRdrT *rdr_entry;
/* get the first rpt entry */
rpt_entry = oh_get_resource_next(oh_hnd->rptcache, RPT_ENTRY_BEGIN);
while (rpt_entry) {
memset(&event, 0, sizeof(event));
event.type = OH_ET_RESOURCE;
memcpy(&event.u.res_event.entry, rpt_entry, sizeof(SaHpiRptEntryT));
oh_hnd->eventq = g_slist_append(oh_hnd->eventq, eventdup(&event) );
/* get every resource rdr's */
rdr_entry = oh_get_rdr_next(oh_hnd->rptcache,
rpt_entry->ResourceId,
RDR_BEGIN);
while (rdr_entry) {
memset(&event, 0, sizeof(event));
event.type = OH_ET_RDR;
memcpy(&event.u.rdr_event.rdr, rdr_entry, sizeof(SaHpiRdrT));
oh_hnd->eventq = g_slist_append(oh_hnd->eventq, eventdup(&event));
rdr_entry = oh_get_rdr_next(oh_hnd->rptcache,
rpt_entry->ResourceId,
rdr_entry->RecordId);
}
/* get any resource rdr's end */
rpt_entry = oh_get_resource_next(oh_hnd->rptcache, rpt_entry->ResourceId);
}
return SA_OK;
}
/*XXX algorithm here is so ulgy! */
SaHpiRptEntryT *ohoi_get_resource_by_entityid(RPTable *table,
const ipmi_entity_id_t *entity_id)
{
struct ohoi_resource_info res_info1;
SaHpiRptEntryT *rpt_entry;
res_info1.type = OHOI_RESOURCE_ENTITY;
res_info1.u.entity_id = *entity_id;
rpt_entry = oh_get_resource_next(table, SAHPI_FIRST_ENTRY);
while (rpt_entry) {
struct ohoi_resource_info *ohoi_res_info;
ohoi_res_info = oh_get_resource_data(table, rpt_entry->ResourceId);
if (ohoi_resource_info_is_equal(res_info1, *ohoi_res_info)) {
return rpt_entry;
}
rpt_entry = oh_get_resource_next(table,
rpt_entry->ResourceId);
}
dbg("Not found resource by entity_id");
return NULL;
}
/**
* main: Adds 2 resources to an rpt table.
* Fetches the 2nd resource through the get_next call
* using a NULL table.
* Passes the test if the interface returns NULL, else it fails.
*
* Return value: 0 on success, 1 on failure
**/
int main(int argc, char **argv)
{
RPTable *rptable = (RPTable *)g_malloc0(sizeof(RPTable));
oh_init_rpt(rptable);
if (oh_add_resource(rptable, rptentries, NULL, 1))
return 1;
if (oh_add_resource(rptable, rptentries + 1, NULL, 1))
return 1;
if (oh_get_resource_next(NULL, rptentries[0].ResourceId))
return 1;
return 0;
}
/**
* main: Adds 10 resources to an rpt table.
* Fetches the 1st resource through the get_next call
* using SAHPI_FIRST_ENTRY for the Resource Id. Makes sure that the resource
* returned is the 1st resource.
* Passes the test if the interface returns a valid entry, else it fails.
*
* Return value: 0 on success, 1 on failure
**/
int main(int argc, char **argv)
{
RPTable *rptable = (RPTable *)g_malloc0(sizeof(RPTable));
oh_init_rpt(rptable);
SaHpiRptEntryT *tmpentry = NULL;
guint i;
for (i = 0; rptentries[i].ResourceId; i++) {
if (oh_add_resource(rptable, rptentries+i, NULL, 1))
return 1;
}
tmpentry = oh_get_resource_next(rptable, SAHPI_FIRST_ENTRY);
if (!tmpentry)
return 1;
if (tmpentry->ResourceId != rptentries[0].ResourceId)
return 1;
return 0;
}
/**
* main: Starts with an RPTable of 10 resources, starting at
* a random resource on going on to the next, compares
* resource ids against the originals. A failed comparison
* means the test failed, otherwise the test passed.
*
* Return value: 0 on success, 1 on failure
**/
int main(int argc, char **argv)
{
RPTable *rptable = (RPTable *)g_malloc0(sizeof(RPTable));
oh_init_rpt(rptable);
SaHpiRptEntryT *tmpentry = NULL;
guint i = 0, k = 0;
for (i = 0; rptentries[i].ResourceId != 0; i++) {
if (oh_add_resource(rptable, rptentries + i, NULL, 0))
return 1;
}
k = (guint) (((gfloat)i)*rand()/(RAND_MAX+1.0));
for (tmpentry = oh_get_resource_by_id(rptable, rptentries[k].ResourceId);
tmpentry;
tmpentry = oh_get_resource_next(rptable, tmpentry->ResourceId)) {
if (rptentries[k++].ResourceId != tmpentry->ResourceId)
return 1;
}
return 0;
}
