int Test_Rdr(SaHpiSessionIdT session,
SaHpiResourceIdT resourceId, SaHpiRdrT rdr)
{
SaErrorT status;
int retval = SAF_TEST_UNKNOWN;
SaHpiSensorReadingT reading;
SaHpiEventStateT EventState;
if (rdr.RdrType == SAHPI_SENSOR_RDR) {
//
// Call saHpiSensorReadingGet passing in a bad Sensor Number
//
status = saHpiSensorReadingGet(session,
resourceId,
UNLIKELY_SENSOR_NUM,
&reading, &EventState);
if (status != SA_ERR_HPI_NOT_PRESENT) {
e_print(saHpiSensorReadingGet, SA_ERR_HPI_NOT_PRESENT,
status);
retval = SAF_TEST_FAIL;
} else
retval = SAF_TEST_PASS;
} else
retval = SAF_TEST_NOTSUPPORT;
return (retval);
}
SaErrorT show_sensor(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid,
SaHpiSensorNumT sensornum, hpi_ui_print_cb_t proc)
{
SaHpiSensorReadingT reading;
SaHpiEventStateT status;
SaErrorT rv;
char buf[1024];
rv = saHpiSensorReadingGet(sessionid, resourceid, sensornum,
&reading, &status);
if (rv != SA_OK) {
snprintf(buf, 1024, "ERROR: saHpiSensorReadingGet error = %s\n",
oh_lookup_error(rv));
proc(buf);
return rv;
}
if (reading.IsSupported) {
snprintf(buf, 1024, " : Sensor status = %x", status);
proc(buf);
print_thres_value(&reading, " Reading Value =", proc);
};
show_sensor_status(sessionid, resourceid, sensornum, proc);
show_threshold(sessionid, resourceid, sensornum, proc);
return SA_OK;
}
static void
thres_read(SaHpiSessionIdT sessionid,
SaHpiResourceIdT resourceid,
SaHpiRdrT *rdr)
{
SaHpiSensorReadingT reading;
SaHpiSensorThresholdsT thres;
SaHpiSensorRecT *rec;
SaErrorT rv;
rec = &rdr->RdrTypeUnion.SensorRec;
rv = saHpiSensorReadingGet(sessionid, resourceid, rec->Num, &reading);
if (rv != SA_OK) {
printf( "saHpiSensorReadingGet error %d\n",rv);
return;
}
printf("sensor(%s)\n",gettext(&rdr->IdString));
printf("current reading:");
reading_print(&reading);
printf("\n");
rv = saHpiSensorThresholdsGet(sessionid, resourceid, rec->Num, &thres);
if (rv != SA_OK) {
printf( "saHpiSensorThresholdsGet error %d\n",rv);
return;
}
printf("current threshold:\n");
thres_print(&thres);
}
static int
bladehpi_status(StonithPlugin *s)
{
struct pluginDevice * dev;
SaErrorT ohrc;
SaHpiDomainInfoT ohdi;
int rc = S_OK;
if (Debug) {
LOG(PIL_DEBUG, "%s: called", __FUNCTION__);
}
ERRIFWRONGDEV(s, S_OOPS);
dev = (struct pluginDevice *)s;
rc = open_hpi_session(dev);
if( rc != S_OK )
return rc;
/* Refresh the hostlist only if RPTs updated */
ohrc = saHpiDomainInfoGet(dev->ohsession, &ohdi);
if (ohrc != SA_OK) {
LOG(PIL_CRIT, "Unable to get domain info in %s (%d)"
, __FUNCTION__, ohrc);
rc = S_BADCONFIG;
goto done;
}
if (dev->ohrptcnt != ohdi.RptUpdateCount) {
free_bladehpi_hostlist(dev);
if (get_bladehpi_hostlist(dev) != S_OK) {
LOG(PIL_CRIT, "Unable to obtain list of hosts in %s"
, __FUNCTION__);
rc = S_BADCONFIG;
goto done;
}
}
/* At this point, hostlist is up to date */
if (dev->ohsensid && dev->ohsensnum) {
/*
* For accurate status, need to make a call that goes out to
* BladeCenter MM because the calls made so far by this
* function (and perhaps get_bladehpi_hostlist) only retrieve
* information from memory cached by OpenHPI
*/
ohrc = saHpiSensorReadingGet(dev->ohsession
, dev->ohsensid, dev->ohsensnum, NULL, NULL);
if (ohrc == SA_ERR_HPI_BUSY || ohrc == SA_ERR_HPI_NO_RESPONSE) {
LOG(PIL_CRIT, "Unable to connect to BladeCenter in %s"
, __FUNCTION__);
rc = S_OOPS;
goto done;
}
}
done:
close_hpi_session(dev);
return (rc == S_OK) ? (dev->ohdevid ? S_OK : S_OOPS) : rc;
}
int Test_Rdr(SaHpiSessionIdT session_id, SaHpiResourceIdT resource_id,
SaHpiRdrT rdr)
{
SaHpiBoolT enable, enable_old;
SaErrorT val;
SaHpiSensorNumT num;
int ret = SAF_TEST_UNKNOWN;
SaHpiSensorReadingT reading;
/* Need to skip sensors which we can't set */
if (rdr.RdrType == SAHPI_SENSOR_RDR &&
rdr.RdrTypeUnion.SensorRec.EnableCtrl != SAHPI_FALSE) {
num = rdr.RdrTypeUnion.SensorRec.Num;
val = saHpiSensorEnableGet(session_id, resource_id, num,
&enable_old);
if (val != SA_OK) {
e_print(saHpiSensorEnableGet, SA_OK, val);
ret = SAF_TEST_UNRESOLVED;
goto out;
}
if (enable_old) {
enable = SAHPI_FALSE;
val = saHpiSensorEnableSet(session_id, resource_id, num,
enable);
if (val != SA_OK) {
e_print(saHpiSensorEnableSet, SA_OK, val);
ret = SAF_TEST_UNRESOLVED;
goto out1;
}
}
val = saHpiSensorReadingGet(session_id, resource_id, num,
&reading, NULL);
if (val != SA_ERR_HPI_INVALID_REQUEST) {
e_print(saHpiSensorReadingGet, val != SA_OK, val);
ret = SAF_TEST_FAIL;
} else
ret = SAF_TEST_PASS;
if (ret == SAF_TEST_UNKNOWN)
ret = SAF_TEST_PASS;
out1:
val = saHpiSensorEnableSet(session_id, resource_id, num,
enable_old);
if (val != SA_OK)
e_print(saHpiSensorEnableSet, SA_OK, val);
} else
ret = SAF_TEST_NOTSUPPORT;
out:
return ret;
}
static void show_reading_value(Rpt_t *Rpt, Rdr_t *R)
{
SaHpiSensorUnitsT k;
SaErrorT rv;
char unit[128];
rv = saHpiSensorReadingGet(sessionid, Rpt->Rpt.ResourceId,
R->Rdr.RdrTypeUnion.SensorRec.Num, &(R->reading), NULL);
if (rv != SA_OK) {
printf("ERROR: %s\n", oh_lookup_error(rv));
return;
};
k = R->Rdr.RdrTypeUnion.SensorRec.DataFormat.BaseUnits;
printf("Reading value: ");
snprintf(unit, 128, "%s", oh_lookup_sensorunits(k));
print_value(&(R->reading), unit);
}
int main(int argc, char **argv)
{
SaHpiSessionIdT sid = 0;
SaHpiSensorReadingT reading;
SaHpiEventStateT state;
SaErrorT rc = SA_OK;
rc = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID, &sid, NULL);
if (rc != SA_OK) {
dbg("Failed to open session");
return -1;
}
rc = saHpiDiscover(sid);
if (rc != SA_OK) {
dbg("Failed to run discover");
return -1;
}
/* get the resource id of the chassis */
SaHpiResourceIdT resid = get_resid(sid, SAHPI_ENT_SYSTEM_CHASSIS);
if (resid == 0) {
dbg("Couldn't find the resource id of the chassis");
return -1;
}
/* get a sensor reading */
rc = saHpiSensorReadingGet(sid, resid, 1, &reading, &state);
if (rc != SA_OK) {
dbg("Couldn't get a sensor reading");
dbg("Error %s",oh_lookup_error(rc));
return -1;
}
return 0;
}
void list_rdr(SaHpiSessionIdT session_id, SaHpiResourceIdT resource_id)
{
SaErrorT err;
SaHpiEntryIdT current_rdr;
SaHpiEntryIdT next_rdr;
SaHpiRdrT rdr;
SaHpiSensorReadingT reading;
SaHpiSensorTypeT sensor_type;
SaHpiSensorNumT sensor_num;
SaHpiEventCategoryT category;
SaHpiSensorThresholdsT thres;
SaHpiCtrlNumT ctrl_num;
SaHpiCtrlStateT state;
SaHpiCtrlTypeT ctrl_type;
SaHpiEirIdT l_eirid;
SaHpiInventoryDataT* l_inventdata;
const SaHpiUint32T l_inventsize = 16384;
SaHpiUint32T l_actualsize;
printf("RDR Info:\n");
next_rdr = SAHPI_FIRST_ENTRY;
do {
char tmp_epath[128];
current_rdr = next_rdr;
err = saHpiRdrGet(session_id, resource_id, current_rdr,
&next_rdr, &rdr);
if (SA_OK != err) {
if (current_rdr == SAHPI_FIRST_ENTRY)
printf("Empty RDR table\n");
else
error("saHpiRdrGet", err);
return;
}
printf("\tRecordId: %x\n", rdr.RecordId);
printf("\tRdrType: %s\n", rdrtype2str(rdr.RdrType));
if (rdr.RdrType == SAHPI_SENSOR_RDR)
{
SaErrorT val;
sensor_num = rdr.RdrTypeUnion.SensorRec.Num;
val = saHpiSensorTypeGet(session_id, resource_id,
sensor_num, &sensor_type,
&category);
printf("\tSensor num: %i\n\tType: %s\n", sensor_num, get_sensor_type(sensor_type));
printf("\tCategory: %s\n", get_sensor_category(category));
memset(&reading, 0, sizeof(SaHpiSensorReadingT));
err = saHpiSensorReadingGet(session_id, resource_id, sensor_num, &reading);
if (err != SA_OK) {
printf("Error=%d reading sensor data {sensor, %d}\n", err, sensor_num);
continue;
}
if (reading.ValuesPresent & SAHPI_SRF_RAW) {
printf("\tValues Present: RAW\n");
printf("\t\tRaw value: %d\n", reading.Raw);
}
if (reading.ValuesPresent & SAHPI_SRF_INTERPRETED) {
printf("\tValues Present: Interpreted\n");
printf("\t\t");
interpreted2str(reading.Interpreted);
}
if (reading.ValuesPresent & SAHPI_SRF_EVENT_STATE) {
printf("\tValues Present: Event State\n");
}
if (rdr.RdrTypeUnion.SensorRec.ThresholdDefn.IsThreshold == SAHPI_TRUE) {
memset(&thres, 0, sizeof(SaHpiSensorThresholdsT));
err = saHpiSensorThresholdsGet(session_id, resource_id, sensor_num, &thres);
if (err != SA_OK) {
printf("Error=%d reading sensor thresholds {sensor, %d}\n", err, sensor_num);
continue;
}
if (thres.LowCritical.ValuesPresent) {
printf("\t\tThreshold: Low Critical Values\n");
printreading(thres.LowCritical);
}
if (thres.LowMajor.ValuesPresent) {
printf("\t\tThreshold: Low Major Values\n");
printreading(thres.LowMajor);
}
if (thres.LowMinor.ValuesPresent) {
printf("\t\tThreshold: Low Minor Values\n");
printreading(thres.LowMinor);
}
if (thres.UpCritical.ValuesPresent) {
printf("\t\tThreshold: Up Critical Values\n");
printreading(thres.UpCritical);
}
if (thres.UpMajor.ValuesPresent) {
printf("\t\tThreshold: Up Major Values\n");
printreading(thres.UpMajor);
}
if (thres.UpMinor.ValuesPresent) {
printf("\t\tThreshold: Up Minor Values\n");
printreading(thres.UpMinor);
}
if (thres.PosThdHysteresis.ValuesPresent) {
printf("\t\tThreshold: Pos Threshold Hysteresis Values\n");
printreading(thres.PosThdHysteresis);
}
if (thres.NegThdHysteresis.ValuesPresent) {
printf("\t\tThreshold: Neg Threshold Hysteresis Values\n");
printreading(thres.NegThdHysteresis);
}
}
}
if (rdr.RdrType == SAHPI_CTRL_RDR)
{
ctrl_num = rdr.RdrTypeUnion.CtrlRec.Num;
err = saHpiControlTypeGet(session_id, resource_id, ctrl_num, &ctrl_type);
if (err != SA_OK) {
printf("Error=%d reading control type {control, %d}\n", err, ctrl_num);
continue;
}
printf("\tControl num: %i\n\tType: %s\n", ctrl_num, get_control_type(ctrl_type));
err = saHpiControlStateGet(session_id, resource_id, ctrl_num, &state);
if (err != SA_OK) {
printf("Error=%d reading control state {control, %d}\n", err, ctrl_num);
continue;
}
if (ctrl_type != state.Type) {
printf("Control Type mismatch between saHpiControlTypeGet=%d and saHpiControlStateGet = %d\n",
ctrl_type, state.Type);
}
switch (state.Type) {
case SAHPI_CTRL_TYPE_DIGITAL:
printf("\t\tControl Digital State: %s\n",
ctrldigital2str(state.StateUnion.Digital));
break;
case SAHPI_CTRL_TYPE_DISCRETE:
printf("\t\tControl Discrete State: %x\n", state.StateUnion.Discrete);
break;
case SAHPI_CTRL_TYPE_ANALOG:
printf("\t\tControl Analog State: %x\n", state.StateUnion.Analog);
break;
case SAHPI_CTRL_TYPE_STREAM:
printf("\t\tControl Stream Repeat: %d\n", state.StateUnion.Stream.Repeat);
printf("\t\tControl Stream Data: ");
display_oembuffer(state.StateUnion.Stream.StreamLength, state.StateUnion.Stream.Stream);
break;
case SAHPI_CTRL_TYPE_TEXT:
printf("\t\tControl Text Line Num: %c\n", state.StateUnion.Text.Line);
display_textbuffer(state.StateUnion.Text.Text);
break;
case SAHPI_CTRL_TYPE_OEM:
printf("\t\tControl OEM Manufacturer: %d\n", state.StateUnion.Oem.MId);
printf("\t\tControl OEM Data: ");
display_oembuffer((SaHpiUint32T)state.StateUnion.Oem.BodyLength,
state.StateUnion.Oem.Body);
break;
default:
printf("\t\tInvalid control type (%d) from saHpiControlStateGet\n",
state.Type);
}
}
if (rdr.RdrType == SAHPI_INVENTORY_RDR)
{
l_eirid = rdr.RdrTypeUnion.InventoryRec.EirId;
l_inventdata = (SaHpiInventoryDataT *)g_malloc(l_inventsize);
err = saHpiEntityInventoryDataRead(session_id, resource_id,
l_eirid, l_inventsize,
l_inventdata, &l_actualsize);
if (err != SA_OK) {
printf("Error=%d reading inventory type {EirId, %d}\n", err, l_eirid);
continue;
} else if (l_inventdata->Validity == SAHPI_INVENT_DATA_VALID) {
printf("\tFound Inventory RDR with EirId: %x\n", l_eirid);
printf("\tRDR l_inventsize = %d, actualsize = %d\n", l_inventsize, l_actualsize);
switch (l_inventdata->DataRecords[0]->RecordType)
{
case SAHPI_INVENT_RECTYPE_INTERNAL_USE:
printf( "Internal Use\n");
break;
case SAHPI_INVENT_RECTYPE_PRODUCT_INFO:
printf( "Product Info\n");
break;
case SAHPI_INVENT_RECTYPE_CHASSIS_INFO:
printf( "Chassis Info\n");
break;
case SAHPI_INVENT_RECTYPE_BOARD_INFO:
printf( "Board Info\n");
break;
case SAHPI_INVENT_RECTYPE_OEM:
printf( "OEM Record\n");
break;
default:
printf(" Invalid Invent Rec Type =%x\n",
l_inventdata->DataRecords[0]->RecordType);
break;
}
}
g_free(l_inventdata);
}
printf("\tEntity: \n");
entitypath2string(&rdr.Entity, tmp_epath, sizeof(tmp_epath));
printf("\t\t%s\n", tmp_epath);
printf("\tIdString: ");
display_textbuffer(rdr.IdString);
printf("\n"); /* Produce blank line between rdrs. */
}while(next_rdr != SAHPI_LAST_ENTRY);
}
static void ShowSensor(
SaHpiSessionIdT sessionid,
SaHpiResourceIdT resourceid,
SaHpiSensorRecT *sensorrec )
{
SaHpiSensorNumT sensornum;
SaHpiSensorReadingT reading;
SaHpiSensorReadingT conv_reading;
SaHpiSensorThresholdsT senstbuff;
SaErrorT rv;
char *unit;
int i;
sensornum = sensorrec->Num;
rv = saHpiSensorReadingGet(sessionid,resourceid, sensornum, &reading);
if (rv != SA_OK) {
printf("ReadingGet ret=%d\n", rv);
return;
}
if ((reading.ValuesPresent & SAHPI_SRF_INTERPRETED) == 0) {
if ((reading.ValuesPresent & SAHPI_SRF_RAW) == 0) {
/* no raw or interpreted, so just show event status */
/* This is a Compact Sensor */
if (reading.ValuesPresent & SAHPI_SRF_EVENT_STATE)
printf(" = %x %x\n", reading.EventStatus.SensorStatus,
reading.EventStatus.EventStatus);
else printf(" = no reading\n");
return;
} else {
/* have raw, but not interpreted, so try convert. */
rv = saHpiSensorReadingConvert(sessionid, resourceid, sensornum,
&reading, &conv_reading);
if (rv != SA_OK) {
printf("raw=%x conv_ret=%d\n", reading.Raw, rv);
/* printf("conv_rv=%s\n", decode_error(rv)); */
return;
}
else {
if (fdebug) printf("conv ok: raw=%x conv=%x\n", reading.Raw,
conv_reading.Interpreted.Value.SensorUint32);
reading.Interpreted.Type = conv_reading.Interpreted.Type;
if (reading.Interpreted.Type == SAHPI_SENSOR_INTERPRETED_TYPE_BUFFER)
{
memcpy(reading.Interpreted.Value.SensorBuffer,
conv_reading.Interpreted.Value.SensorBuffer,
4); /* SAHPI_SENSOR_BUFFER_LENGTH); */
/* IPMI 1.5 only returns 4 bytes */
} else
reading.Interpreted.Value.SensorUint32 =
conv_reading.Interpreted.Value.SensorUint32;
}
}
}
/* Also show units of interpreted reading */
i = sensorrec->DataFormat.BaseUnits;
if (i >= NSU) i = 0;
unit = units[i];
switch(reading.Interpreted.Type)
{
case SAHPI_SENSOR_INTERPRETED_TYPE_FLOAT32:
printf(" = %5.2f %s\n",
reading.Interpreted.Value.SensorFloat32,unit);
break;
case SAHPI_SENSOR_INTERPRETED_TYPE_UINT32:
printf(" = %d %s\n",
reading.Interpreted.Value.SensorUint32, unit);
break;
case SAHPI_SENSOR_INTERPRETED_TYPE_BUFFER:
printf(" = %02x %02x %02x %02x\n",
reading.Interpreted.Value.SensorBuffer[0],
reading.Interpreted.Value.SensorBuffer[1],
reading.Interpreted.Value.SensorBuffer[2],
reading.Interpreted.Value.SensorBuffer[3]);
break;
default:
printf(" = %x (itype=%x)\n",
reading.Interpreted.Value.SensorUint32,
reading.Interpreted.Type);
}
if (fshowthr) {
#ifdef SHOWMAX
if ( sensorrec->DataFormat.Range.Flags & SAHPI_SRF_MAX )
printf( " Max of Range: %5.2f\n",
sensorrec->DataFormat.Range.Max.Interpreted.Value.SensorFloat32);
if ( sensorrec->DataFormat.Range.Flags & SAHPI_SRF_MIN )
printf( " Min of Range: %5.2f\n",
sensorrec->DataFormat.Range.Min.Interpreted.Value.SensorFloat32);
#endif
/* Show thresholds, if any */
if ((!sensorrec->Ignore) && (sensorrec->ThresholdDefn.IsThreshold)) {
rv = saHpiSensorThresholdsGet(sessionid, resourceid,
sensornum, &senstbuff);
printf( "\t\t\t");
if ( sensorrec->ThresholdDefn.ReadThold & SAHPI_STM_LOW_MINOR ) {
printf( "LoMin %5.2f ",
senstbuff.LowMinor.Interpreted.Value.SensorFloat32);
}
if ( sensorrec->ThresholdDefn.ReadThold & SAHPI_STM_LOW_MAJOR ) {
printf( "LoMaj %5.2f ",
senstbuff.LowMajor.Interpreted.Value.SensorFloat32);
}
if ( sensorrec->ThresholdDefn.ReadThold & SAHPI_STM_LOW_CRIT ) {
printf( "LoCri %5.2f ",
senstbuff.LowCritical.Interpreted.Value.SensorFloat32);
}
if ( sensorrec->ThresholdDefn.ReadThold & SAHPI_STM_UP_MINOR ) {
printf( "HiMin %5.2f ",
senstbuff.UpMinor.Interpreted.Value.SensorFloat32);
}
if ( sensorrec->ThresholdDefn.ReadThold & SAHPI_STM_UP_MAJOR ) {
printf( "HiMaj %5.2f ",
senstbuff.UpMajor.Interpreted.Value.SensorFloat32);
}
if ( sensorrec->ThresholdDefn.ReadThold & SAHPI_STM_UP_CRIT ) {
printf( "HiCri %5.2f ",
senstbuff.UpCritical.Interpreted.Value.SensorFloat32);
}
#ifdef SHOWMAX
if ( sensorrec->ThresholdDefn.ReadThold & SAHPI_STM_UP_HYSTERESIS ) {
printf( "Hi Hys %5.2f ",
senstbuff.PosThdHysteresis.Interpreted.Value.SensorFloat32);
}
if ( sensorrec->ThresholdDefn.ReadThold & SAHPI_STM_LOW_HYSTERESIS ) {
printf( "Lo Hys %5.2f ",
senstbuff.NegThdHysteresis.Interpreted.Value.SensorFloat32);
}
#endif
printf( "\n");
} /* endif valid threshold */
} /* endif showthr */
return;
} /*end ShowSensor*/
/*
* This routine get sensor reading and threshold, and display them.
*
**/
static
void sensor_readingthreshold(SaHpiSessionIdT sessionid,
SaHpiResourceIdT resourceid,
SaHpiRdrT *rdrptr)
{
SaHpiSensorRecT *sensorrec;
SaHpiSensorNumT sensornum;
SaHpiSensorReadingT reading;
SaHpiSensorThresholdsT thresh;
SaHpiEventStateT events;
SaHpiTextBufferT text;
SaErrorT rv;
sensorrec = &rdrptr->RdrTypeUnion.SensorRec;
sensornum = sensorrec->Num;
rv = saHpiSensorReadingGet(sessionid,resourceid, sensornum, &reading, &events);
if (rv != SA_OK) {
printf("\nReadingGet ret=%s\n", oh_lookup_error(rv));
return;
}
if (!reading.IsSupported ) {
printf("\t Reading Not Supported for sensor %d!\n\n", sensornum);
return;
}
if((rv = oh_decode_sensorreading(reading, sensorrec->DataFormat, &text)) == SA_OK) {
printf("\t Sensor %d reading = %s\n", sensornum, text.Data);
} else {
printf("\n\t Sensor %d Reading FAILED, %s\n", sensornum, oh_lookup_error(rv));
}
rv = saHpiSensorThresholdsGet(sessionid,resourceid, sensornum, &thresh);
if (rv != SA_OK) {
printf("\t ThresholdsGet ret=%s\n\n", oh_lookup_error(rv));
return;
}
printf( "\t Thresholds::\n" );
if (thresh.LowCritical.IsSupported) {
if((rv = oh_decode_sensorreading(thresh.LowCritical,
sensorrec->DataFormat, &text)) == SA_OK) {
printf( "\t\tLow Critical Threshold: %s\n", text.Data);
} else {
printf( "\t\tLow Critical Threshold: FAILED %s\n", oh_lookup_error(rv));
}
}
if (thresh.LowMajor.IsSupported) {
if((rv = oh_decode_sensorreading(thresh.LowMajor,
sensorrec->DataFormat, &text)) == SA_OK) {
printf( "\t\tLow Major Threshold: %s\n", text.Data);
} else {
printf( "\t\tLow Major Threshold: FAILED %s\n", oh_lookup_error(rv));
}
}
if (thresh.LowMinor.IsSupported) {
if((rv = oh_decode_sensorreading(thresh.LowMinor,
sensorrec->DataFormat, &text)) == SA_OK) {
printf( "\t\tLow Minor Threshold: %s\n", text.Data);
} else {
printf( "\t\tLow Minor Threshold: FAILED %s\n", oh_lookup_error(rv));
}
}
if (thresh.UpCritical.IsSupported) {
if((rv = oh_decode_sensorreading(thresh.UpCritical,
sensorrec->DataFormat, &text)) == SA_OK) {
printf( "\t\tUp Critical Threshold: %s\n", text.Data);
} else {
printf( "\t\tUp Critical Threshold: FAILED %s\n", oh_lookup_error(rv));
}
}
if (thresh.UpMajor.IsSupported) {
if((rv = oh_decode_sensorreading(thresh.UpMajor,
sensorrec->DataFormat, &text)) == SA_OK) {
printf( "\t\tUp Major Threshold: %s\n", text.Data);
} else {
printf( "\t\tUp Major Threshold: FAILED %s\n", oh_lookup_error(rv));
}
}
if (thresh.UpMinor.IsSupported) {
if((rv = oh_decode_sensorreading(thresh.UpMinor,
sensorrec->DataFormat, &text)) == SA_OK) {
printf( "\t\tUp Minor Threshold: %s\n", text.Data);
} else {
printf( "\t\tUp Minor Threshold: FAILED %s\n", oh_lookup_error(rv));
}
}
if (thresh.PosThdHysteresis.IsSupported) {
if((rv = oh_decode_sensorreading(thresh.PosThdHysteresis,
sensorrec->DataFormat, &text)) == SA_OK) {
printf( "\t\tPos Threshold Hysteresis: %s\n", text.Data);
} else {
printf( "\t\tPos Threshold Hysteresis: FAILED %s\n", oh_lookup_error(rv));
}
}
if (thresh.NegThdHysteresis.IsSupported) {
if((rv = oh_decode_sensorreading(thresh.NegThdHysteresis,
sensorrec->DataFormat, &text)) == SA_OK) {
printf( "\t\tNeg Threshold Hysteresis: %s\n", text.Data);
} else {
printf( "\t\tNeg Threshold Hysteresis: FAILED %s\n", oh_lookup_error(rv));
}
}
printf("\n\n\n");
}
SaErrorT show_sensor(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid,
SaHpiSensorNumT sensornum, hpi_ui_print_cb_t proc)
{
SaHpiSensorReadingT reading;
SaHpiEventStateT status, assert, deassert;
SaHpiRdrT rdr;
SaErrorT rv;
SaHpiBoolT val;
char buf[SHOW_BUF_SZ];
char errbuf[SHOW_BUF_SZ];
Pr_ret_t res;
rv = saHpiRdrGetByInstrumentId(sessionid, resourceid, SAHPI_SENSOR_RDR,
sensornum, &rdr);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiRdrGetByInstrumentId: error: %s\n",
oh_lookup_error(rv));
proc(errbuf);
return(rv);
};
snprintf(buf, SHOW_BUF_SZ, "Sensor(%d/%d) %s", resourceid, sensornum,
oh_lookup_sensortype(rdr.RdrTypeUnion.SensorRec.Type));
proc(buf);
res = print_text_buffer_text(" ", &(rdr.IdString), "\n", proc);
if (res != HPI_UI_OK) return(SA_OK);
rv = saHpiSensorEnableGet(sessionid, resourceid, sensornum, &val);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiSensorEnableGet: error: %s\n",
oh_lookup_error(rv));
if (proc(errbuf) != HPI_UI_OK) return(rv);
} else {
if (val) res = proc("Enable ");
else res = proc("Disable ");
if (res != HPI_UI_OK) return(SA_OK);
};
rv = saHpiSensorEventEnableGet(sessionid, resourceid, sensornum, &val);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiSensorEventEnableGet: error: %s\n",
oh_lookup_error(rv));
if (proc(errbuf) != HPI_UI_OK) return(rv);
} else {
if (proc(" event : ") != HPI_UI_OK) return(SA_OK);
if (val) res = proc("Enable");
else res = proc("Disable");
if (res != HPI_UI_OK) return(SA_OK);
};
rv = saHpiSensorEventMasksGet(sessionid, resourceid, sensornum,
&assert, &deassert);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiSensorEventMasksGet: error: %s\n",
oh_lookup_error(rv));
if (proc(errbuf) != HPI_UI_OK) return(rv);
} else {
snprintf(buf, SHOW_BUF_SZ,
" supported: 0x%4.4x masks: assert = 0x%4.4x"
" deassert = 0x%4.4x\n",
rdr.RdrTypeUnion.SensorRec.Events, assert, deassert);
if (proc(buf) != HPI_UI_OK) return(rv);
};
rv = saHpiSensorReadingGet(sessionid, resourceid, sensornum,
&reading, &status);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiSensorReadingGet: error: %s\n",
oh_lookup_error(rv));
proc(errbuf);
return(rv);
};
snprintf(buf, SHOW_BUF_SZ, "\tEvent states = 0x%x\n", status);
if (proc(buf) != HPI_UI_OK) return(SA_OK);
if (reading.IsSupported) {
res = print_thres_value(&reading, "\tReading Value =",
NULL, 0, proc);
if (res == HPI_UI_END) return(SA_OK);
} else {
if (proc("\tReading not supported\n") != HPI_UI_OK) return(SA_OK);
}
show_threshold(sessionid, resourceid, sensornum,
&(rdr.RdrTypeUnion.SensorRec), proc);
return SA_OK;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiSensorNumT dd_sid = 0;
SaHpiEventStateT state;
SaHpiSensorReadingT reading;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundSensor;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return -1;
}
id = rptentry.ResourceId;
/**************************
* Test: find a sensor with desired property
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundSensor = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if ((rdr.RdrType == SAHPI_SENSOR_RDR) &&
(rdr.RdrTypeUnion.SensorRec.DataFormat.IsSupported == SAHPI_TRUE))
{
foundSensor = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundSensor) {
err("Did not find desired resource for test\n");
return(SA_OK);
} else {
dd_sid = rdr.RdrTypeUnion.SensorRec.Num;
}
/**************************
* Test : Read sensor with NULL Reading area. State only
**************************/
expected_err = SA_OK;
err = saHpiSensorReadingGet(sessionid, id, dd_sid, NULL, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test:Read with NULL State area, Read Value only
**************************/
err = saHpiSensorReadingGet(sessionid, id, dd_sid, &reading, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Both Reading and State are NULL. ie checking for sensor existance
**************************/
err = saHpiSensorReadingGet(sessionid, id, dd_sid, NULL, NULL);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
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 isReadingWithinMinorLimits(SaHpiSessionIdT sessionId,
SaHpiResourceIdT resourceId,
SaHpiSensorRecT * sensorRec)
{
SaErrorT status;
int retval = SAF_TEST_NOTSUPPORT;
SaHpiSensorReadingT reading;
SaHpiSensorThresholdsT thresholds;
SaHpiBoolT isWithin;
SaHpiSensorReadingT low, high;
status = saHpiSensorReadingGet(sessionId, resourceId,
sensorRec->Num, &reading, NULL);
if (status != SA_OK) {
retval = SAF_TEST_UNRESOLVED;
e_print(saHpiSensorReadingGet, SA_OK, status);
} else {
status = saHpiSensorThresholdsGet(sessionId, resourceId,
sensorRec->Num, &thresholds);
if (status != SA_OK) {
retval = SAF_TEST_UNRESOLVED;
e_print(saHpiSensorThresholdsGet, SA_OK, status);
} else {
switch (reading.Type) {
case SAHPI_SENSOR_READING_TYPE_INT64:
low.Value.SensorInt64 =
thresholds.LowMinor.Value.SensorInt64;
if (thresholds.NegThdHysteresis.IsSupported) {
low.Value.SensorInt64 +=
thresholds.NegThdHysteresis.Value.
SensorInt64;
}
high.Value.SensorInt64 =
thresholds.UpMinor.Value.SensorInt64;
if (thresholds.PosThdHysteresis.IsSupported) {
high.Value.SensorInt64 -=
thresholds.PosThdHysteresis.Value.
SensorInt64;
}
isWithin =
(reading.Value.SensorInt64 >
low.Value.SensorInt64)
&& (reading.Value.SensorInt64 <
high.Value.SensorInt64);
break;
case SAHPI_SENSOR_READING_TYPE_UINT64:
low.Value.SensorUint64 =
thresholds.LowMinor.Value.SensorUint64;
if (thresholds.NegThdHysteresis.IsSupported) {
low.Value.SensorUint64 +=
thresholds.NegThdHysteresis.Value.
SensorUint64;
}
high.Value.SensorUint64 =
thresholds.UpMinor.Value.SensorUint64;
if (thresholds.PosThdHysteresis.IsSupported) {
high.Value.SensorUint64 -=
thresholds.PosThdHysteresis.Value.
SensorUint64;
}
isWithin =
(reading.Value.SensorUint64 >
low.Value.SensorUint64)
&& (reading.Value.SensorUint64 <
high.Value.SensorUint64);
break;
case SAHPI_SENSOR_READING_TYPE_FLOAT64:
low.Value.SensorFloat64 =
thresholds.LowMinor.Value.SensorFloat64;
if (thresholds.NegThdHysteresis.IsSupported) {
low.Value.SensorFloat64 +=
thresholds.NegThdHysteresis.Value.
SensorFloat64;
}
high.Value.SensorFloat64 =
thresholds.UpMinor.Value.SensorFloat64;
if (thresholds.PosThdHysteresis.IsSupported) {
high.Value.SensorFloat64 -=
thresholds.PosThdHysteresis.Value.
SensorFloat64;
}
isWithin =
(reading.Value.SensorFloat64 >
low.Value.SensorFloat64)
&& (reading.Value.SensorFloat64 <
high.Value.SensorFloat64);
break;
case SAHPI_SENSOR_READING_TYPE_BUFFER:
isWithin = SAHPI_FALSE;
break;
}
if (isWithin) {
retval = SAF_TEST_PASS;
}
}
}
return retval;
}
int
populate_sensor (SaHpiEntryIdT rdr_id,
SaHpiSensorRecT * sensor,
SaHpiRptEntryT * rpt_entry,
oid * rdr_entry_oid, size_t rdr_entry_oid_len,
oid * sensor_oid, size_t * sensor_oid_len)
{
int rc = AGENT_ERR_NOERROR;
oid index_oid[SENSOR_INDEX_NR];
oid column[2];
netsnmp_index sensor_index;
#ifdef BUG_873961
int i = 0;
netsnmp_void_array *array;
saHpiSensorTable_context *ctx;
#endif
saHpiSensorTable_context *sensor_context;
SaHpiSensorThresholdsT sensor_threshold;
SaHpiSessionIdT session_id;
SaHpiSensorEvtEnablesT enables;
SaHpiSensorReadingT current_reading;
DEBUGMSGTL ((AGENT, "\n\t--- populate_sensor: Entry.\n"));
if (sensor)
{
sensor_index.len = SENSOR_INDEX_NR;
// Look at the MIB to find out what the indexs are
index_oid[0] = rpt_entry->DomainId;
index_oid[1] = rpt_entry->ResourceId;
index_oid[2] = sensor->Num;
sensor_index.oids = (oid *) & index_oid;
// We are re-populating. Check for existing entries
sensor_context = NULL;
sensor_context = CONTAINER_FIND (cb.container, &sensor_index);
// If we don't find it - we create it.
#ifdef BUG_873961
if (!sensor_context)
{
// Bug # 873961. We use the 'rdr_id' to check to see if
// it is the context. To do so, we have to search for it first.
sensor_index.len = 1;
// re-using the index_oid.
array = CONTAINER_GET_SUBSET (cb.container, &sensor_index);
if (array != NULL)
{
if (array->size > 0)
{
for (i = 0; i < array->size; i++)
{
ctx = array->array[i];
if (ctx->rdr_id == rdr_id)
{
// Found the duplicate entry!
sensor_context = ctx;
index_oid[1] = ctx->resource_id;
index_oid[2] = ctx->saHpiSensorIndex;
DEBUGMSGTL ((AGENT,
"duplicate sensor entry %d, %d, %d [rdr: %d] found.\n",
rpt_entry->DomainId,
rpt_entry->ResourceId, sensor->Num,
rdr_id));
break;
}
}
}
free (array->array);
free (array);
array = NULL;
}
// restoree it to its previous glory.
sensor_index.len = SENSOR_INDEX_NR;
}
#endif
if (!sensor_context)
{
// New entry. Add it
sensor_context = saHpiSensorTable_create_row (&sensor_index);
}
if (!sensor_context)
{
snmp_log (LOG_ERR, "Not enough memory for a sensor row!");
return AGENT_ERR_INTERNAL_ERROR;
}
// Generate our full OID
column[0] = 1;
column[1] = COLUMN_SAHPISENSORINDEX;
build_full_oid (saHpiSensorTable_oid, saHpiSensorTable_oid_len,
column, 2,
&sensor_index, sensor_oid, MAX_OID_LEN, sensor_oid_len);
// By this stage, sensor_context surely has something in it.
// '*_modify_context' does a checksum check to see if
// the record needs to be altered, and if so populates with
// information from RDR and the OIDs passed.
// Get Threshold Data
rc = getSaHpiSession (&session_id);
if (rc != AGENT_ERR_NOERROR)
{
DEBUGMSGTL ((AGENT, "Call to getSaHpiSession failed with rc: %d\n",
rc));
return rc;
}
if (sensor->ThresholdDefn.IsThreshold == SAHPI_TRUE)
{
rc = saHpiSensorThresholdsGet (session_id,
rpt_entry->ResourceId,
sensor->Num, &sensor_threshold);
if (rc != SA_OK)
{
snmp_log (LOG_ERR,
"Call to saHpiSensorThresholdsGet fails with return code: %s.\n",
get_error_string (rc));
DEBUGMSGTL ((AGENT,
"Call to SensorThresholdGet fails with return code: %s.\n",
get_error_string (rc)));
return AGENT_ERR_OPERATION;
}
}
/*
* No need to call a plugin that does not support
* events.
*/
if (sensor->EventCtrl != SAHPI_SEC_NO_EVENTS)
{
rc = saHpiSensorEventEnablesGet (session_id,
rpt_entry->ResourceId,
sensor->Num, &enables);
if (rc != SA_OK)
{
snmp_log (LOG_ERR,
"Call to saHpiSensorEventEnablesGet fails with return code: %s.\n",
get_error_string (rc));
DEBUGMSGTL ((AGENT,
"Call to saHpiSensorEventEnablesGet fails with return code: %s.\n",
get_error_string (rc)));
// We continue on working. No need to bail on that one - will just use 'undefined(0)' values.
}
}
rc = saHpiSensorReadingGet (session_id,
rpt_entry->ResourceId,
sensor->Num, ¤t_reading);
if (rc != SA_OK)
{
snmp_log (LOG_ERR,
"Call to saHpiSensorReadingGet fails with return code: %s.\n",
get_error_string (rc));
DEBUGMSGTL ((AGENT,
"Call to saHpiSensorReadingGet fails with return code: %s.\n",
get_error_string (rc)));
}
if (saHpiSensorTable_modify_context (rdr_id, sensor,
&enables,
rpt_entry,
rdr_entry_oid, rdr_entry_oid_len,
sensor_context) == AGENT_NEW_ENTRY)
{
CONTAINER_INSERT (cb.container, sensor_context);
sensor_count = CONTAINER_SIZE (cb.container);
}
/*
Update our child sensor tables
*/
rc = populate_ReadingCurrent (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
sensor->Category, ¤t_reading);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ReadingCurrent failed with rc: %d\n",
rc));
if (sensor_context->flags & SAHPI_SRF_MIN)
{
rc = populate_ReadingMin (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
sensor->Category,
&sensor->DataFormat.Range.Min);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ReadingMin failed with rc: %d\n",
rc));
}
if (sensor_context->flags & SAHPI_SRF_MAX)
{
rc = populate_ReadingMax (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
sensor->Category,
&sensor->DataFormat.Range.Max);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ReadingMax failed with rc: %d\n",
rc));
}
if (sensor_context->flags & SAHPI_SRF_NOMINAL)
{
rc = populate_ReadingNominal (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
sensor->Category,
&sensor->DataFormat.Range.Nominal);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ReadingNominal failed with rc: %d\n",
rc));
}
if (sensor_context->flags & SAHPI_SRF_NORMAL_MAX)
{
rc = populate_ReadingNormalMax (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
sensor->Category,
&sensor->DataFormat.Range.
NormalMax);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ReadingNormalMax failed with rc: %d\n",
rc));
}
if (sensor_context->flags & SAHPI_SRF_NORMAL_MIN)
{
rc = populate_ReadingNormalMin (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
sensor->Category,
&sensor->DataFormat.Range.
NormalMin);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ReadingNormalMin failed with rc: %d\n",
rc));
}
/*
* Thresholds
*/
if (sensor_context->saHpiSensorHasThresholds == MIB_TRUE)
{
/* if (sensor_context->thd_capabilities & SAHPI_STM_LOW_CRIT) */
{
rc = populate_ThdLowCritical (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
&sensor->ThresholdDefn,
&sensor_threshold.LowCritical);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ThdLowCritical failed with rc: %d\n",
rc));
}
/* if (sensor_context->thd_capabilities & SAHPI_STM_LOW_MAJOR) */
{
rc = populate_ThdLowMajor (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
&sensor->ThresholdDefn,
&sensor_threshold.LowMajor);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ThdLowMajor failed with rc: %d\n",
rc));
}
/* if (sensor_context->thd_capabilities & SAHPI_STM_LOW_MINOR) */
{
rc = populate_ThdLowMinor (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
&sensor->ThresholdDefn,
&sensor_threshold.LowMinor);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ThdLowMinor failed with rc: %d\n",
rc));
}
/* if (sensor_context->thd_capabilities & SAHPI_STM_UP_CRIT) */
{
rc = populate_ThdUpCritical (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
&sensor->ThresholdDefn,
&sensor_threshold.UpCritical);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ThdUpCritical failed with rc: %d\n",
rc));
}
/* if (sensor_context->thd_capabilities & SAHPI_STM_UP_MAJOR) */
{
rc = populate_ThdUpMajor (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
&sensor->ThresholdDefn,
&sensor_threshold.UpMajor);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ThdUpMajor failed with rc: %d\n",
rc));
}
/* if (sensor_context->thd_capabilities & SAHPI_STM_UP_MINOR) */
{
rc = populate_ThdUpMinor (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
&sensor->ThresholdDefn,
&sensor_threshold.UpMinor);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ThdUpMinor failed with rc: %d\n",
rc));
}
/* if (sensor_context->thd_capabilities & SAHPI_STM_UP_HYSTERESIS) */
{
rc = populate_ThdPosHysteresis (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
&sensor->ThresholdDefn,
&sensor_threshold.
PosThdHysteresis);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ThdPosHysteresis failed with rc: %d\n",
rc));
}
/* if (sensor_context->thd_capabilities & SAHPI_STM_LOW_HYSTERESIS) */
{
rc = populate_ThdNegHysteresis (rpt_entry->DomainId,
rpt_entry->ResourceId,
sensor->Num,
&sensor->ThresholdDefn,
&sensor_threshold.
NegThdHysteresis);
if (rc != AGENT_ERR_NOERROR)
DEBUGMSGTL ((AGENT,
"call to populate_ThdNegHysteresis failed with rc: %d\n",
rc));
}
}
rc = AGENT_ERR_NOERROR;
}
else
rc = AGENT_ERR_OPERATION;
DEBUGMSGTL ((AGENT, "\n\t--- populate_sensor. Exit\n"));
return rc;
}
static void
dordr(SaHpiSessionIdT sessionid,
SaHpiResourceIdT resourceid,
SaHpiRdrT *rdr)
{
SaHpiSensorReadingT reading;
SaHpiSensorThresholdsT thres;
SaHpiSensorRecT *rec;
SaErrorT rv;
if ( (rdr->RdrType == SAHPI_SENSOR_RDR) &&
!strcmp(sensor_name, gettext(&rdr->IdString))) {
rec = &rdr->RdrTypeUnion.SensorRec;
rv = saHpiSensorReadingGet(sessionid, resourceid, rec->Num, &reading);
if (rv != SA_OK) {
printf( "saHpiSensorReadingGet error %d\n",rv);
return;
}
printf("sensor(%s)\n",gettext(&rdr->IdString));
printf("current reading:");
reading_print(&reading);
printf("\n");
rv = saHpiSensorThresholdsGet(sessionid, resourceid, rec->Num, &thres);
if (rv != SA_OK) {
printf( "saHpiSensorThresholdsGet error %d\n",rv);
return;
}
printf("current threshold:\n");
thres_print(&thres);
if (have_minor) {
struct timeval tv;
thres.LowMinor.ValuesPresent = SAHPI_SRF_INTERPRETED;
thres.LowMinor.Interpreted.Type =
SAHPI_SENSOR_INTERPRETED_TYPE_FLOAT32;
thres.LowMinor.Interpreted.Value.SensorFloat32 = minor_value;
if (have_major) {
thres.LowMajor.ValuesPresent = SAHPI_SRF_INTERPRETED;
thres.LowMajor.Interpreted.Type =
SAHPI_SENSOR_INTERPRETED_TYPE_FLOAT32;
thres.LowMajor.Interpreted.Value.SensorFloat32 = major_value;
}
gettimeofday(&tv, NULL);
printf("set thres at :%ld\n", tv.tv_sec);
rv = saHpiSensorThresholdsSet(sessionid, resourceid, rec->Num, &thres);
if (rv != SA_OK) {
printf( "saHpiSensorThresholdsSet error %d\n",rv);
return;
}
}
exit(0);
}
}
static
void DoEvent(
SaHpiSessionIdT sessionid,
SaHpiResourceIdT resourceid,
SaHpiSensorRecT *sensorrec )
{
SaHpiSensorNumT sensornum;
SaHpiSensorReadingT reading;
SaHpiSensorReadingT conv_reading;
SaHpiSensorThresholdsT senstbuff1;
SaHpiSensorThresholdsT senstbuff2;
SaHpiTimeoutT timeout = (SaHpiInt64T)(12 * HPI_NSEC_PER_SEC); /* 12 seconds */
SaHpiEventT event;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
char *unit;
int eventflag = 0;
int i;
sensornum = sensorrec->Num;
/* Get current sensor reading */
rv = saHpiSensorReadingGet( sessionid, resourceid, sensornum, &reading);
if (rv != SA_OK) {
printf( "\n");
/* printf("ReadingGet ret=%d\n", rv); */
return;
}
if ((reading.ValuesPresent & SAHPI_SRF_INTERPRETED) == 0 &&
(reading.ValuesPresent & SAHPI_SRF_RAW)) {
/* only try convert if intrepreted not available. */
rv = saHpiSensorReadingConvert(sessionid, resourceid, sensornum,
&reading, &conv_reading);
if (rv != SA_OK) {
printf("raw=%x conv_ret=%d\n", reading.Raw, rv);
/* printf("conv_rv=%s\n", decode_error(rv)); */
return;
} else {
reading.Interpreted.Type = conv_reading.Interpreted.Type;
reading.Interpreted.Value.SensorUint32 =
conv_reading.Interpreted.Value.SensorUint32;
}
}
/* Determine units of interpreted reading */
i = sensorrec->DataFormat.BaseUnits;
if (i > NSU) i = 0;
unit = units[i];
printf(" = %05.2f %s \n",
reading.Interpreted.Value.SensorFloat32, unit);
/* Retrieve current threshold setings, twice */
/* once for backup and once for modification */
/* Get backup copy */
rv = saHpiSensorThresholdsGet(
sessionid, resourceid, sensornum, &senstbuff1);
if (rv != SA_OK) return;
/* Get modification copy */
rv = saHpiSensorThresholdsGet(
sessionid, resourceid, sensornum, &senstbuff2);
if (rv != SA_OK) return;
/* Display current thresholds */
if (rv == SA_OK) {
printf( " Current\n");
ShowThresh( &senstbuff2 );
}
/* Set new threshold to current reading + 10% */
senstbuff2.LowMajor.Interpreted.Value.SensorFloat32 =
reading.Interpreted.Value.SensorFloat32 * (SaHpiFloat32T)1.10;
printf( "ValuesPresent = %x\n", senstbuff2.LowMajor.ValuesPresent);
printf( "Values Mask = %x\n", (SAHPI_SRF_RAW));
senstbuff2.LowMajor.ValuesPresent =
senstbuff2.LowMajor.ValuesPresent ^ (SAHPI_SRF_RAW);
printf( "ValuesPresent = %x\n", senstbuff2.LowMajor.ValuesPresent);
/* Display new current thresholds */
if (rv == SA_OK) {
printf( " New\n");
ShowThresh( &senstbuff2 );
}
/* See what Events are Enabled */
rv = saHpiSensorEventEnablesGet(
sessionid, resourceid, sensornum, &enables1);
if (rv != SA_OK) return;
printf( "Sensor Event Enables: \n");
printf( " Sensor Status = %x\n", enables1.SensorStatus);
printf( " Assert Events = %x\n", enables1.AssertEvents);
printf( " Deassert Events = %x\n", enables1.DeassertEvents);
/*
enables1.AssertEvents = 0x0400;
enables1.DeassertEvents = 0x0400;
rv = saHpiSensorEventEnablesSet(
sessionid, resourceid, sensornum, &enables1);
if (rv != SA_OK) return;
*/
/************************
Temporary exit */
/*
return;
*/
/* Subscribe to New Events, only */
printf( "Subscribe to events\n");
rv = saHpiSubscribe( sessionid, (SaHpiBoolT)0 );
if (rv != SA_OK) return;
/* Set new thresholds */
printf( "Set new thresholds\n");
rv = saHpiSensorThresholdsSet(
sessionid, resourceid, sensornum, &senstbuff2);
if (rv != SA_OK) return;
/* Go wait on event to occur */
printf( "Go and get the event\n");
eventflag = 0;
while ( eventflag == 0) {
rv = saHpiEventGet( sessionid, timeout, &event, &rdr, &rptentry );
if (rv != SA_OK) {
if (rv != SA_ERR_HPI_TIMEOUT) {
printf( "Error during EventGet - Test FAILED\n");
return;
} else {
printf( "Time expired during EventGet - Test FAILED\n");
/* Reset to the original thresholds */
printf( "Reset thresholds\n");
rv = saHpiSensorThresholdsSet(
sessionid, resourceid, sensornum, &senstbuff1);
if (rv != SA_OK) return;
/* Re-read threshold values */
rv = saHpiSensorThresholdsGet(
sessionid, resourceid, sensornum, &senstbuff2);
if (rv != SA_OK) return;
return;
}
}
/* Decode the event information */
printf( "Decode event info\n");
if (event.EventType == SAHPI_ET_SENSOR) {
printf( "Sensor # = %2d Severity = %2x\n",
event.EventDataUnion.SensorEvent.SensorNum, event.Severity );
if (event.EventDataUnion.SensorEvent.SensorNum == sensornum) {
eventflag = 1;
printf( "Got it - Test PASSED\n");
}
}
}
/* Reset to the original thresholds */
printf( "Reset thresholds\n");
rv = saHpiSensorThresholdsSet(
sessionid, resourceid, sensornum, &senstbuff1);
if (rv != SA_OK) return;
/* Re-read threshold values */
rv = saHpiSensorThresholdsGet(
sessionid, resourceid, sensornum, &senstbuff2);
if (rv != SA_OK) return;
/* Display reset thresholds */
if (rv == SA_OK) {
printf( " Reset\n");
ShowThresh( &senstbuff2 );
}
/* Unsubscribe to future events */
printf( "Unsubscribe\n");
rv = saHpiUnsubscribe( sessionid );
return;
} /*end DoEvent*/
static int sa_show_sensor(
SaHpiResourceIdT resourceid,
SaHpiSensorNumT sensornum )
{
SaHpiSensorReadingT reading;
SaHpiSensorReadingT conv_reading;
SaErrorT rv;
rv = saHpiSensorReadingGet(sessionid,resourceid, sensornum, &reading);
if (rv != SA_OK) {
printf("ReadingGet ret=%d\n", rv);
return rv;
}
if ((reading.ValuesPresent & SAHPI_SRF_INTERPRETED) == 0) {
if ((reading.ValuesPresent & SAHPI_SRF_RAW) == 0) {
/* no raw or interpreted, so just show event status */
/* This is a Compact Sensor */
if (reading.ValuesPresent & SAHPI_SRF_EVENT_STATE)
printf(" = %x %x\n", reading.EventStatus.SensorStatus,
reading.EventStatus.EventStatus);
else printf(" = event-only sensor\n");
return SA_OK;
} else {
/* have raw, but not interpreted, so try convert. */
rv = saHpiSensorReadingConvert(sessionid, resourceid, sensornum,
&reading, &conv_reading);
if (rv != SA_OK) {
printf("raw=%x conv_ret=%d\n", reading.Raw, rv);
/* printf("conv_rv=%s\n", decode_error(rv)); */
return rv;
}
else {
reading.Interpreted.Type = conv_reading.Interpreted.Type;
if (reading.Interpreted.Type == SAHPI_SENSOR_INTERPRETED_TYPE_BUFFER)
{
memcpy(reading.Interpreted.Value.SensorBuffer,
conv_reading.Interpreted.Value.SensorBuffer,
4); /* SAHPI_SENSOR_BUFFER_LENGTH); */
/* IPMI 1.5 only returns 4 bytes */
} else
reading.Interpreted.Value.SensorUint32 =
conv_reading.Interpreted.Value.SensorUint32;
}
}
}
switch(reading.Interpreted.Type)
{
case SAHPI_SENSOR_INTERPRETED_TYPE_FLOAT32:
printf("Value: %5.2f \n",
reading.Interpreted.Value.SensorFloat32);
break;
case SAHPI_SENSOR_INTERPRETED_TYPE_UINT32:
printf("Value: %d \n",
reading.Interpreted.Value.SensorUint32);
break;
case SAHPI_SENSOR_INTERPRETED_TYPE_BUFFER:
printf("Value: %02x %02x %02x %02x\n",
reading.Interpreted.Value.SensorBuffer[0],
reading.Interpreted.Value.SensorBuffer[1],
reading.Interpreted.Value.SensorBuffer[2],
reading.Interpreted.Value.SensorBuffer[3]);
break;
default:
printf("Value: %x (itype=%x)\n",
reading.Interpreted.Value.SensorUint32,
reading.Interpreted.Type);
}
#if 0
printf("Sensor Status: ");
if (reading.EventStatus.SensorStatus & SAHPI_SENSTAT_EVENTS_ENABLED) {
printf("Event Enabled.\n");
} else if (reading.EventStatus.SensorStatus & SAHPI_SENSTAT_SCAN_ENABLED) {
printf("Scan Enabled.\n");
} else if (reading.EventStatus.SensorStatus & SAHPI_SENSTAT_BUSY) {
printf("Busy.\n");
} else {
printf("Unknown.\n");
}
#endif
sa_sen_evt_get(resourceid, sensornum);
sa_get_thres(resourceid, sensornum);
return SA_OK;
}
