Index: plugins/ilo2_ribcl/ilo2_ribcl_xml.c =================================================================== --- plugins/ilo2_ribcl/ilo2_ribcl_xml.c (revision 7331) +++ plugins/ilo2_ribcl/ilo2_ribcl_xml.c (working copy) @@ -60,7 +60,9 @@ static int ir_xml_scan_fans( ilo2_ribcl_handler_t *, xmlNodePtr); static int ir_xml_record_fandata( ilo2_ribcl_handler_t *, char *, char *, char *, char *, char *); -static void ir_xml_scan_temperature( ilo2_ribcl_handler_t *, xmlNodePtr); +static int ir_xml_scan_temperature( ilo2_ribcl_handler_t *, xmlNodePtr); +static int ir_xml_record_temperaturedata( ilo2_ribcl_handler_t *, + char *, char *,char *, char *, char *); static void ir_xml_scan_firmware_revision(ilo2_ribcl_handler_t *, xmlNodePtr); static int ir_xml_scan_vrm( ilo2_ribcl_handler_t *, xmlNodePtr); static int ir_xml_record_vrmdata( ilo2_ribcl_handler_t *, char *, char *); @@ -214,9 +216,12 @@ } /* Extract data for temp sensors */ - ir_xml_scan_temperature( ir_handler, eh_data_node); + if( ir_xml_scan_temperature( ir_handler, eh_data_node) + != RIBCL_SUCCESS){ + xmlFreeDoc( doc); + return( -1); + } - xmlFreeDoc( doc); return( RIBCL_SUCCESS); @@ -366,7 +371,11 @@ } /* Extract data for temp sensors */ - ir_xml_scan_temperature( ir_handler, h_node); + if( ir_xml_scan_temperature( ir_handler, h_node) + != RIBCL_SUCCESS){ + xmlFreeDoc( doc); + return( -1); + } /* Extract firmware revision information */ /* Now we parse the output from the GET_FW_VERSION RIBCL command */ @@ -1483,9 +1492,9 @@ * * * - * Return value: None + * Return value: RIBCL_SUCCESS if success, -1 if failure. **/ -static void ir_xml_scan_temperature( ilo2_ribcl_handler_t *ir_handler, +static int ir_xml_scan_temperature( ilo2_ribcl_handler_t *ir_handler, xmlNodePtr eh_data_node) { xmlNodePtr t_node; @@ -1495,6 +1504,7 @@ xmlChar *stat = NULL; xmlChar *cur_reading = NULL; xmlChar *unit = NULL; + int ret; t_node = ir_xml_find_node( eh_data_node, "TEMPERATURE"); @@ -1525,8 +1535,10 @@ /* Extract Caution value here, if needed */ - /* Call to process temperature data goes here, when - * we add support to this plugin for sensors. */ + /* Call to process temperature data */ + ret = ir_xml_record_temperaturedata( ir_handler, + ( char *)lbl,( char *)loc, ( char *)stat, + ( char *)cur_reading,( char *)unit); if( lbl){ xmlFree( lbl); @@ -1544,15 +1556,141 @@ xmlFree( unit); } + if( ret != RIBCL_SUCCESS){ + return( -1); + } + } /* end if name == "TEMP" */ t_node = t_node->next; } /* end while t_node != NULL */ + return( RIBCL_SUCCESS); + } /* end ir_xml_scan_temperature() */ + /** + * ir_xml_record_temperaturedata + * @ir_handler: ptr to the ilo2_ribcl plugin private handler. + * @temperaturelabel: string label for the temperature sensor from iLO2. + * @temperaturelocation:string location for the temperature sensor from iLO2. + * @temperaturestat: string status for the temperature sensor from iLO2. + * @temperaturereading: string reading for the temperature sensor from iLO2. + * @temperatureunits: string units for the temperature. + * + * This routine records the data for a temperature sensor reported by iLO2 + * into the DiscoveryData structure within the plugin's private handler. + * + * Detailed description: + * + * - Extract an index for this temperature sensor from the temperature + * sensor label provided by iLO2. + * - Use this index to access the DiscoveryData.tsdata[] array. + * - Set the IR_DISCOVERED bit in tsflags. + * - Store updated values for the temperature sensor reading, label, + * location, status, and temperatureunit for this temperature sensor. + * + * Return value: RIBCL_SUCCESS if success, -1 if failure. + **/ +static int ir_xml_record_temperaturedata( ilo2_ribcl_handler_t *ir_handler, + char *temperaturelabel, char *temperaturelocation, + char *temperaturestat,char *temperaturereading, + char *temperatureunits) +{ + + int temperatureindex = 0; + ir_tsdata_t *tsdat = NULL; + + if ( ir_handler == NULL) { + err("ir_xml_record_temperaturedata: ir_handler value is NULL"); + return( -1); + } + + /* Find the index of this temperature sensor. The parameter + * 'temperaturelabel' should be of the form 'Temp N', + * where N ranges from 1 to ILO2_RIBCL_DISCOVER_TS_MAX. + */ + + temperatureindex = ir_xml_extract_index("Temp", + (char *)temperaturelabel, 1); + + if( temperatureindex == IR_NO_PREFIX){ + /* We didn't parse the temperaturelabel string prefix + * correctly + */ + err("ir_xml_record_temperaturedata: incorrect temperature " + "label string: %s", temperaturelabel); + return( -1); + } + + if( temperatureindex == IR_NO_INDEX){ + /* We didn't parse the temperaturelabel string index + * correctly + */ + err("ir_xml_record_temperaturedata: could not extract index " + "from temperature label string: %s", temperaturelabel); + return( -1); + } + + /* The index of this temperature sensor should be between 1 and + ILO2_RIBCL_DISCOVER_TS_MAX.*/ + + if( (temperatureindex < 1) || + (temperatureindex > ILO2_RIBCL_DISCOVER_TS_MAX) ){ + err("ir_xml_record_temperaturedata: temperatureindex out of " + "range: %d.", temperatureindex); + return( -1); + } + + /* Now, if this information is different than what's already in + * DiscoveryData, update DiscoveryData with the latest info */ + + tsdat = &(ir_handler->DiscoveryData.tsdata[3 + temperatureindex]); + tsdat->tsflags |= IR_DISCOVERED; + + if( ir_xml_replacestr( &(tsdat->label), temperaturelabel) + != RIBCL_SUCCESS){ + err("ir_xml_record_temperaturedata: could not update " + "temperature label: %s", temperaturelabel); + return( -1); + } + + if( ir_xml_replacestr( &(tsdat->location), temperaturelocation) + != RIBCL_SUCCESS){ + err("ir_xml_record_temperaturedata: could not update " + "temperature location: %s", temperaturelocation); + return( -1); + } + + if( ir_xml_replacestr( &(tsdat->status), temperaturestat) + != RIBCL_SUCCESS){ + err("ir_xml_record_temperaturedata: could not update " + "temperature status: %s", temperaturestat); + return( -1); + } + + if( ir_xml_replacestr( &(tsdat->reading), temperaturereading) + != RIBCL_SUCCESS){ + err("ir_xml_record_temperaturedata: could not update " + "temperature reading: %s", temperaturereading); + return( -1); + } + + if( ir_xml_replacestr( &(tsdat->readingunits), temperatureunits) + != RIBCL_SUCCESS){ + err("ir_xml_record_temperaturedata: could not update " + "temperature units: %s", temperatureunits); + return( -1); + } + + return( RIBCL_SUCCESS); + +} /* end ir_xml_record_temparaturedata()*/ + + +/** * ir_xml_firmaware_revision * @ir_handler: Ptr to this instance's custom handler. * @eh_data_node: Points to GET_FW_VERSION subtree in the output xml Index: plugins/ilo2_ribcl/ilo2_ribcl_sensor.c =================================================================== --- plugins/ilo2_ribcl/ilo2_ribcl_sensor.c (revision 7331) +++ plugins/ilo2_ribcl/ilo2_ribcl_sensor.c (working copy) @@ -57,7 +57,11 @@ static void ilo2_ribcl_process_severitysensor( struct oh_handler_state *, struct ilo2_ribcl_sens_allinfo *, I2R_SensorDataT *); +static void ilo2_ribcl_process_temperaturesensor( struct oh_handler_state *, + struct ilo2_ribcl_sens_allinfo *, + ir_tsdata_t *); + /** * ilo2_ribcl_get_sensor_reading: * @hdn: Pointer to the handler for this instance. @@ -643,6 +647,7 @@ sens_allinfo->rpt = NULL; sens_allinfo->rdr = NULL; sens_allinfo->sens_dat = NULL; + sens_allinfo->ts_data = NULL; /* Check if the resource exists, and that it has sensor capability */ @@ -678,6 +683,17 @@ return( SA_ERR_HPI_INTERNAL_ERROR); } + /* Finally, get the associated private data for temperature sensor */ + sens_allinfo->ts_data = (struct ir_tsdata *)oh_get_rdr_data( + oh_handler->rptcache, rid, sens_allinfo->rdr->RecordId); + + if( sens_allinfo->ts_data == NULL){ + err("ilo2_ribcl_get_sensor_allinfo: no private temp data for " + "resource id %d, sensor %d, label: %s.",rid, s_num, + sens_allinfo->rdr->IdString.Data); + return( SA_ERR_HPI_INTERNAL_ERROR); + } + return( SA_OK); } /* end ilo2_ribcl_get_sensor_allinfo( ) */ @@ -823,10 +839,11 @@ void ilo2_ribcl_process_sensors( struct oh_handler_state *oh_handler) { SaErrorT ret; - SaHpiSensorNumT sens_num; + SaHpiSensorNumT sens_num, temp_sensnum; ilo2_ribcl_handler_t *ir_handler = NULL; I2R_SensorDataT *ir_sens_dat; struct ilo2_ribcl_sens_allinfo sens_allinfo; + ir_tsdata_t *tsdata = NULL; ir_handler = (ilo2_ribcl_handler_t *) oh_handler->data; @@ -856,6 +873,34 @@ ir_sens_dat); } + /* Handle the temperature sensors */ + for( temp_sensnum = 4; temp_sensnum < ILO2_RIBCL_DISCOVER_TS_MAX + 1; + temp_sensnum++){ + + tsdata = + &(ir_handler->DiscoveryData.tsdata[temp_sensnum]); + + /* If temperature sensor was not found during discovery, + * skip it */ + if( tsdata->tsflags != IR_DISCOVERED){ + continue; + } + + /* Get the rpt of the sensor resource, the RDR of the sensor, + * and the sensor data associated with the RDR. */ + ret = ilo2_ribcl_get_sensor_allinfo( oh_handler, + tsdata->rid, temp_sensnum, &sens_allinfo); + + if( ret != SA_OK){ + err("ilo2_ribcl_process_sensors: could not locate HPI " + "data for temp sensor number %d.", temp_sensnum); + continue; + } + + ilo2_ribcl_process_temperaturesensor( oh_handler, &sens_allinfo, + tsdata); + } + /* Processing of any future sensors will be inserted here */ } /* end ilo2_ribcl_process_sensors() */ @@ -1042,7 +1087,52 @@ } /* end ilo2_ribcl_process_severitysensor() */ +/** + * ilo2_ribcl_process_temperaturesensor: + * @oh_handler: Pointer to the handler for this instance. + * @sens_allinfo: Pointer to structure giving all HPI info for this sensor. + * @ir_tsdata: Pointer to iLo2 RIBCL data for temperature sensor. + * + * This routine is given the sensor data obtained from iLo2 via parameter + * ir_tsdata and converts that data into an HPI sensor value. + * + * + * A high level description of the algorithm used is: + * + * if( (sensor is disabled) || + (sensor reading has not changed){ + * return; + * } + * + * Update the stored sensor value with the current sensor reading. + * + * Return values: + * None +**/ +static void ilo2_ribcl_process_temperaturesensor( + struct oh_handler_state *oh_handler, + struct ilo2_ribcl_sens_allinfo *sens_allinfo, + ir_tsdata_t *ir_tsdata) +{ + struct ilo2_ribcl_sensinfo *sensinfo; + sensinfo = (struct ilo2_ribcl_sensinfo *)sens_allinfo->ts_data; + + /* Either the sensor is disable or the sensor reading has not + * changed; just return. + */ + if( (sensinfo->sens_enabled != SAHPI_TRUE) || + (atoi(ir_tsdata->reading) == sensinfo->sens_value)){ + return; + } + + /* Update our stored HPI sensor value with the current iLo2 RIBCL + * sensor reading.*/ + sensinfo->sens_value = atoi(ir_tsdata->reading); + +} /* end ilo2_ribcl_process_temperaturesensor () */ + + /** * ilo2_ribcl_init_sensor_data: * @ir_handler: Pointer to the private handler for this instance. Index: plugins/ilo2_ribcl/ilo2_ribcl_discover.c =================================================================== --- plugins/ilo2_ribcl/ilo2_ribcl_discover.c (revision 7331) +++ plugins/ilo2_ribcl/ilo2_ribcl_discover.c (working copy) @@ -62,6 +62,8 @@ static SaErrorT ilo2_ribcl_discovered_fru( struct oh_handler_state *, SaHpiEntityPathT *, enum ir_discoverstate *, int, char *, struct ilo2_ribcl_idr_info *); +static void ilo2_ribcl_discover_temp_sensors( struct oh_handler_state *, + struct oh_event *); static SaErrorT ilo2_ribcl_resource_set_failstatus( struct oh_handler_state *, SaHpiEntityPathT *, SaHpiBoolT); static SaErrorT ilo2_ribcl_undiscovered_fru( struct oh_handler_state *, @@ -72,6 +74,9 @@ static SaErrorT ilo2_ribcl_add_severity_sensor( struct oh_handler_state *, struct oh_event *, int, SaHpiSensorTypeT, SaHpiEventStateT, struct ilo2_ribcl_sensinfo *, char *); +static SaErrorT ilo2_ribcl_add_threshold_sensor( struct oh_handler_state *, + struct oh_event *, int, SaHpiSensorTypeT, SaHpiEventStateT, + struct ilo2_ribcl_sensinfo *, char *); static void ilo2_ribcl_discover_chassis_sensors( struct oh_handler_state *, struct oh_event *); void ilo2_ribcl_add_resource_capability( struct oh_handler_state *, @@ -424,6 +429,11 @@ ddata->vrmdata[idex].vrmflags &= ~IR_DISCOVERED; } + /* Clear the Temperature Sensor flags */ + for( idex = 4; idex <= ILO2_RIBCL_DISCOVER_TS_MAX; idex++){ + ddata->tsdata[idex].tsflags &= ~IR_DISCOVERED; + } + } /* end ilo2_ribcl_clear_discoveryflags() */ @@ -613,6 +623,9 @@ /* Add sensor RDRs. We use three general system health sensors. */ ilo2_ribcl_discover_chassis_sensors( oh_handler, ev); + /* Add Temperature Sensor RDR */ + ilo2_ribcl_discover_temp_sensors( oh_handler, ev); + /* Add an inventory RDR */ ilo2_ribcl_discover_chassis_idr( oh_handler, ev, tmptag); free( tmptag); @@ -1447,7 +1460,89 @@ } /* end ilo2_ribcl_discovered_fru() */ +/** + * ilo2_ribcl_discover_temp_sensors: + * @oh_handler: Handler data pointer. + * @event: Pointer to event structure for chassis resource event. + * + * This routine will create RDRs for the all temperature sensors that + * have been detected during a discovery operation. + * These sensors correspond to the system's temperature's sensors. + * Return values: + * None + **/ +static void ilo2_ribcl_discover_temp_sensors( + struct oh_handler_state *oh_handler, + struct oh_event *event) +{ + SaErrorT ret = SA_OK; + ilo2_ribcl_handler_t *ir_handler = NULL; + struct ilo2_ribcl_sensinfo si_initial; + ir_tsdata_t *tsdata = NULL; + int idex, cur_reading = I2R_SEN_VAL_UNINITIALIZED; + char *label = NULL, *location = NULL, *description = NULL; + ir_handler = ( ilo2_ribcl_handler_t *) oh_handler->data; + + /* Look for the all temperature isensors from the RIBCL */ + for( idex = 4; idex <= ILO2_RIBCL_DISCOVER_TS_MAX; idex++){ + tsdata = &(ir_handler->DiscoveryData.tsdata[idex]); + if(tsdata->tsflags != IR_DISCOVERED){ + break; + } + + cur_reading = atoi( tsdata->reading ); + + if ( cur_reading != I2R_SEN_VAL_UNINITIALIZED){ + si_initial.sens_num = idex; + si_initial.sens_ev_state = SAHPI_ES_OK; + si_initial.sens_enabled = SAHPI_TRUE; + si_initial.sens_ev_enabled = SAHPI_TRUE; + si_initial.sens_assertmask = I2R_SEVERITY_TWOSTATE_EV; + si_initial.sens_deassertmask = I2R_SEVERITY_TWOSTATE_EV; + si_initial.sens_value = I2R_SEN_VAL_UNINITIALIZED; + + label = tsdata->label; + location = tsdata->location; + description = (char*)malloc(snprintf(NULL, 0, "%s %s", + label, location) + 3); + + if ( description != NULL) { + strcpy(description, label); + strcat(description, ": "); + strcat(description, location); + + ret = ilo2_ribcl_add_threshold_sensor( + oh_handler, event,idex,SAHPI_TEMPERATURE, + I2R_SEVERITY_THREESTATE_EV, &si_initial, + description); + + if ( ret == SA_OK){ + tsdata->rid = + event->resource.ResourceId; + ilo2_ribcl_add_resource_capability( + oh_handler, event, + (SAHPI_CAPABILITY_RDR | + SAHPI_CAPABILITY_SENSOR)); + + } else { + err("ilo2_ribcl_discover_temp_sensors: " + "Failed to set up temp sensor."); + } + + free(description); + + } else { + err("ilo2_ribcl_discover_temp_sensors: " + "Memory Allocation failed."); + } + } + + } /* end for idex */ + +}/* end ilo2_ribcl_discover_temperator_sensors() */ + + /** * ilo2_ribcl_resource_set_failstatus * @oh_handler: Handler data pointer. @@ -1991,7 +2086,112 @@ } /* end ilo2_ribcl_add_severity_sensor() */ +/** + * ilo2_ribcl_add_threshold_sensor: + * @oh_handler: Handler data pointer. + * @event: Pointer to event structure for sensor parent resource event. + * @sens_num: Sensor number for new sensor. + * @sens_type: HPI type of new sensor. + * @supported_states: Mask of all the EV states this sensor can support. + * @sens_info: Private sensor info associated with RDR. + * @description: Character string description of temperature sensor. + * + * This routine creates a new sensor of category SAHPI_EC_THRESHOLD, using + * the data given by the parameters. The new sensor RDR is added to + * the parent resource given in the oh_event structure paramenter. + * + * The following fields in the SensorRec of the RDR will be set to fixed + * values: + * EnableCtrl = SAHPI_TRUE + * EventCtrl = SAHPI_SEC_READ_ONLY + * DataFormat.IsSupported = SAHPI_TRUE + * DataFormat.ReadingType = SAHPI_SENSOR_READING_TYPE_UINT64 + * DataFormat.BaseUnits = SAHPI_SU_DEGREES_C + * DataFormat.ModifierUse = SAHPI_SMUU_NONE + * DataFormat.Percentage = SAHPI_FALSE + * ThresholdDefn.IsAccessible = SAHPI_FALSE + * + * Return values: + * SA_ERR_HPI_OUT_OF_MEMORY - memory allocation failed. + * SA_ERR_HPI_INTERNAL_ERROR - could not add sensor RDR + **/ +static SaErrorT ilo2_ribcl_add_threshold_sensor( + struct oh_handler_state *oh_handler, + struct oh_event *event, + int sens_num, + SaHpiSensorTypeT sens_type, + SaHpiEventStateT supported_states, + struct ilo2_ribcl_sensinfo *sens_info, + char *description) +{ + SaErrorT ret = SA_OK; + SaHpiRdrT *rdr; + SaHpiSensorRecT *sensor_rec; + struct ilo2_ribcl_sensinfo *si; + + rdr = (SaHpiRdrT *)g_malloc0(sizeof(SaHpiRdrT)); + if( rdr == NULL){ + err("ilo2_ribcl_add_threshold_sensor: " + "Memory allocation failed."); + return(SA_ERR_HPI_OUT_OF_MEMORY); + } + + /* Fill in generic RDR stuff */ + rdr->RdrType = SAHPI_SENSOR_RDR; + rdr->Entity = event->resource.ResourceEntity; + rdr->IsFru = SAHPI_FALSE; + + /* Fill in sensor specific info */ + sensor_rec = &(rdr->RdrTypeUnion.SensorRec); + sensor_rec->Num = sens_num; + sensor_rec->Type = sens_type; + sensor_rec->Category = SAHPI_EC_THRESHOLD; + sensor_rec->EnableCtrl = SAHPI_TRUE; + sensor_rec->EventCtrl = SAHPI_SEC_READ_ONLY; + sensor_rec->Events = supported_states; + + sensor_rec->DataFormat.IsSupported = SAHPI_TRUE; + sensor_rec->DataFormat.ReadingType = SAHPI_SENSOR_READING_TYPE_INT64; + sensor_rec->DataFormat.BaseUnits = SAHPI_SU_DEGREES_C; + sensor_rec->DataFormat.ModifierUse = SAHPI_SMUU_NONE; + sensor_rec->DataFormat.Percentage = SAHPI_FALSE; + /* Range and AccuracyFactor have been cleared by g_malloc0() */ + + sensor_rec->ThresholdDefn.IsAccessible = SAHPI_FALSE; + + oh_init_textbuffer(&(rdr->IdString)); + oh_append_textbuffer(&(rdr->IdString), description); + + + /* Copy the private sensor data initial values into a new allocation + * to be associated with this RDR. */ + si = g_memdup(sens_info, sizeof(struct ilo2_ribcl_sensinfo)); + if( si == NULL){ + g_free( rdr); + err("ilo2_ribcl_add_threshold_sensor: Memory allocation " + "failed."); + return(SA_ERR_HPI_OUT_OF_MEMORY); + } + + ret = oh_add_rdr(oh_handler->rptcache, event->resource.ResourceId, + rdr, si, 0); + + if( ret != SA_OK){ + err("ilo2_ribcl_add_threshold_sensor: could not add RDR. " + "Error = %s.", oh_lookup_error(ret)); + g_free( si); + g_free( rdr); + return( SA_ERR_HPI_INTERNAL_ERROR); + } else { + event->rdrs = g_slist_append(event->rdrs, rdr); + } + + return( SA_OK); + +} /* end ilo2_ribcl_add_threshold_sensor() */ + + /** * ilo2_ribcl_discover_chassis_sensors: * @oh_handler: Handler data pointer. Index: plugins/ilo2_ribcl/ilo2_ribcl.h =================================================================== --- plugins/ilo2_ribcl/ilo2_ribcl.h (revision 7331) +++ plugins/ilo2_ribcl/ilo2_ribcl.h (working copy) @@ -255,6 +255,7 @@ SaHpiRptEntryT *rpt; SaHpiRdrT *rdr; struct ilo2_ribcl_sensinfo *sens_dat; + struct ir_tsdata *ts_data; }; /* These are the state for software state machines that process the iLo2 @@ -345,6 +346,7 @@ char *status; char *reading; char *readingunits; + SaHpiResourceIdT rid; } ir_tsdata_t; /* Firmware Revision Information */ @@ -359,7 +361,7 @@ #define ILO2_RIBCL_DISCOVER_FAN_MAX 16 #define ILO2_RIBCL_DISCOVER_PSU_MAX 8 #define ILO2_RIBCL_DISCOVER_VRM_MAX 8 -#define ILO2_RIBCL_DISCOVER_TS_MAX 48 +#define ILO2_RIBCL_DISCOVER_TS_MAX 51 #define ILO2_RIBCL_CHASSIS_INDEX -1; /* Index is not aplicable to chassis */