void list_sel(SaHpiSessionIdT session_id, SaHpiResourceIdT resource_id) { char str[256]; printf("SEL Info:\n"); SaHpiSelInfoT info; SaErrorT rv = saHpiEventLogInfoGet(session_id, resource_id, &info); if (rv != SA_OK) { printf( "Error=%d reading SEL info\n", rv); return; } printf("\tEntries in SEL: %d\n", info.Entries); printf("\tSize: %d\n", info.Size); time2str(info.UpdateTimestamp, str); printf("\tUpdateTimestamp: %s\n", str); time2str(info.CurrentTime, str); printf("\tCurrentTime : %s\n", str); printf("\tEnabled: %s\n", info.Enabled ? "true" : "false"); printf("\tOverflowFlag: %s\n", info.OverflowFlag ? "true" : "false"); printf("\tOverflowAction: " ); switch(info.OverflowAction) { case SAHPI_SEL_OVERFLOW_DROP: printf("SAHPI_SEL_OVERFLOW_DROP\n"); break; case SAHPI_SEL_OVERFLOW_WRAP: printf("SAHPI_SEL_OVERFLOW_WRAP\n"); break; case SAHPI_SEL_OVERFLOW_WRITELAST: printf("SAHPI_SEL_OVERFLOW_WRITELAST\n"); break; default: printf("unknown(0x%x)\n", info.OverflowAction); break; } printf("\tDeleteEntrySupported: %s\n", info.DeleteEntrySupported ? "true" : "false" ); if (info.Entries == 0) return; //else // read sel records SaHpiSelEntryIdT current = SAHPI_OLDEST_ENTRY; do { SaHpiSelEntryIdT prev; SaHpiSelEntryIdT next; SaHpiSelEntryT entry; SaHpiRdrT rdr; SaHpiRptEntryT res; rv = saHpiEventLogEntryGet(session_id, resource_id, current, &prev, &next, &entry, &rdr, &res); if (rv != SA_OK) { printf( "Error=%d reading SEL entry %d\n", rv, current); return; } printf("\t\tEntry %d, prev %d, next %d\n", entry.EntryId, prev, next); time2str(entry.Timestamp, str); printf("\t\t\tTimestamp: %s\n", str); SaHpiRptEntryT rres; rv = saHpiRptEntryGetByResourceId(session_id, entry.Event.Source, &rres ); if ( rv != SA_OK ) printf("\t\t\tSource: unknown\n" ); else { entitypath2string( &rres.ResourceEntity, str, sizeof(str)); printf("\t\t\tSource: %s\n", str ); } printf("\t\t\tEventType: %s\n", eventtype2str(entry.Event.EventType)); time2str(entry.Timestamp, str); printf("\t\t\tEvent timestamp: %s\n", str); printf("\t\t\tSeverity: %s\n", severity2str( entry.Event.Severity ) ); switch(entry.Event.EventType) { case SAHPI_ET_SENSOR: { SaHpiSensorEventT *se = &entry.Event.EventDataUnion.SensorEvent; printf("\t\t\tSensorNum: %d\n", se->SensorNum ); printf("\t\t\tSensorType: %s\n", get_sensor_type(se->SensorType ) ); printf("\t\t\tEventCategory: %s\n", get_sensor_category( se->EventCategory ) ); printf("\t\t\tAssertion: %s\n", se->Assertion ? "TRUE" : "FALSE" ); } break; case SAHPI_ET_HOTSWAP: { SaHpiHotSwapEventT *he = &entry.Event.EventDataUnion.HotSwapEvent; printf("\t\t\tHotSwapState: %s\n", hotswapstate2str( he->HotSwapState ) ); printf("\t\t\tPreviousHotSwapState: %s\n", hotswapstate2str( he->PreviousHotSwapState ) ); } break; case SAHPI_ET_WATCHDOG: break; case SAHPI_ET_OEM: break; case SAHPI_ET_USER: break; } current = next; } while(current != SAHPI_NO_MORE_ENTRIES); }
SaErrorT show_event_log(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid, int show_short, hpi_ui_print_cb_t proc) { SaErrorT rv = SA_OK; SaHpiRptEntryT rptentry; SaHpiEntryIdT rptentryid; SaHpiEntryIdT nextrptentryid; SaHpiEventLogInfoT info; SaHpiEventLogEntryIdT entryid; SaHpiEventLogEntryIdT nextentryid; SaHpiEventLogEntryIdT preventryid; SaHpiEventLogEntryT sel; SaHpiRdrT rdr; char buf[1024]; char date[30], date1[30]; rptentryid = SAHPI_FIRST_ENTRY; while (rptentryid != SAHPI_LAST_ENTRY) { rv = saHpiRptEntryGet(sessionid, rptentryid, &nextrptentryid, &rptentry); if (rv != SA_OK) { snprintf(buf, 1024, "ERROR: saHpiRptEntryGet error = %s\n", oh_lookup_error(rv)); proc(buf); return rv; }; if (rptentry.ResourceId == resourceid) { if (rptentry.ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG) break; else { proc("ERROR: The designated resource hasn't SEL.\n"); return rv; } }; rptentryid = nextrptentryid; } if (rptentryid == SAHPI_LAST_ENTRY) { snprintf(buf, 1024, "ERROR: no resource for resourceId = %d\n", resourceid); proc(buf); return rv; } rv = saHpiEventLogInfoGet(sessionid, resourceid, &info); if (rv != SA_OK) { snprintf(buf, 1024, "ERROR: saHpiEventLogInfoGet error = %s\n", oh_lookup_error(rv)); proc(buf); return -1; } snprintf(buf, 1024, "EventLog: entries = %d, size = %d, enabled = %d\n", info.Entries, info.Size, info.Enabled); proc(buf); time2str(info.UpdateTimestamp, date, 30); time2str(info.CurrentTime, date1, 30); snprintf(buf, 1024, "UpdateTime = %s CurrentTime = %s Overflow = %d\n", date, date1, info.OverflowFlag); proc(buf); if (info.Entries != 0){ entryid = SAHPI_OLDEST_ENTRY; while (entryid != SAHPI_NO_MORE_ENTRIES) { rv = saHpiEventLogEntryGet(sessionid, resourceid, entryid, &preventryid, &nextentryid, &sel, &rdr, NULL); if (rv != SA_OK) { snprintf(buf, 1024, "ERROR: saHpiEventLogEntryGet error = %s\n", oh_lookup_error(rv)); proc(buf); return -1; }; if (show_short) show_short_event(&(sel.Event)); else oh_print_eventlogentry(&sel, 1); preventryid = entryid; entryid = nextentryid; } } else { snprintf(buf, 1024, "SEL is empty\n"); proc(buf); }; return SA_OK; }
int main(int argc, char **argv) { int c, test_fail = 0, wait = 0; char *timeout_str= (char *)NULL; int do_discover_after_subscribe = 0; SaErrorT rv; SaHpiSessionIdT sessionid; SaHpiDomainInfoT domainInfo; SaHpiRptEntryT rptentry; SaHpiEntryIdT rptentryid; SaHpiEntryIdT nextrptentryid; SaHpiResourceIdT resourceid; SaHpiEventLogInfoT info; SaHpiRdrT rdr; SaHpiTimeoutT timeout; SaHpiEventT event; memset(&rptentry, 0, sizeof(rptentry)); printf("%s: version %s\n", argv[0], progver); while ( (c = getopt( argc, argv,"t:xd?")) != EOF ) { switch(c) { case 't': timeout_str = optarg; break; case 'd': do_discover_after_subscribe = 1; break; case 'x': fdebug = 1; break; default: Usage(argv); exit(1); } } if (timeout_str != (char *)NULL) { if ((strcmp(timeout_str, "SAHPI_TIMEOUT_BLOCK") == 0) || (strcmp(timeout_str, "BLOCK") == 0)) { timeout = SAHPI_TIMEOUT_BLOCK; } else { wait = atoi(timeout_str); timeout = (SaHpiTimeoutT)(wait * HPI_NSEC_PER_SEC); } } else timeout = (SaHpiTimeoutT) SAHPI_TIMEOUT_IMMEDIATE; printf("************** timeout:[%lld] ****************\n", timeout); rv = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID, &sessionid, NULL); if (rv != SA_OK) { if (rv == SA_ERR_HPI_ERROR) printf("saHpiSessionOpen: error %d, SpiLibd not running\n", rv); else printf("saHpiSessionOpen: %s\n", oh_lookup_error(rv)); exit(-1); } if (fdebug) printf("saHpiDiscover\n"); rv = saHpiDiscover(sessionid); if (rv != SA_OK) { printf("saHpiDiscover: %s\n", oh_lookup_error(rv)); exit(-1); } if (fdebug) printf( "Subscribe to events\n"); rv = saHpiSubscribe( sessionid ); if (rv != SA_OK) { printf("saHpiSubscribe: %s\n", oh_lookup_error(rv)); exit(-1); } if (do_discover_after_subscribe) { if (fdebug) printf("saHpiDiscover after saHpiSubscribe\n"); rv = saHpiDiscover(sessionid); if (rv != SA_OK) { printf("saHpiDiscover after saHpiSubscribe: %s\n", oh_lookup_error(rv)); exit(-1); } } rv = saHpiDomainInfoGet(sessionid, &domainInfo); if (fdebug) printf("saHpiDomainInfoGet %s\n", oh_lookup_error(rv)); printf("DomainInfo: UpdateCount = %d, UpdateTime = %lx\n", domainInfo.RptUpdateCount, (unsigned long)domainInfo.RptUpdateTimestamp); /* walk the RPT list */ rptentryid = SAHPI_FIRST_ENTRY; while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY)) { printf("**********************************************\n"); rv = saHpiRptEntryGet(sessionid, rptentryid, &nextrptentryid, &rptentry); if (fdebug) printf("saHpiRptEntryGet %s\n", oh_lookup_error(rv)); if (rv == SA_OK) { resourceid = rptentry.ResourceId; if (fdebug) printf("RPT %x capabilities = %x\n", resourceid, rptentry.ResourceCapabilities); if ( (rptentry.ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) { /* Using EventLogInfo to build up event queue - for now */ rv = saHpiEventLogInfoGet(sessionid, resourceid, &info); if (fdebug) printf("saHpiEventLogInfoGet %s\n", oh_lookup_error(rv)); if (rv == SA_OK) oh_print_eventloginfo(&info, 4); } else { if (fdebug) printf("RPT doesn't have SEL\n"); } rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0; printf("rptentry[%d] tag: %s\n", resourceid, rptentry.ResourceTag.Data); rptentryid = nextrptentryid; } printf("**********************************************\n"); } printf( "Go and get the event\n"); while (1) { rdr.RdrType = SAHPI_NO_RECORD; rv = saHpiEventGet( sessionid, timeout, &event, &rdr, &rptentry, NULL); if (rv != SA_OK) { if (rv != SA_ERR_HPI_TIMEOUT) { printf("ERROR during EventGet : %s\n", oh_lookup_error(rv)); test_fail = 1; } else { if (timeout == SAHPI_TIMEOUT_BLOCK) { printf("ERROR: Timeout while infinite wait\n"); test_fail = 1; } else if (timeout != SAHPI_TIMEOUT_IMMEDIATE) { printf("ERROR: Time, %d seconds, expired waiting" " for event\n", wait); test_fail = 1; } } break; } else { oh_print_event(&event, 4); } } if (test_fail == 0) printf(" Test PASS.\n"); else printf(" Test FAILED.\n"); /* Unsubscribe to future events */ if (fdebug) printf( "Unsubscribe\n"); rv = saHpiUnsubscribe( sessionid ); rv = saHpiSessionClose(sessionid); return(0); }
int main(int argc, char **argv) { int c; oh_big_textbuffer bigbuf2; SaErrorT rv, rv_2; SaHpiVersionT hpiVer; SaHpiSessionIdT sessionid; /* Domain */ SaHpiDomainInfoT domainInfo; SaHpiRptEntryT rptentry; SaHpiEntryIdT rptentryid; SaHpiEntryIdT nextrptentryid; SaHpiResourceIdT resourceid; SaHpiEventLogEntryIdT entryid; SaHpiEventLogEntryIdT nextentryid; SaHpiEventLogEntryIdT preventryid; SaHpiEventLogInfoT info; SaHpiEventLogEntryT el; SaHpiRdrT rdr, *rdrptr; SaHpiRptEntryT rpt_2nd, *rptptr; int free = 50; printf("%s: version %s\n",argv[0],progver); while ( (c = getopt( argc, argv,"cdpx?")) != EOF ) switch(c) { case 'c': fclear = 1; break; case 'd': frdr = 1; break; case 'p': frpt = 1; break; case 'x': fdebug = 1; break; default: printf("\n\n\nUsage %s [-cdpx]\n",argv[0]); printf(" Where \n"); printf(" -c clears the event log\n"); printf(" -d also get RDR with the event log\n"); printf(" -p also get RPT with the event log\n"); printf(" -x displays eXtra debug messages\n\n\n"); exit(1); } /* * House keeping: * -- get (check?) hpi implementation version * -- open hpi session */ if (fdebug) printf("saHpiVersionGet\n"); hpiVer = saHpiVersionGet(); printf("Hpi Version %d Implemented.\n", hpiVer); rv = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID,&sessionid,NULL); if (rv != SA_OK) { if (rv == SA_ERR_HPI_ERROR) printf("saHpiSessionOpen: error %d, SpiLibd not running\n",rv); else printf("saHpiSessionOpen: %s\n", oh_lookup_error(rv)); exit(-1); } rv = saHpiDiscover(sessionid); if (fdebug) printf("saHpiResourcesDiscover %s\n", oh_lookup_error(rv)); rv = saHpiDomainInfoGet(sessionid, &domainInfo); if (fdebug) printf("saHpiDomainInfoGet %s\n", oh_lookup_error(rv)); printf("DomainInfo: UpdateCount = %d, UpdateTime = %lx\n", domainInfo.RptUpdateCount, (unsigned long)domainInfo.RptUpdateTimestamp); /* walk the RPT list */ rptentryid = SAHPI_FIRST_ENTRY; while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY)) { rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry); if (fdebug) printf("saHpiRptEntryGet %s\n", oh_lookup_error(rv)); if (rv == SA_OK) { resourceid = rptentry.ResourceId; if (fdebug) printf("RPT %d capabilities = %x\n", resourceid, rptentry.ResourceCapabilities); if (!(rptentry.ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) { if (fdebug) printf("RPT doesn't have SEL\n"); rptentryid = nextrptentryid; continue; /* no SEL here, try next RPT */ } rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0; rv_2 = oh_init_bigtext(&bigbuf2); if (rv_2) return(rv_2); rv = oh_decode_entitypath(&rptentry.ResourceEntity, &bigbuf2); printf("%s\n", bigbuf2.Data); printf("rptentry[%d] tag: %s\n", resourceid,rptentry.ResourceTag.Data); /* initialize structure */ info.Entries = 0; info.Size = 0; info.Enabled = 0; rv_2 = saHpiEventLogInfoGet(sessionid,resourceid,&info); if (fdebug) printf("saHpiEventLogInfoGet %s\n", oh_lookup_error(rv)); if (rv_2 == SA_OK) { printf("EventLogInfo for %s, ResourceId %d\n", rptentry.ResourceTag.Data, resourceid); oh_print_eventloginfo(&info, 4); } else { printf("saHpiEventLogInfoGet %s\n", oh_lookup_error(rv_2)); } if (fclear) { rv = saHpiEventLogClear(sessionid,resourceid); if (rv == SA_OK) printf("EventLog successfully cleared\n"); else printf("EventLog clear, error = %d, %s\n", rv, oh_lookup_error(rv)); break; } if (info.Entries != 0){ entryid = SAHPI_OLDEST_ENTRY; while ((rv == SA_OK) && (entryid != SAHPI_NO_MORE_ENTRIES)) { if (frdr) rdrptr = &rdr; else rdrptr = NULL; if (frpt) rptptr = &rpt_2nd; else rptptr = NULL; if(fdebug) printf("rdrptr %p, rptptr %p\n", rdrptr, rptptr); rv = saHpiEventLogEntryGet(sessionid,resourceid, entryid,&preventryid, &nextentryid, &el,rdrptr,rptptr); if (fdebug) printf("saHpiEventLogEntryGet %s\n", oh_lookup_error(rv)); if (rv == SA_OK) { oh_print_eventlogentry(&el, 6); if (frdr) { if (rdrptr->RdrType == SAHPI_NO_RECORD) printf(" No RDR associated with EventType = %s\n\n", oh_lookup_eventtype(el.Event.EventType)); else oh_print_rdr(rdrptr, 12); } if (frpt) { if (rptptr->ResourceCapabilities == 0) printf(" No RPT associated with EventType = %s\n\n", oh_lookup_eventtype(el.Event.EventType)); else oh_print_rptentry(rptptr, 10); } preventryid = entryid; entryid = nextentryid; } } } else printf("\tSEL is empty.\n\n"); if (free < 6) { printf("WARNING: Log free space is very low (%d records)\n",free); printf("\tClear log with hpiel -c\n"); } } rptentryid = nextrptentryid; } printf("done.\n"); rv = saHpiSessionClose(sessionid); return(0); }
int main(int argc, char **argv) { int c, wait = 0; SaErrorT rv; SaHpiVersionT hpiVer; SaHpiSessionIdT sessionid; SaHpiRptInfoT rptinfo; SaHpiRptEntryT rptentry; SaHpiEntryIdT rptentryid; SaHpiEntryIdT nextrptentryid; SaHpiResourceIdT resourceid; SaHpiSelInfoT info; SaHpiRdrT rdr; SaHpiTimeoutT timeout; SaHpiEventT event; printf("%s: version %s\n",argv[0],progver); while ( (c = getopt( argc, argv,"t:x?")) != EOF ) switch(c) { case 't': ftimer = 1; wait = atoi(optarg); break; case 'x': fdebug = 1; break; default: printf("Usage %s [-tx]\n",argv[0]); printf(" -t <value>:wait <value> seconds for event\n"); printf(" -x :displays eXtra debug messages\n"); exit(1); } if (ftimer) timeout = (SaHpiInt64T)(wait * HPI_NSEC_PER_SEC); else timeout = (SaHpiInt64T) SAHPI_TIMEOUT_IMMEDIATE; rv = saHpiInitialize(&hpiVer); if (rv != SA_OK) { printf("saHpiInitialize: %s\n",decode_error(rv)); exit(-1); } rv = saHpiSessionOpen(SAHPI_DEFAULT_DOMAIN_ID,&sessionid,NULL); if (rv != SA_OK) { if (rv == SA_ERR_HPI_ERROR) printf("saHpiSessionOpen: error %d, SpiLibd not running\n",rv); else printf("saHpiSessionOpen: %s\n",decode_error(rv)); exit(-1); } rv = saHpiResourcesDiscover(sessionid); if (fdebug) printf("saHpiResourcesDiscover %s\n",decode_error(rv)); rv = saHpiRptInfoGet(sessionid,&rptinfo); if (fdebug) printf("saHpiRptInfoGet %s\n",decode_error(rv)); printf("RptInfo: UpdateCount = %d, UpdateTime = %lx\n", rptinfo.UpdateCount, (unsigned long)rptinfo.UpdateTimestamp); printf( "Subscribe to events\n"); rv = saHpiSubscribe( sessionid, (SaHpiBoolT)0 ); if (rv != SA_OK) return rv; /* walk the RPT list */ rptentryid = SAHPI_FIRST_ENTRY; while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY)) { rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry); if (fdebug) printf("saHpiRptEntryGet %s\n",decode_error(rv)); if (rv == SA_OK) { resourceid = rptentry.ResourceId; if (fdebug) printf("RPT %x capabilities = %x\n", resourceid, rptentry.ResourceCapabilities); if (!(rptentry.ResourceCapabilities & SAHPI_CAPABILITY_SEL)) { if (fdebug) printf("RPT doesn't have SEL\n"); rptentryid = nextrptentryid; continue; /* no SEL here, try next RPT */ } rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0; printf("rptentry[%d] tag: %s\n", resourceid,rptentry.ResourceTag.Data); /* Using EventLogInfo to build up event queue - for now */ rv = saHpiEventLogInfoGet(sessionid,resourceid,&info); if (fdebug) printf("saHpiEventLogInfoGet %s\n",decode_error(rv)); if (rv == SA_OK) { break; } rptentryid = nextrptentryid; } } printf( "Go and get the event\n"); while (1) { rv = saHpiEventGet( sessionid, timeout, &event, &rdr, &rptentry ); if (rv != SA_OK) { if (rv != SA_ERR_HPI_TIMEOUT) { printf( "Error during EventGet - Test FAILED\n"); break; } else { printf( "\n\n****** Time, %d seconds, expired waiting for event.\n", wait); break; } } else { print_event(&event); } } /* Unsubscribe to future events */ printf( "Unsubscribe\n"); rv = saHpiUnsubscribe( sessionid ); rv = saHpiSessionClose(sessionid); rv = saHpiFinalize(); exit(0); return(0); }
int Test_Resource(SaHpiSessionIdT session, SaHpiResourceIdT resource) { SaErrorT status; int retval = SAF_TEST_UNKNOWN; SaHpiEventLogEntryT LogEntry; SaHpiEventLogEntryIdT PrevLogEntry; SaHpiEventT EvtEntry; SaHpiEventLogInfoT info; // // Check to see if there needs to be an eventlog entry added. // status = saHpiEventLogInfoGet(session, resource, &info); if (status != SA_OK) { retval = SAF_TEST_UNRESOLVED; e_print(saHpiEventLogInfoGet, SA_OK, status); } else { if (info.Size == 0) { retval = SAF_TEST_NOTSUPPORT; } else if (info.Entries == 0) { EvtEntry.EventType = SAHPI_ET_USER; EvtEntry.Source = SAHPI_UNSPECIFIED_RESOURCE_ID; EvtEntry.Timestamp = SAHPI_TIME_UNSPECIFIED; EvtEntry.Severity = SAHPI_OK; strncpy(EvtEntry.EventDataUnion.UserEvent.UserEventData. Data, TEST_STRING, TEST_STRING_LENGTH); EvtEntry.EventDataUnion.UserEvent.UserEventData. DataLength = TEST_STRING_LENGTH; EvtEntry.EventDataUnion.UserEvent.UserEventData. Language = SAHPI_LANG_ENGLISH; EvtEntry.EventDataUnion.UserEvent.UserEventData. DataType = SAHPI_TL_TYPE_TEXT; status = saHpiEventLogEntryAdd(session, resource, &EvtEntry); if (status != SA_OK) { e_print(saHpiEventLogEntryAdd, SA_OK, status); retval = SAF_TEST_UNRESOLVED; } } } if (retval == SAF_TEST_UNKNOWN) { // // Call saHpiEventLogEntryGet while passing in a NULL // pointer for PrevEntryId. // status = saHpiEventLogEntryGet(session, resource, SAHPI_OLDEST_ENTRY, &PrevLogEntry, NULL, &LogEntry, NULL, NULL); if (status == SA_ERR_HPI_INVALID_PARAMS) retval = SAF_TEST_PASS; else { e_print(saHpiEventLogEntryGet, SA_ERR_HPI_INVALID_PARAMS, status); retval = SAF_TEST_FAIL; } } return (retval); }
SaErrorT show_event_log(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid, int show_short, hpi_ui_print_cb_t proc) { SaErrorT rv = SA_OK; SaHpiRptEntryT rptentry; SaHpiEventLogInfoT info; SaHpiEventLogEntryIdT entryid; SaHpiEventLogEntryIdT nextentryid; SaHpiEventLogEntryIdT preventryid; SaHpiEventLogEntryT sel; SaHpiRdrT rdr; SaHpiRptEntryT rpt; char buf[SHOW_BUF_SZ]; char date[30], date1[30]; if (resourceid != SAHPI_UNSPECIFIED_RESOURCE_ID) { rv = saHpiRptEntryGetByResourceId(sessionid, resourceid, &rptentry); if (rv != SA_OK) { snprintf(buf, SHOW_BUF_SZ, "ERROR: saHpiRptEntryGetByResourceId error = %s\n", oh_lookup_error(rv)); proc(buf); return rv; }; if (!(rptentry.ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG)) { proc("ERROR: The designated resource hasn't SEL.\n"); return SA_OK; } }; rv = saHpiEventLogInfoGet(sessionid, resourceid, &info); if (rv != SA_OK) { snprintf(buf, SHOW_BUF_SZ, "ERROR: saHpiEventLogInfoGet error = %s\n", oh_lookup_error(rv)); proc(buf); return rv; } snprintf(buf, SHOW_BUF_SZ, "EventLog: entries = %d, size = %d, enabled = %d\n", info.Entries, info.Size, info.Enabled); if (proc(buf) != HPI_UI_OK) return(SA_OK); time2str(info.UpdateTimestamp, date, 30); time2str(info.CurrentTime, date1, 30); snprintf(buf, SHOW_BUF_SZ, "UpdateTime = %s CurrentTime = %s Overflow = %d\n", date, date1, info.OverflowFlag); if (proc(buf) != HPI_UI_OK) return(SA_OK); if (info.Entries != 0) { entryid = SAHPI_OLDEST_ENTRY; while (entryid != SAHPI_NO_MORE_ENTRIES) { rv = saHpiEventLogEntryGet(sessionid, resourceid, entryid, &preventryid, &nextentryid, &sel, &rdr, &rpt); if (rv != SA_OK) { snprintf(buf, SHOW_BUF_SZ, "ERROR: saHpiEventLogEntryGet error = %s\n", oh_lookup_error(rv)); proc(buf); return -1; }; if (show_short) { if (show_short_event(&(sel.Event), proc) != HPI_UI_OK) return(SA_OK); } else { if (rpt.ResourceCapabilities != 0) { oh_print_eventlogentry(&sel, &rpt.ResourceEntity, 1); } else if (rdr.RdrType != SAHPI_NO_RECORD) { oh_print_eventlogentry(&sel, &rdr.Entity, 1); } else { oh_print_eventlogentry(&sel, NULL, 1); } } preventryid = entryid; entryid = nextentryid; } } else { proc("SEL is empty\n"); }; return SA_OK; }
int main(int argc, char **argv) { int c; SaErrorT rv; SaHpiVersionT hpiVer; SaHpiSessionIdT sessionid; SaHpiRptInfoT rptinfo; SaHpiRptEntryT rptentry; SaHpiEntryIdT rptentryid; SaHpiEntryIdT nextrptentryid; SaHpiResourceIdT resourceid; SaHpiSelEntryIdT entryid; SaHpiSelEntryIdT nextentryid; SaHpiSelEntryIdT preventryid; SaHpiSelInfoT info; SaHpiSelEntryT sel; SaHpiRdrT rdr; int free = 50; printf("%s: version %s\n",argv[0],progver); while ( (c = getopt( argc, argv,"cx?")) != EOF ) switch(c) { case 'c': fclear = 1; break; case 'x': fdebug = 1; break; default: printf("Usage %s [-cx]\n",argv[0]); printf("where -c clears the event log\n"); printf(" -x displays eXtra debug messages\n"); exit(1); } rv = saHpiInitialize(&hpiVer); if (rv != SA_OK) { printf("saHpiInitialize: %s\n",decode_error(rv)); exit(-1); } rv = saHpiSessionOpen(SAHPI_DEFAULT_DOMAIN_ID,&sessionid,NULL); if (rv != SA_OK) { if (rv == SA_ERR_HPI_ERROR) printf("saHpiSessionOpen: error %d, SpiLibd not running\n",rv); else printf("saHpiSessionOpen: %s\n",decode_error(rv)); exit(-1); } rv = saHpiResourcesDiscover(sessionid); if (fdebug) printf("saHpiResourcesDiscover %s\n",decode_error(rv)); rv = saHpiRptInfoGet(sessionid,&rptinfo); if (fdebug) printf("saHpiRptInfoGet %s\n",decode_error(rv)); printf("RptInfo: UpdateCount = %d, UpdateTime = %lx\n", rptinfo.UpdateCount, (unsigned long)rptinfo.UpdateTimestamp); /* walk the RPT list */ rptentryid = SAHPI_FIRST_ENTRY; while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY)) { rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry); if (fdebug) printf("saHpiRptEntryGet %s\n",decode_error(rv)); if (rv == SA_OK) { resourceid = rptentry.ResourceId; if (fdebug) printf("RPT %d capabilities = %x\n", resourceid, rptentry.ResourceCapabilities); if (!(rptentry.ResourceCapabilities & SAHPI_CAPABILITY_SEL)) { if (fdebug) printf("RPT doesn't have SEL\n"); rptentryid = nextrptentryid; continue; /* no SEL here, try next RPT */ } rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0; printf("rptentry[%d] tag: %s\n", resourceid,rptentry.ResourceTag.Data); /* initialize structure */ info.Entries = 0; info.Size = 0; info.Enabled = 0; rv = saHpiEventLogInfoGet(sessionid,resourceid,&info); if (fdebug) printf("saHpiEventLogInfoGet %s\n",decode_error(rv)); if (rv == SA_OK) { char date[30]; printf("EventLog entries=%d, size=%d, enabled=%d\n", info.Entries,info.Size,info.Enabled); free = info.Size - info.Entries; saftime2str(info.UpdateTimestamp,date,30); printf("UpdateTime = %s, ", date); saftime2str(info.CurrentTime,date,30); printf("CurrentTime = %s\n", date); printf("Overflow = %d\n", info.OverflowFlag); printf("DeleteEntrySupported = %d\n", info.DeleteEntrySupported); } if (fclear) { rv = saHpiEventLogClear(sessionid,resourceid); if (rv == SA_OK) printf("EventLog successfully cleared\n"); else printf("EventLog clear, error = %d, %s\n",rv, decode_error(rv)); break; } if (info.Entries != 0){ entryid = SAHPI_OLDEST_ENTRY; while ((rv == SA_OK) && (entryid != SAHPI_NO_MORE_ENTRIES)) { rv = saHpiEventLogEntryGet(sessionid,resourceid, entryid,&preventryid,&nextentryid, &sel,&rdr,NULL); if (fdebug) printf("saHpiEventLogEntryGet %s\n", decode_error(rv)); if (rv == SA_OK) { ShowSel(&sel, &rdr, &rptentry); preventryid = entryid; entryid = nextentryid; } } } else printf("SEL is empty\n"); if (free < 6) { printf("WARNING: Log free space is very low (%d records)\n",free); printf("\tClear log with hpisel -c\n"); } rptentryid = nextrptentryid; } } printf("done.\n"); rv = saHpiSessionClose(sessionid); rv = saHpiFinalize(); // exit(0); return(0); }
cOpenHpiDaemon::tResult cOpenHpiDaemon::HandleMsg( cConnection *c, const cMessageHeader &header, const void *data, cMessageHeader &rh, void *&rd ) { cHpiMarshal *hm = HpiMarshalFind( header.m_id ); // check for function and data length if ( !hm || hm->m_request_len < header.m_len ) { //MessageHeaderInit( &rh, eMhError, header.m_seq, 0, 0 ); //rd = 0; fprintf( stderr, "wrong message length: id %d !\n", header.m_id ); return eResultError; } assert( hm->m_reply_len ); // init reply header MessageHeaderInit( &rh, eMhReply, header.m_seq, header.m_id, hm->m_reply_len ); // alloc reply buffer rd = calloc( 1, hm->m_reply_len ); SaErrorT ret; switch( header.m_id ) { case eFsaHpiSessionOpen: { SaHpiDomainIdT domain_id; SaHpiSessionIdT session_id = 0; HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, (void *)&domain_id ); ret = saHpiSessionOpen( domain_id, &session_id, 0 ); DbgFunc( "saHpiSessionOpen( %x, %x ) = %d\n", domain_id, session_id, ret ); if ( ret == SA_OK ) c->AddSession( session_id ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &session_id ); } break; case eFsaHpiSessionClose: { SaHpiSessionIdT session_id; HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id ); ret = saHpiSessionClose( session_id ); DbgFunc( "saHpiSessionClose( %x ) = %d\n", session_id, ret ); if ( ret == SA_OK ) c->RemSession( session_id ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiResourcesDiscover: { SaHpiSessionIdT session_id; HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id ); ret = saHpiResourcesDiscover( session_id ); DbgFunc( "saHpiResourcesDiscover( %x ) = %d\n", session_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiRptInfoGet: { SaHpiSessionIdT session_id; SaHpiRptInfoT rpt_info; HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id ); ret = saHpiRptInfoGet( session_id, &rpt_info ); DbgFunc( "saHpiRptInfoGet( %x ) = %d\n", session_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &rpt_info ); } break; case eFsaHpiRptEntryGet: { SaHpiSessionIdT session_id; SaHpiEntryIdT entry_id; SaHpiEntryIdT next_entry_id; SaHpiRptEntryT rpt_entry; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &entry_id ); ret = saHpiRptEntryGet( session_id, entry_id, &next_entry_id, &rpt_entry ); DbgFunc( "saHpiRptEntryGet( %x, %x, %x ) = %d\n", session_id, entry_id, next_entry_id, ret ); rh.m_len = HpiMarshalReply2( hm, rd, &ret, &next_entry_id, &rpt_entry ); } break; case eFsaHpiRptEntryGetByResourceId: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiRptEntryT rpt_entry; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiRptEntryGetByResourceId( session_id, resource_id, &rpt_entry ); DbgFunc( "saHpiRptEntryGetByResourceId( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &rpt_entry ); } break; case eFsaHpiResourceSeveritySet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSeverityT severity; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &severity ); ret = saHpiResourceSeveritySet( session_id, resource_id, severity ); DbgFunc( "saHpiResourceSeveritySet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiResourceTagSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiTextBufferT resource_tag; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &resource_tag ); ret = saHpiResourceTagSet( session_id, resource_id, &resource_tag ); DbgFunc( "saHpiResourceTagSet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiResourceIdGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id = 0; HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id ); ret = saHpiResourceIdGet( session_id, &resource_id ); DbgFunc( "saHpiResourceIdGet( %x ) = %d, %x\n", session_id, ret, resource_id ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &resource_id ); } break; case eFsaHpiEntitySchemaGet: { SaHpiSessionIdT session_id; SaHpiUint32T schema_id = 0; HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id ); ret = saHpiEntitySchemaGet( session_id, &schema_id ); DbgFunc( "saHpiEntitySchemaGet( %x ) = %d, %x\n", session_id, ret, schema_id ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &schema_id ); } break; case eFsaHpiEventLogInfoGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSelInfoT info; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiEventLogInfoGet( session_id, resource_id, &info ); DbgFunc( "saHpiEventLogInfoGet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &info ); } break; case eFsaHpiEventLogEntryGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSelEntryIdT entry_id; SaHpiSelEntryIdT prev_entry_id = 0; SaHpiSelEntryIdT next_entry_id = 0; SaHpiSelEntryT event_log_entry; SaHpiRdrT rdr; SaHpiRptEntryT rpt_entry; memset( &rdr, 0, sizeof( SaHpiRdrT ) ); memset( &rpt_entry, 0, sizeof( SaHpiRptEntryT ) ); HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &entry_id ); ret = saHpiEventLogEntryGet( session_id, resource_id, entry_id, &prev_entry_id, &next_entry_id, &event_log_entry, &rdr, &rpt_entry ); DbgFunc( "saHpiEventLogEntryGet( %x, %x, %x ) = %d\n", session_id, resource_id, entry_id, ret ); rh.m_len = HpiMarshalReply5( hm, rd, &ret, &prev_entry_id, &next_entry_id, &event_log_entry, &rdr, &rpt_entry ); } break; case eFsaHpiEventLogEntryAdd: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSelEntryT evt_entry; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &evt_entry ); ret = saHpiEventLogEntryAdd( session_id, resource_id, &evt_entry ); DbgFunc( "saHpiEventLogEntryAdd( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiEventLogEntryDelete: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSelEntryIdT entry_id; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &entry_id ); ret = saHpiEventLogEntryDelete( session_id, resource_id, entry_id ); DbgFunc( "saHpiEventLogEntryDelete( %x, %x, %x ) = %d\n", session_id, resource_id, entry_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiEventLogClear: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiEventLogClear( session_id, resource_id ); DbgFunc( "saHpiEventLogClear( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiEventLogTimeGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiTimeT ti; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiEventLogTimeGet( session_id, resource_id, &ti ); DbgFunc( "saHpiEventLogTimeGet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &ti ); } break; case eFsaHpiEventLogTimeSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiTimeT ti; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id , &ti ); ret = saHpiEventLogTimeSet( session_id, resource_id, ti ); DbgFunc( "saHpiEventLogTimeSet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiEventLogStateGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiBoolT enable; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiEventLogStateGet( session_id, resource_id, &enable ); DbgFunc( "saHpiEventLogStateGet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &enable ); } break; case eFsaHpiEventLogStateSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiBoolT enable; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &enable ); ret = saHpiEventLogStateSet( session_id, resource_id, enable ); DbgFunc( "saHpiEventLogStateSet( %x, %x, %s ) = %d\n", session_id, resource_id, enable ? "true" : "false", ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiSubscribe: { SaHpiSessionIdT session_id; SaHpiBoolT provide_active_alarms; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &provide_active_alarms ); ret = saHpiSubscribe( session_id, provide_active_alarms ); DbgFunc( "saHpiSubscribe( %x, %s ) = %d\n", session_id, provide_active_alarms ? "true" : "false", ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiUnsubscribe: { SaHpiSessionIdT session_id; HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id ); ret = saHpiUnsubscribe( session_id ); DbgFunc( "saHpiUnsubscribe( %x ) = %d\n", session_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiEventGet: { SaHpiSessionIdT session_id; SaHpiTimeoutT timeout; SaHpiEventT event; SaHpiRdrT rdr; SaHpiRptEntryT rpt_entry; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &timeout ); if ( timeout == 0 ) { ret = saHpiEventGet( session_id, timeout, &event, &rdr, &rpt_entry ); DbgFunc( "saHpiEventGet( %x ) = %d\n", session_id, ret ); rh.m_len = HpiMarshalReply3( hm, rd, &ret, &event, &rdr, &rpt_entry ); } else { cSession *s = c->FindSession( session_id ); if ( s && !s->IsEventGet() ) { s->EventGet( true ); SaHpiTimeT end; gettimeofday1( &end ); if ( timeout == SAHPI_TIMEOUT_BLOCK ) end += (SaHpiTimeT)10000*1000000000; //set a long time else end += timeout; s->Timeout() = end; s->Seq() = header.m_seq; DbgEvent( "saHpiEventGet( %x ): add to event listener.\n", s->SessionId() ); return eResultOk; } // error ret = SA_ERR_HPI_BUSY; rh.m_len = HpiMarshalReply3( hm, rd, &ret, &event, &rdr, &rpt_entry ); } } break; case eFsaHpiRdrGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiEntryIdT entry_id; SaHpiEntryIdT next_entry_id; SaHpiRdrT rdr; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &entry_id ); ret = saHpiRdrGet( session_id, resource_id, entry_id, &next_entry_id, &rdr ); DbgFunc( "saHpiRdrGet( %x, %x, %x ) = %d\n", session_id, resource_id, entry_id, ret ); rh.m_len = HpiMarshalReply2( hm, rd, &ret, &next_entry_id, &rdr ); } break; case eFsaHpiSensorReadingGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSensorNumT sensor_num; SaHpiSensorReadingT reading; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &sensor_num ); ret = saHpiSensorReadingGet( session_id, resource_id, sensor_num, &reading ); DbgFunc( "saHpiSensorReadingGet( %x, %x, %x ) = %d\n", session_id, resource_id, sensor_num, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &reading ); } break; case eFsaHpiSensorReadingConvert: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSensorNumT sensor_num; SaHpiSensorReadingT reading_input; SaHpiSensorReadingT converted_reading; HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &sensor_num, &reading_input ); ret = saHpiSensorReadingConvert( session_id, resource_id, sensor_num, &reading_input, &converted_reading ); DbgFunc( "saHpiSensorReadingConvert( %x, %x, %x ) = %d\n", session_id, resource_id, sensor_num, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &converted_reading ); } break; case eFsaHpiSensorThresholdsGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSensorNumT sensor_num; SaHpiSensorThresholdsT sensor_thresholds; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &sensor_num ); ret = saHpiSensorThresholdsGet( session_id, resource_id, sensor_num, &sensor_thresholds); DbgFunc( "saHpiSensorThresholdsGet( %x, %x, %x ) = %d\n", session_id, resource_id, sensor_num, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &sensor_thresholds ); } break; case eFsaHpiSensorThresholdsSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSensorNumT sensor_num; SaHpiSensorThresholdsT sensor_thresholds; HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &sensor_num, &sensor_thresholds ); ret = saHpiSensorThresholdsSet( session_id, resource_id, sensor_num, &sensor_thresholds ); DbgFunc( "saHpiSensorThresholdsSet( %x, %x, %x ) = %d\n", session_id, resource_id, sensor_num, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiSensorTypeGet: { SaHpiResourceIdT resource_id; SaHpiSessionIdT session_id; SaHpiSensorNumT sensor_num; SaHpiSensorTypeT type; SaHpiEventCategoryT category; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &sensor_num ); ret = saHpiSensorTypeGet( session_id, resource_id, sensor_num, &type, &category ); DbgFunc( "saHpiSensorTypeGet( %x, %x, %x ) = %d\n", session_id, resource_id, sensor_num, ret ); rh.m_len = HpiMarshalReply2( hm, rd, &ret, &type, &category ); } break; case eFsaHpiSensorEventEnablesGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSensorNumT sensor_num; SaHpiSensorEvtEnablesT enables; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &sensor_num ); ret = saHpiSensorEventEnablesGet( session_id, resource_id, sensor_num, &enables ); DbgFunc( "saHpiSensorEventEnablesGet( %x, %x, %x ) = %d\n", session_id, resource_id, sensor_num, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &enables ); } break; case eFsaHpiSensorEventEnablesSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiSensorNumT sensor_num; SaHpiSensorEvtEnablesT enables; HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &sensor_num, &enables ); ret = saHpiSensorEventEnablesSet( session_id, resource_id, sensor_num, &enables ); DbgFunc( "saHpiSensorEventEnablesSet( %x, %x, %x ) = %d\n", session_id, resource_id, sensor_num, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiControlTypeGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiCtrlNumT ctrl_num; SaHpiCtrlTypeT type; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &ctrl_num ); ret = saHpiControlTypeGet( session_id, resource_id, ctrl_num, &type ); DbgFunc( "saHpiControlTypeGet( %x, %x, %x ) = %d\n", session_id, resource_id, ctrl_num, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &type ); } break; case eFsaHpiControlStateGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiCtrlNumT ctrl_num; SaHpiCtrlStateT ctrl_state; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &ctrl_num ); ret = saHpiControlStateGet( session_id, resource_id, ctrl_num, &ctrl_state ); DbgFunc( "saHpiControlStateGet( %x, %x, %x ) = %d\n", session_id, resource_id, ctrl_num, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &ctrl_state ); } break; case eFsaHpiControlStateSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiCtrlNumT ctrl_num; SaHpiCtrlStateT ctrl_state; HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &ctrl_num, &ctrl_state ); ret = saHpiControlStateSet( session_id, resource_id, ctrl_num, &ctrl_state ); DbgFunc( "saHpiControlStateSet( %x, %x, %x ) = %d\n", session_id, resource_id, ctrl_num, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiEntityInventoryDataRead: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiEirIdT eir_id; SaHpiUint32T buffer_size; unsigned char *buffer = 0; SaHpiUint32T actual_size; HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &eir_id, &buffer_size ); if ( buffer_size ) buffer = new unsigned char [buffer_size]; ret = saHpiEntityInventoryDataRead( session_id, resource_id, eir_id, buffer_size, (SaHpiInventoryDataT *)(void *)buffer, &actual_size ); DbgFunc( "saHpintityInventoryDataRead( %x, %x, %x, %d ) = %d\n", session_id, resource_id, eir_id, buffer_size, ret ); const cMarshalType *reply[4]; reply[0] = &SaErrorType; // SA_OK reply[1] = &SaHpiUint32Type; // actual size const void *params[3]; params[0] = &ret; params[1] = &actual_size; if ( ret != SA_OK || buffer == 0 ) reply[2] = 0; else { reply[2] = &SaHpiInventoryDataType, // inventory data reply[3] = 0; params[2] = buffer; } rh.m_len = MarshalArray( reply, params, rd ); if ( buffer ) delete [] buffer; } break; case eFsaHpiEntityInventoryDataWrite: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiEirIdT eir_id; unsigned char buffer[10240]; HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &eir_id, buffer ); ret = saHpiEntityInventoryDataWrite( session_id, resource_id, eir_id, (SaHpiInventoryDataT *)(void *)buffer ); DbgFunc( "saHpintityInventoryDataWrite( %x, %x, %x ) = %d\n", session_id, resource_id, eir_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiWatchdogTimerGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiWatchdogNumT watchdog_num; SaHpiWatchdogT watchdog; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &watchdog_num ); ret = saHpiWatchdogTimerGet( session_id, resource_id, watchdog_num, &watchdog ); DbgFunc( "saHpiWatchdogTimerGet( %x, %x, %x ) = %d\n", session_id, resource_id, watchdog_num, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &watchdog ); } break; case eFsaHpiWatchdogTimerSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiWatchdogNumT watchdog_num; SaHpiWatchdogT watchdog; HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &watchdog_num, &watchdog ); ret = saHpiWatchdogTimerSet( session_id, resource_id, watchdog_num, &watchdog ); DbgFunc( "saHpiWatchdogTimerSet( %x, %x, %x ) = %d\n", session_id, resource_id, watchdog_num, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiWatchdogTimerReset: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiWatchdogNumT watchdog_num; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &watchdog_num ); ret = saHpiWatchdogTimerReset( session_id, resource_id, watchdog_num ); DbgFunc( "eFsaHpiWatchdogTimerReset( %x, %x, %x ) = %d\n", session_id, resource_id, watchdog_num, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiHotSwapControlRequest: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiHotSwapControlRequest( session_id, resource_id ); DbgFunc( "saHpiHotSwapControlRequest( %x, %x ) = %d\n", session_id, resource_id , ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiResourceActiveSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiResourceActiveSet( session_id, resource_id ); DbgFunc( "saHpiResourceActiveSet( %x, %x ) = %d\n", session_id, resource_id , ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiResourceInactiveSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiResourceInactiveSet( session_id, resource_id ); DbgFunc( "saHpiResourceInactiveSet( %x, %x ) = %d\n", session_id, resource_id , ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiAutoInsertTimeoutGet: { SaHpiSessionIdT session_id; SaHpiTimeoutT timeout; HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id ); ret = saHpiAutoInsertTimeoutGet( session_id, &timeout ); DbgFunc( "saHpiAutoInsertTimeoutGet( %x ) = %d\n", session_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &timeout ); } break; case eFsaHpiAutoInsertTimeoutSet: { SaHpiSessionIdT session_id; SaHpiTimeoutT timeout; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &timeout ); ret = saHpiAutoInsertTimeoutSet( session_id, timeout ); DbgFunc( "saHpiAutoInsertTimeoutSet( %x ) = %d\n", session_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiAutoExtractTimeoutGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiTimeoutT timeout; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiAutoExtractTimeoutGet( session_id, resource_id, &timeout ); DbgFunc( "saHpiAutoExtractTimeoutGet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &timeout ); } break; case eFsaHpiAutoExtractTimeoutSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiTimeoutT timeout; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &timeout ); ret = saHpiAutoExtractTimeoutSet( session_id, resource_id, timeout ); DbgFunc( "saHpiAutoExtractTimeoutSet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiHotSwapStateGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiHsStateT state; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiHotSwapStateGet( session_id, resource_id, &state ); DbgFunc( "saHpiHotSwapStateGet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &state ); } break; case eFsaHpiHotSwapActionRequest: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiHsActionT action; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &action ); ret = saHpiHotSwapActionRequest( session_id, resource_id, action ); DbgFunc( "saHpiHotSwapActionRequest( %x, %x ) = %d\n", session_id, resource_id , ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiResourcePowerStateGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiHsPowerStateT state; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiResourcePowerStateGet( session_id, resource_id, &state ); DbgFunc( "saHpiResourcePowerStateGet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &state ); } break; case eFsaHpiResourcePowerStateSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiHsPowerStateT state; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &state ); ret = saHpiResourcePowerStateSet( session_id, resource_id, state ); DbgFunc( "(saHpiResourcePowerStateSet %x, %x ) = %d\n", session_id, resource_id , ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiHotSwapIndicatorStateGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiHsIndicatorStateT state; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiHotSwapIndicatorStateGet( session_id, resource_id, &state ); DbgFunc( "saHpiHotSwapIndicatorStateGet( %x, %x ) = %d\n", session_id, resource_id , ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &state ); } break; case eFsaHpiHotSwapIndicatorStateSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiHsIndicatorStateT state; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &state ); ret = saHpiHotSwapIndicatorStateSet( session_id, resource_id, state ); DbgFunc( "saHpiHotSwapIndicatorStateSet( %x, %x ) = %d\n", session_id, resource_id , ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiParmControl: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiParmActionT action; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &action ); ret = saHpiParmControl( session_id, resource_id, action ); DbgFunc( "saHpiParmControl( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; case eFsaHpiResourceResetStateGet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiResetActionT reset_action; HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id ); ret = saHpiResourceResetStateGet( session_id, resource_id, &reset_action ); DbgFunc( "saHpiResourceResetStateGet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply1( hm, rd, &ret, &reset_action ); } break; case eFsaHpiResourceResetStateSet: { SaHpiSessionIdT session_id; SaHpiResourceIdT resource_id; SaHpiResetActionT reset_action; HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data, &session_id, &resource_id, &reset_action ); ret = saHpiResourceResetStateSet( session_id, resource_id, reset_action ); DbgFunc( "saHpiResourceResetStateSet( %x, %x ) = %d\n", session_id, resource_id, ret ); rh.m_len = HpiMarshalReply0( hm, rd, &ret ); } break; default: assert( 0 ); break; } assert( rh.m_len <= hm->m_reply_len ); return eResultReply; }
int main(int argc, char **argv) { char c; SaErrorT rv; SaHpiVersionT hpiVer; SaHpiSessionIdT sessionid; SaHpiRptInfoT rptinfo; SaHpiRptEntryT rptentry; SaHpiEntryIdT rptentryid; SaHpiEntryIdT nextrptentryid; SaHpiResourceIdT resourceid; SaHpiSelEntryIdT entryid; SaHpiSelEntryIdT nextentryid; SaHpiSelEntryIdT preventryid; SaHpiSelInfoT info; SaHpiSelEntryT sel; SaHpiRdrT rdr; printf("%s: version %s\n",argv[0],progver); while ( (c = getopt( argc, argv,"cx?")) != EOF ) switch(c) { case 'c': fclear = 1; break; case 'x': fdebug = 1; break; default: printf("Usage %s [-cx]\n",argv[0]); printf("where -c clears the event log\n"); printf(" -x displays eXtra debug messages\n"); exit(1); } rv = saHpiInitialize(&hpiVer); if (rv != SA_OK) { printf("saHpiInitialize: %s\n",decode_error(rv)); exit(-1); } rv = saHpiSessionOpen(SAHPI_DEFAULT_DOMAIN_ID,&sessionid,NULL); if (rv != SA_OK) { if (rv == SA_ERR_HPI_ERROR) printf("saHpiSessionOpen: error %d, SpiLibd not running\n",rv); else printf("saHpiSessionOpen: %s\n",decode_error(rv)); exit(-1); } rv = saHpiResourcesDiscover(sessionid); if (fdebug) printf("saHpiResourcesDiscover %s\n",decode_error(rv)); rv = saHpiRptInfoGet(sessionid,&rptinfo); if (fdebug) printf("saHpiRptInfoGet %s\n",decode_error(rv)); printf("RptInfo: UpdateCount = %d, UpdateTime = %lx\n", rptinfo.UpdateCount, (unsigned long)rptinfo.UpdateTimestamp); #ifdef BUGGY /* ARC: Bug here in OpenHPI required re-doing discovery as a workaround. */ #endif /* walk the RPT list */ rptentryid = SAHPI_OLDEST_ENTRY; while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY)) { rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry); if (fdebug) printf("saHpiRptEntryGet %s\n",decode_error(rv)); if (rv == SA_OK) { resourceid = rptentry.ResourceId; if (fdebug) printf("RPT %x capabilities = %x\n", resourceid, rptentry.ResourceCapabilities); if ((rptentry.ResourceCapabilities & SAHPI_CAPABILITY_SEL) == 0) continue; /* no SEL here, try next RPT */ if (fclear) { rv = saHpiEventLogClear(sessionid,resourceid); if (rv == SA_OK) printf("EventLog successfully cleared\n"); else printf("EventLog clear, error = %d\n",rv); break; } rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0; printf("rptentry[%d] tag: %s\n", resourceid,rptentry.ResourceTag.Data); rv = saHpiEventLogInfoGet(sessionid,resourceid,&info); if (fdebug) printf("saHpiEventLogInfoGet %s\n",decode_error(rv)); if (rv == SA_OK) { /* This data isn't reliable yet with Spi beta2 implementation */ /* Use the entryid instead to calculate log size below. */ printf("EventLog entries=%d, size=%d, enabled=%d\n", info.Entries,info.Size,info.Enabled); } entryid = SAHPI_OLDEST_ENTRY; while ((rv == SA_OK) && (entryid != SAHPI_NO_MORE_ENTRIES)) { rv = saHpiEventLogEntryGet(sessionid,resourceid,entryid, &preventryid,&nextentryid,&sel,&rdr,NULL); if (fdebug) printf("saHpiEventLogEntryGet %s\n", decode_error(rv)); if (rv == SA_OK) { ShowSel(&sel, &rdr, &rptentry); preventryid = entryid; entryid = nextentryid; } } if (preventryid >= 0xff80) { int free; /* * This test could be more generic if the log info fields above * were accurate. IPMI SEL logs have a fixed size of 0x10000 * bytes. New log records are thrown away when it gets full. * (OLDEST = 0, NO_MORE = fffffffe , so these are ok.) */ free = (0x10000 - 20) - preventryid; printf("WARNING: Log free space is very low (%d bytes)\n" " Clear log with hpisel -c\n",free); } rptentryid = nextrptentryid; } } rv = saHpiSessionClose(sessionid); rv = saHpiFinalize(); exit(0); return(0); }
int testEventLog(SaHpiSessionIdT session_id, SaHpiResourceIdT resourceId, char *name) { SaHpiEventLogEntryIdT prev_entry_id; SaHpiEventLogEntryIdT next_entry_id; SaHpiEventLogEntryT entry_get; SaHpiEventT entry_add; SaHpiRdrT rdr; SaHpiRptEntryT rpt_entry; SaHpiBoolT enable_old; SaHpiBoolT temporarly_disabled = SAHPI_FALSE; SaErrorT error; int retval = SAF_TEST_UNKNOWN; SaHpiEventLogInfoT info; /* Disable event log state, to ensure entry is newest eventlog entry */ error = saHpiEventLogStateGet(session_id, resourceId, &enable_old); if (error != SA_OK) { retval = SAF_TEST_UNRESOLVED; e_print(saHpiEventLogStateGet, SA_OK, error); } else { if (enable_old) { error = saHpiEventLogStateSet(session_id, resourceId, SAHPI_FALSE); if (error == SA_OK) { temporarly_disabled = SAHPI_TRUE; } else { retval = SAF_TEST_UNRESOLVED; e_print(saHpiEventLogStateSet, SA_OK, error); } } if (retval == SAF_TEST_UNKNOWN) { error = saHpiEventLogInfoGet(session_id, resourceId, &info); if (error != SA_OK) { retval = SAF_TEST_UNRESOLVED; e_print(saHpiEventLogInfoGet, SA_OK, error); } else { if (info.Entries >= info.Size) { // If the event log is full error = saHpiEventLogClear(session_id, rpt_entry.ResourceId); if (error != SA_OK) { retval = SAF_TEST_UNRESOLVED; e_print(saHpiEventLogInfoGet, SA_OK, error); } } if (retval == SAF_TEST_UNKNOWN) { entry_add.Source = SAHPI_UNSPECIFIED_RESOURCE_ID; entry_add.EventType = SAHPI_ET_USER; entry_add.Timestamp = SAHPI_TIME_UNSPECIFIED; entry_add.Severity = SAHPI_OK; memcpy(entry_add.EventDataUnion.UserEvent.UserEventData.Data, TEST_STR, sizeof(TEST_STR)); entry_add.EventDataUnion.UserEvent.UserEventData.DataType = SAHPI_TL_TYPE_TEXT; entry_add.EventDataUnion.UserEvent.UserEventData.Language = SAHPI_LANG_ENGLISH; entry_add.EventDataUnion.UserEvent.UserEventData.DataLength = (SaHpiUint8T) sizeof(TEST_STR); error = saHpiEventLogEntryAdd(session_id, resourceId, &entry_add); if (error != SA_OK) { retval = SAF_TEST_FAIL; e_print(saHpiEventLogStateSet, SA_OK, error); } else { error = saHpiEventLogEntryGet(session_id, resourceId, SAHPI_NEWEST_ENTRY, &prev_entry_id, &next_entry_id, &entry_get, &rdr, &rpt_entry); if (error != SA_OK) { retval = SAF_TEST_FAIL; e_print(saHpiEventLogEntryGet, SA_OK, error); } else if (!sameUserEvent(&entry_add, &entry_get.Event)) { retval = SAF_TEST_FAIL; m_print("Added event log entry is invalid! (%s)!", name); } else { retval = SAF_TEST_PASS; } } } } } // Clean-up if (temporarly_disabled) { error = saHpiEventLogStateSet(session_id, resourceId, enable_old); if (error != SA_OK) { e_print(saHpiEventLogStateSet, SA_OK, error); } } } return retval; }
int test_res(SaHpiSessionIdT session, SaHpiResourceIdT resource) { SaErrorT status; int retval = SAF_TEST_UNKNOWN; SaHpiEventLogEntryIdT PrevLogEntry; SaHpiEventLogEntryIdT NextLogEntry; SaHpiEventLogEntryT LogEntry; SaHpiEventT EvtEntry; SaHpiEventLogInfoT info; SaHpiBoolT savedState; status = saHpiEventLogStateGet(session, resource, &savedState); if (status != SA_OK) { e_print(saHpiEventLogStateGet, SA_OK, status); return SAF_TEST_UNRESOLVED; } status = saHpiEventLogStateSet(session, resource, SAHPI_FALSE); if (status != SA_OK) { e_print(saHpiEventLogStateSet, SA_OK, status); return SAF_TEST_UNRESOLVED; } // // Check to see if there needs to be an eventlog entry added. // status = saHpiEventLogInfoGet(session, resource, &info); if (status != SA_OK) { // Even if this resource does not work, others will e_print(saHpiEventLogInfoGet, SA_OK, status); retval = SAF_TEST_NOTSUPPORT; } else { if (info.Size == 0) retval = SAF_TEST_NOTSUPPORT; else { if (info.Entries == info.Size) { status = saHpiEventLogClear(session, resource); if (status != SA_OK) { e_print(saHpiEventLogClear, SA_OK, status); retval = SAF_TEST_UNRESOLVED; } } if (retval == SAF_TEST_UNKNOWN) { EvtEntry.EventType = SAHPI_ET_USER; EvtEntry.Source = SAHPI_UNSPECIFIED_RESOURCE_ID; EvtEntry.Timestamp = SAHPI_TIME_UNSPECIFIED; EvtEntry.Severity = SAHPI_OK; strncpy(EvtEntry.EventDataUnion.UserEvent. UserEventData.Data, TEST_STRING, TEST_STRING_LENGTH); EvtEntry.EventDataUnion.UserEvent.UserEventData. DataLength = TEST_STRING_LENGTH; EvtEntry.EventDataUnion.UserEvent.UserEventData. Language = SAHPI_LANG_ENGLISH; EvtEntry.EventDataUnion.UserEvent.UserEventData. DataType = SAHPI_TL_TYPE_TEXT; status = saHpiEventLogEntryAdd(session, resource, &EvtEntry); if (status == SA_ERR_HPI_INVALID_DATA) { retval = SAF_TEST_NOTSUPPORT; } else if (status == SA_ERR_HPI_OUT_OF_SPACE) { retval = SAF_TEST_NOTSUPPORT; } else if (status != SA_OK) { retval = SAF_TEST_UNRESOLVED; e_print(saHpiEventLogEntryAdd, SA_OK || SA_ERR_HPI_INVALID_DATA, status); } } } } if (retval == SAF_TEST_UNKNOWN) { status = saHpiEventLogEntryGet(session, resource, SAHPI_NEWEST_ENTRY, &PrevLogEntry, &NextLogEntry, &LogEntry, NULL, NULL); if (status != SA_OK) { e_print(saHpiEventLogEntryGet, SA_OK, status); retval = SAF_TEST_FAIL; } else if (sameUserEvent(&EvtEntry, &LogEntry.Event)) retval = SAF_TEST_PASS; else { m_print("Didn't get the same event that was added!"); retval = SAF_TEST_FAIL; } status = saHpiEventLogClear(session, resource); if (status != SA_OK) e_print(saHpiEventLogClear, SA_OK, status); status = saHpiEventLogStateSet(session, resource, savedState); if (status != SA_OK) e_print(savedState, SA_OK, status); } return (retval); }
static int sa_show_evtlog(SaHpiResourceIdT resourceid) { SaErrorT rv = SA_OK; SaHpiSelInfoT info; SaHpiRptEntryT rptentry; SaHpiEntryIdT rptentryid; SaHpiEntryIdT nextrptentryid; SaHpiSelEntryIdT entryid; SaHpiSelEntryIdT nextentryid; SaHpiSelEntryIdT preventryid; SaHpiSelEntryT sel; SaHpiRdrT rdr; char date[30]; rptentryid = SAHPI_FIRST_ENTRY; while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY)) { rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry); if (!(rptentry.ResourceCapabilities & SAHPI_CAPABILITY_SEL)) { rptentryid = nextrptentryid; continue; /* no SEL here, try next RPT */ } if (rptentry.ResourceId == resourceid) { break; } rptentryid = nextrptentryid; } if ((rv != SA_OK) || (rptentryid == SAHPI_LAST_ENTRY)) { printf("The designated resource hasn't SEL.\n"); return SA_OK; } rv = saHpiEventLogInfoGet(sessionid,resourceid,&info); if (rv != SA_OK) { printf("saHpiEventLogInfoGet error %d\n",rv); return -1; } printf("EventLog entries=%d, size=%d, enabled=%d\n", info.Entries,info.Size,info.Enabled); saftime2str(info.UpdateTimestamp,date,30); printf("UpdateTime = %s, ", date); saftime2str(info.CurrentTime,date,30); printf("CurrentTime = %s\n", date); printf("Overflow = %d\n", info.OverflowFlag); printf("DeleteEntrySupported = %d\n", info.DeleteEntrySupported); if (info.Entries != 0){ entryid = SAHPI_OLDEST_ENTRY; while (entryid != SAHPI_NO_MORE_ENTRIES) { rv = saHpiEventLogEntryGet(sessionid,resourceid, entryid,&preventryid,&nextentryid, &sel,&rdr,NULL); if (rv != SA_OK) { printf("saHpiEventLogEntryGet error %d\n",rv); return -1; } ShowSel(&sel, &rdr, &rptentry); preventryid = entryid; entryid = nextentryid; } } else printf("SEL is empty\n"); return SA_OK; }
int main(int argc, char **argv) { int c; SaErrorT rv, rv_2; SaHpiVersionT hpiVer; SaHpiSessionIdT sessionid; /* Domain */ SaHpiDomainInfoT domainInfo; SaHpiEventLogEntryIdT entryid; SaHpiEventLogEntryIdT nextentryid; SaHpiEventLogEntryIdT preventryid; SaHpiEventLogInfoT info; SaHpiEventLogEntryT el; SaHpiRdrT rdr, *rdrptr; SaHpiRptEntryT rpt, *rptptr; printf("%s: version %s\n",argv[0],progver); while ( (c = getopt( argc, argv,"cdpx?")) != EOF ) switch(c) { case 'c': fclear = 1; break; case 'd': frdr = 1; break; case 'p': frpt = 1; break; case 'x': fdebug = 1; break; default: printf("\n\n\nUsage %s [-cdpx]\n",argv[0]); printf(" Where \n"); printf(" -c clears the event log\n"); printf(" -d also get RDR with the event log\n"); printf(" -p also get RPT with the event log\n"); printf(" -x displays eXtra debug messages\n\n\n"); exit(1); } /* * House keeping: * -- get (check?) hpi implementation version * -- open hpi session */ if (fdebug) printf("saHpiVersionGet\n"); hpiVer = saHpiVersionGet(); printf("Hpi Version %d Implemented.\n", hpiVer); rv = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID,&sessionid,NULL); if (rv != SA_OK) { if (rv == SA_ERR_HPI_ERROR) printf("saHpiSessionOpen: error %d, SpiLibd not running\n",rv); else printf("saHpiSessionOpen: %s\n", oh_lookup_error(rv)); exit(-1); } rv = saHpiDiscover(sessionid); if (fdebug) printf("saHpiResourcesDiscover %s\n", oh_lookup_error(rv)); rv = saHpiDomainInfoGet(sessionid, &domainInfo); if (fdebug) printf("saHpiDomainInfoGet %s\n", oh_lookup_error(rv)); printf("DomainInfo: UpdateCount = %d, UpdateTime = %lx\n", domainInfo.RptUpdateCount, (unsigned long)domainInfo.RptUpdateTimestamp); /* initialize structure */ info.Entries = 0; info.Size = 0; info.Enabled = 0; rv_2 = saHpiEventLogInfoGet(sessionid,SAHPI_UNSPECIFIED_RESOURCE_ID,&info); if (fdebug) printf("saHpiEventLogInfoGet %s\n", oh_lookup_error(rv)); if (rv_2 == SA_OK) { printf("Domain EventLogInfo\n"); oh_print_eventloginfo(&info, 4); } else { printf("Domain saHpiEventLogInfoGet %s\n", oh_lookup_error(rv_2)); } if (fclear) { rv = saHpiEventLogClear(sessionid,SAHPI_UNSPECIFIED_RESOURCE_ID); if (rv == SA_OK) printf("EventLog successfully cleared\n"); else printf("EventLog clear, error = %d, %s\n", rv, oh_lookup_error(rv)); return(0); } if (info.Entries != 0){ rv = SA_OK; entryid = SAHPI_OLDEST_ENTRY; while ((rv == SA_OK) && (entryid != SAHPI_NO_MORE_ENTRIES)) { if (frdr) rdrptr = &rdr; else rdrptr = NULL; if (frpt) rptptr = &rpt; else rptptr = NULL; rv = saHpiEventLogEntryGet(sessionid,SAHPI_UNSPECIFIED_RESOURCE_ID, entryid,&preventryid, &nextentryid, &el, rdrptr, rptptr); if (fdebug) printf("saHpiEventLogEntryGet %s\n", oh_lookup_error(rv)); if (rv == SA_OK) { oh_print_eventlogentry(&el, 6); if (frdr) { if (rdrptr->RdrType == SAHPI_NO_RECORD) printf(" No RDR associated with EventType = %s\n\n", oh_lookup_eventtype(el.Event.EventType)); else oh_print_rdr(rdrptr, 12); } if (frpt) { if (rptptr->ResourceCapabilities == 0) printf(" No RPT associated with EventType = %s\n\n", oh_lookup_eventtype(el.Event.EventType)); else oh_print_rptentry(rptptr, 10); } preventryid = entryid; entryid = nextentryid; } else { printf("Domain EventLogEntryGet, error = %d, %s\n", rv, oh_lookup_error(rv)); break; } } } else printf("\tSEL is empty.\n\n"); rv = saHpiSessionClose(sessionid); return(0); }