715 lines
20 KiB
C++
715 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2013, 2015 Wind River Systems, Inc.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* Wind River CGTS Platform - Hardware Monitoring "General Utilities" Implementation
|
|
*/
|
|
|
|
#ifdef __AREA__
|
|
#undef __AREA__
|
|
#endif
|
|
#define __AREA__ "hwm"
|
|
|
|
#include "alarmUtil.h" /* for ... alarmUtil_getSev_str */
|
|
#include "hwmonUtil.h" /* this module header */
|
|
|
|
string get_key_value_string ( string reading, string key, char delimiter, bool set_tolowercase )
|
|
{
|
|
string value = "" ;
|
|
if ( ! reading.empty() )
|
|
{
|
|
/* verify this is the correct sensor to be reading */
|
|
std::size_t start = reading.find(key, 0) ;
|
|
if ( start != std::string::npos )
|
|
{
|
|
start = reading.find( delimiter, start ) ;
|
|
if ( start != std::string::npos )
|
|
{
|
|
std::size_t end = reading.find( '\n', ++start ) ;
|
|
|
|
value = reading.substr(start, end-start).c_str();
|
|
|
|
if ( set_tolowercase == true )
|
|
value = tolowercase ( value );
|
|
|
|
blog3 ("key:%s - value:%s\n", key.c_str(), value.c_str());
|
|
}
|
|
else
|
|
{
|
|
elog ("value parse error\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
elog ("key parse error\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
elog ("empty key\n");
|
|
}
|
|
return (value);
|
|
}
|
|
|
|
string get_severity ( sensor_severity_enum severity )
|
|
{
|
|
if ( severity == HWMON_SEVERITY_GOOD )
|
|
return "ok" ;
|
|
else if ( severity == HWMON_SEVERITY_OFFLINE )
|
|
return "offline" ;
|
|
else if ( severity == HWMON_SEVERITY_MINOR )
|
|
return "minor" ;
|
|
else if ( severity == HWMON_SEVERITY_MAJOR )
|
|
return "major" ;
|
|
else if ( severity == HWMON_SEVERITY_CRITICAL )
|
|
return "critical" ;
|
|
else if ( severity == HWMON_SEVERITY_NONRECOVERABLE )
|
|
return "critical" ;
|
|
else
|
|
return "unknown" ;
|
|
}
|
|
|
|
sensor_severity_enum get_severity ( string status )
|
|
{
|
|
if ( status.compare("ok") == 0 )
|
|
return HWMON_SEVERITY_GOOD ;
|
|
if ( status.compare("offline") == 0 )
|
|
return HWMON_SEVERITY_OFFLINE ;
|
|
if ( status.compare("minor") == 0 )
|
|
return HWMON_SEVERITY_MINOR ;
|
|
if ( status.compare("major") == 0 )
|
|
return HWMON_SEVERITY_MAJOR ;
|
|
if ( status.compare("critical") == 0 )
|
|
return HWMON_SEVERITY_CRITICAL ;
|
|
if ( status.compare("nonrecov") == 0 )
|
|
return HWMON_SEVERITY_NONRECOVERABLE ;
|
|
|
|
return HWMON_SEVERITY_OFFLINE ;
|
|
}
|
|
|
|
string get_bmc_severity ( sensor_severity_enum status )
|
|
{
|
|
switch ( status )
|
|
{
|
|
case HWMON_SEVERITY_GOOD: return "ok" ;
|
|
case HWMON_SEVERITY_MAJOR: return "nc" ;
|
|
case HWMON_SEVERITY_CRITICAL: return "cr" ;
|
|
case HWMON_SEVERITY_OFFLINE: return "na" ;
|
|
default: return "ns" ;
|
|
}
|
|
}
|
|
|
|
sensor_severity_enum get_bmc_severity ( string status )
|
|
{
|
|
if ( status.compare("ok") == 0 )
|
|
return HWMON_SEVERITY_GOOD ;
|
|
if ( status.compare("nc") == 0 )
|
|
return HWMON_SEVERITY_MAJOR ;
|
|
if ( status.compare("cr") == 0 )
|
|
return HWMON_SEVERITY_CRITICAL ;
|
|
if ( status.compare("na") == 0 )
|
|
return HWMON_SEVERITY_OFFLINE ;
|
|
if ( status.compare("ns") == 0 )
|
|
return HWMON_SEVERITY_OFFLINE ;
|
|
|
|
/* Separate clauses because they are likelt infrequent if at all */
|
|
if (( status.compare("nr") == 0 ) ||
|
|
( status.compare("lnr") == 0 ) ||
|
|
( status.compare("unr") == 0 ))
|
|
{
|
|
return HWMON_SEVERITY_NONRECOVERABLE ;
|
|
}
|
|
|
|
if (( status.compare("lnc") == 0 ) ||
|
|
( status.compare("unc") == 0 ))
|
|
{
|
|
return HWMON_SEVERITY_MAJOR ;
|
|
}
|
|
|
|
if (( status.compare("lcr") == 0 ) ||
|
|
( status.compare("ucr") == 0 ))
|
|
{
|
|
return HWMON_SEVERITY_CRITICAL ;
|
|
}
|
|
|
|
/* Unrecognized status is handled as a minor alarm */
|
|
return HWMON_SEVERITY_MINOR ;
|
|
}
|
|
|
|
bool is_valid_action ( sensor_severity_enum severity, string & action, bool set_to_lower )
|
|
{
|
|
bool rc = false ;
|
|
string lower_case_action = tolowercase ( action );
|
|
|
|
if ( set_to_lower == true )
|
|
{
|
|
action = lower_case_action ;
|
|
}
|
|
|
|
if ( severity == HWMON_SEVERITY_CRITICAL )
|
|
{
|
|
if ( !lower_case_action.compare(HWMON_ACTION_IGNORE) ||
|
|
!lower_case_action.compare(HWMON_ACTION_ALARM) ||
|
|
!lower_case_action.compare(HWMON_ACTION_LOG) ||
|
|
!lower_case_action.compare(HWMON_ACTION_RESET) ||
|
|
!lower_case_action.compare(HWMON_ACTION_POWERCYCLE))
|
|
{
|
|
rc = true ;
|
|
}
|
|
}
|
|
else if ( !lower_case_action.compare(HWMON_ACTION_IGNORE) ||
|
|
!lower_case_action.compare(HWMON_ACTION_ALARM) ||
|
|
!lower_case_action.compare(HWMON_ACTION_LOG))
|
|
{
|
|
rc = true ;
|
|
}
|
|
return (rc);
|
|
}
|
|
|
|
bool is_log_action ( string action )
|
|
{
|
|
if ( !action.compare(HWMON_ACTION_LOG) )
|
|
return true ;
|
|
return false ;
|
|
}
|
|
|
|
|
|
bool is_ignore_action ( string action )
|
|
{
|
|
if ( !action.compare(HWMON_ACTION_IGNORE) )
|
|
return true ;
|
|
return false ;
|
|
}
|
|
|
|
bool is_alarm_action ( string action )
|
|
{
|
|
if ( !action.compare(HWMON_ACTION_ALARM) )
|
|
return true ;
|
|
return false ;
|
|
}
|
|
|
|
bool is_reset_action ( string action )
|
|
{
|
|
if ( !action.compare(HWMON_ACTION_RESET) )
|
|
return true ;
|
|
return false ;
|
|
}
|
|
|
|
bool is_powercycle_action ( string action )
|
|
{
|
|
if ( !action.compare(HWMON_ACTION_POWERCYCLE) )
|
|
return true ;
|
|
return false ;
|
|
}
|
|
|
|
|
|
void clear_degraded_state ( sensor_type * sensor_ptr )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
sensor_ptr->degraded = false ;
|
|
}
|
|
}
|
|
|
|
void set_degraded_state ( sensor_type * sensor_ptr )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
// ilog ("%s %s DEGRADE ASSERT ^^^^^^^^^^\n", sensor_ptr->hostname.c_str(), sensor_ptr->sensorname.c_str());
|
|
sensor_ptr->degraded = true ;
|
|
}
|
|
}
|
|
|
|
bool clear_severity_alarm ( string & hostname, hwmonAlarm_id_type id, string & sub_entity, EFmAlarmSeverityT severity, string reason )
|
|
{
|
|
if ( hwmon_alarm_query ( hostname, id, sub_entity ) == severity )
|
|
{
|
|
hwmonAlarm_clear ( hostname, id, sub_entity, reason );
|
|
return (true);
|
|
}
|
|
return (false);
|
|
}
|
|
|
|
void clear_asserted_alarm ( string & hostname, hwmonAlarm_id_type id, sensor_type * ptr , string reason )
|
|
{
|
|
if ( ptr )
|
|
{
|
|
if ( ptr->alarmed == true )
|
|
{
|
|
hwmonAlarm_clear ( hostname, id, ptr->sensorname, reason );
|
|
}
|
|
clear_logged_state (ptr);
|
|
clear_ignored_state (ptr);
|
|
clear_alarmed_state (ptr);
|
|
ptr->degraded = false ;
|
|
ptr->alarmed = false ;
|
|
}
|
|
else
|
|
{
|
|
wlog ("%s null sensor pointer\n", hostname.c_str() );
|
|
}
|
|
}
|
|
|
|
|
|
void clear_alarmed_state ( sensor_type * sensor_ptr )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
sensor_ptr->minor.alarmed = false ;
|
|
sensor_ptr->major.alarmed = false ;
|
|
sensor_ptr->critl.alarmed = false ;
|
|
sensor_ptr->alarmed = false ;
|
|
}
|
|
}
|
|
|
|
void set_alarmed_severity ( sensor_type * sensor_ptr , EFmAlarmSeverityT severity )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
if ( severity == FM_ALARM_SEVERITY_MINOR )
|
|
{
|
|
sensor_ptr->alarmed = true ;
|
|
sensor_ptr->minor.alarmed = true ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_MAJOR )
|
|
{
|
|
sensor_ptr->alarmed = true ;
|
|
sensor_ptr->major.alarmed = true ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_CRITICAL )
|
|
{
|
|
sensor_ptr->alarmed = true ;
|
|
sensor_ptr->critl.alarmed = true ;
|
|
}
|
|
else
|
|
{
|
|
slog ("%s alarm status does not apply for severity '%s'\n",
|
|
sensor_ptr->hostname.c_str(),
|
|
alarmUtil_getSev_str(severity).c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
slog ("null sensor pointer\n");
|
|
}
|
|
}
|
|
|
|
/********************* Log Utilities *****************************/
|
|
|
|
void clear_logged_state ( sensor_type * sensor_ptr )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
sensor_ptr->minor.logged = false ;
|
|
sensor_ptr->major.logged = false ;
|
|
sensor_ptr->critl.logged = false ;
|
|
}
|
|
}
|
|
|
|
|
|
void set_logged_severity ( sensor_type * sensor_ptr , EFmAlarmSeverityT severity )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
if ( severity == FM_ALARM_SEVERITY_MINOR )
|
|
{
|
|
sensor_ptr->minor.logged = true ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_MAJOR )
|
|
{
|
|
sensor_ptr->major.logged = true ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_CRITICAL )
|
|
{
|
|
sensor_ptr->critl.logged = true ;
|
|
}
|
|
else
|
|
{
|
|
slog ("%s %s logged status does not apply for severity '%s'\n",
|
|
sensor_ptr->hostname.c_str(),
|
|
sensor_ptr->sensorname.c_str(),
|
|
alarmUtil_getSev_str(severity).c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
slog ("null sensor pointer\n");
|
|
}
|
|
}
|
|
|
|
void clear_logged_severity ( sensor_type * sensor_ptr , EFmAlarmSeverityT severity )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
if ( severity == FM_ALARM_SEVERITY_MINOR )
|
|
{
|
|
sensor_ptr->minor.logged = false ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_MAJOR )
|
|
{
|
|
sensor_ptr->major.logged = false ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_CRITICAL )
|
|
{
|
|
sensor_ptr->critl.logged = false ;
|
|
}
|
|
else
|
|
{
|
|
slog ("%s logged status does not apply for severity '%s'\n",
|
|
sensor_ptr->hostname.c_str(),
|
|
alarmUtil_getSev_str(severity).c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
slog ("null sensor pointer\n");
|
|
}
|
|
}
|
|
|
|
/********************* Ignore Utilities *************************/
|
|
void clear_ignored_state ( sensor_type * sensor_ptr )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
sensor_ptr->minor.ignored = false ;
|
|
sensor_ptr->major.ignored = false ;
|
|
sensor_ptr->critl.ignored = false ;
|
|
}
|
|
}
|
|
|
|
void set_ignored_severity ( sensor_type * sensor_ptr , EFmAlarmSeverityT severity )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
clear_ignored_state ( sensor_ptr );
|
|
if ( severity == FM_ALARM_SEVERITY_MINOR )
|
|
{
|
|
sensor_ptr->minor.ignored = true ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_MAJOR )
|
|
{
|
|
sensor_ptr->major.ignored = true ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_CRITICAL )
|
|
{
|
|
sensor_ptr->critl.ignored = true ;
|
|
}
|
|
else
|
|
{
|
|
slog ("%s logged status does not apply for severity '%s'\n",
|
|
sensor_ptr->hostname.c_str(),
|
|
alarmUtil_getSev_str(severity).c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
slog ("null sensor pointer\n");
|
|
}
|
|
}
|
|
|
|
void clear_ignored_severity ( sensor_type * sensor_ptr , EFmAlarmSeverityT severity )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
if ( severity == FM_ALARM_SEVERITY_MINOR )
|
|
{
|
|
sensor_ptr->minor.ignored = false ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_MAJOR )
|
|
{
|
|
sensor_ptr->major.ignored = false ;
|
|
}
|
|
else if ( severity == FM_ALARM_SEVERITY_CRITICAL )
|
|
{
|
|
sensor_ptr->critl.ignored = false ;
|
|
}
|
|
else
|
|
{
|
|
slog ("%s ignored status does not apply for severity '%s'\n",
|
|
sensor_ptr->hostname.c_str(),
|
|
alarmUtil_getSev_str(severity).c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
slog ("null sensor pointer\n");
|
|
}
|
|
}
|
|
|
|
|
|
string print_alarmed_severity ( sensor_type * sensor_ptr )
|
|
{
|
|
string alarmed_severity = "";
|
|
if ( sensor_ptr->critl.alarmed || sensor_ptr->major.alarmed || sensor_ptr->minor.alarmed )
|
|
{
|
|
alarmed_severity.append(" [");
|
|
if ( sensor_ptr->critl.alarmed )
|
|
alarmed_severity.append("alarmd-critl");
|
|
if ( sensor_ptr->major.alarmed )
|
|
alarmed_severity.append("alarmd-major");
|
|
if ( sensor_ptr->minor.alarmed )
|
|
alarmed_severity.append("alarmd-minor");
|
|
alarmed_severity.append("]");
|
|
}
|
|
return(alarmed_severity);
|
|
}
|
|
|
|
string print_ignored_severity ( sensor_type * sensor_ptr )
|
|
{
|
|
string ignored_severity = "";
|
|
if ( sensor_ptr->critl.ignored || sensor_ptr->major.ignored || sensor_ptr->minor.ignored )
|
|
{
|
|
ignored_severity.append(" [");
|
|
if ( sensor_ptr->critl.ignored )
|
|
ignored_severity.append("ignore-critl");
|
|
if ( sensor_ptr->major.ignored )
|
|
ignored_severity.append("ignore-major");
|
|
if ( sensor_ptr->minor.ignored )
|
|
ignored_severity.append("ignore-minor");
|
|
ignored_severity.append("]");
|
|
}
|
|
return(ignored_severity);
|
|
}
|
|
|
|
string print_logged_severity ( sensor_type * sensor_ptr )
|
|
{
|
|
string logged_severity = "";
|
|
if ( sensor_ptr->critl.logged || sensor_ptr->major.logged || sensor_ptr->minor.logged )
|
|
{
|
|
logged_severity.append(" [");
|
|
if ( sensor_ptr->critl.logged )
|
|
logged_severity.append("logged-critl");
|
|
if ( sensor_ptr->major.logged )
|
|
logged_severity.append("logged-major");
|
|
if ( sensor_ptr->minor.logged )
|
|
logged_severity.append("logged-minor");
|
|
logged_severity.append("]");
|
|
}
|
|
return(logged_severity);
|
|
}
|
|
|
|
|
|
void sensorState_print ( string & hostname, sensor_type * sensor_ptr )
|
|
{
|
|
if ( sensor_ptr->status.compare("ok") ||
|
|
sensor_ptr->degraded ||
|
|
sensor_ptr->alarmed ||
|
|
sensor_ptr->suppress ||
|
|
sensor_ptr->critl.alarmed ||
|
|
sensor_ptr->major.alarmed ||
|
|
sensor_ptr->minor.alarmed ||
|
|
sensor_ptr->critl.ignored ||
|
|
sensor_ptr->major.ignored ||
|
|
sensor_ptr->minor.ignored ||
|
|
sensor_ptr->critl.logged ||
|
|
sensor_ptr->major.logged ||
|
|
sensor_ptr->minor.logged )
|
|
{
|
|
wlog ("%s %-20s %-8s %s%s%s%s%s%s\n",
|
|
hostname.c_str(),
|
|
sensor_ptr->sensorname.c_str(),
|
|
sensor_ptr->status.c_str(),
|
|
print_alarmed_severity ( sensor_ptr ).c_str(),
|
|
print_logged_severity ( sensor_ptr ).c_str(),
|
|
print_ignored_severity ( sensor_ptr ).c_str(),
|
|
sensor_ptr->alarmed ? " alarmed" : "",
|
|
sensor_ptr->degraded ? " degraded" : "",
|
|
sensor_ptr->suppress ? " suppressed" : "");
|
|
}
|
|
}
|
|
|
|
|
|
bool is_alarmed_state ( sensor_type * sensor_ptr , sensor_severity_enum & hwmon_sev )
|
|
{
|
|
int count = 0 ;
|
|
if ( sensor_ptr )
|
|
{
|
|
if ( sensor_ptr->minor.alarmed == true )
|
|
{
|
|
hwmon_sev = HWMON_SEVERITY_MINOR ;
|
|
count++ ;
|
|
}
|
|
if ( sensor_ptr->major.alarmed == true )
|
|
{
|
|
hwmon_sev = HWMON_SEVERITY_MAJOR ;
|
|
count++ ;
|
|
}
|
|
if ( sensor_ptr->critl.alarmed == true )
|
|
{
|
|
hwmon_sev = HWMON_SEVERITY_CRITICAL ;
|
|
count++ ;
|
|
}
|
|
|
|
if ( count > 1 )
|
|
{
|
|
slog ("%s '%s' alarm state tracking mismatch [alarm:%s:%s:%s]\n",
|
|
sensor_ptr->hostname.c_str(),
|
|
sensor_ptr->sensorname.c_str(),
|
|
sensor_ptr->minor.alarmed ? "Yes":"No",
|
|
sensor_ptr->major.alarmed ? "Yes":"No",
|
|
sensor_ptr->critl.alarmed ? "Yes":"No");
|
|
}
|
|
}
|
|
return (count);
|
|
}
|
|
|
|
bool is_alarmed ( sensor_type * sensor_ptr )
|
|
{
|
|
if ( sensor_ptr )
|
|
{
|
|
if (( sensor_ptr->alarmed == true ) ||
|
|
( sensor_ptr->minor.alarmed == true ) ||
|
|
( sensor_ptr->major.alarmed == true ) ||
|
|
( sensor_ptr->critl.alarmed == true ))
|
|
{
|
|
return (true );
|
|
}
|
|
}
|
|
return (false);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
*
|
|
* Name : checksum_sample_profile
|
|
*
|
|
* Description: Append all the sensor names in a 'sensor_data_type' sensor list
|
|
* into a long string and checksum that string.
|
|
*
|
|
* Purponse : The checksum provides a unique signature for a specific sensor
|
|
* profile. Used to uniquely identify the Quanta sensor model or
|
|
* a change of a sensor model.
|
|
*
|
|
******************************************************************************/
|
|
|
|
unsigned short checksum_sample_profile ( const string & hostname,
|
|
int sensors,
|
|
sensor_data_type * sensor_ptr)
|
|
{
|
|
unsigned short sum = 0 ;
|
|
if ( sensors )
|
|
{
|
|
string temp = "" ;
|
|
for ( int i = 0 ; i < sensors ; i++ , sensor_ptr++ )
|
|
{
|
|
temp.append(sensor_ptr->name);
|
|
}
|
|
sum += checksum ( (void*)temp.data(), temp.length());
|
|
|
|
blog2 ("%s sensor sample checksum 0x%04x\n", hostname.c_str(), sum);
|
|
}
|
|
return (sum);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
*
|
|
* Name : checksum_sensor_profile
|
|
*
|
|
* Description: Append all the sensor names in a 'sensor_type' sensor list into
|
|
* a long string and checksum that string.
|
|
*
|
|
* Purponse : The checksum provides a unique signature for a specific sensor
|
|
* profile. Used to uniquely identify the Quanta sensor model or
|
|
* a change of a sensor model.
|
|
*
|
|
******************************************************************************/
|
|
|
|
unsigned short checksum_sensor_profile ( const string & hostname,
|
|
int sensors,
|
|
sensor_type * sensor_ptr)
|
|
{
|
|
unsigned short sum = 0 ;
|
|
if ( sensors )
|
|
{
|
|
string temp = "" ;
|
|
for ( int i = 0 ; i < sensors ; i++ , sensor_ptr++ )
|
|
{
|
|
temp.append(sensor_ptr->sensorname);
|
|
}
|
|
sum += checksum ( (void*)temp.data(), temp.length());
|
|
|
|
blog2 ("%s sensor profile checksum 0x%04x\n", hostname.c_str(), sum );
|
|
}
|
|
return (sum);
|
|
}
|
|
|
|
|
|
|
|
/* load the specified key value in buffer line into 'value' */
|
|
bool got_delimited_value ( char * buf_ptr,
|
|
const char * key,
|
|
const char * delimiter,
|
|
string & value )
|
|
{
|
|
if ( strstr ( buf_ptr, key ))
|
|
{
|
|
string _str = buf_ptr ;
|
|
if ( _str.find(key) != std::string::npos )
|
|
{
|
|
if ( _str.find( delimiter ) != std::string::npos )
|
|
{
|
|
int y = _str.find( delimiter ) ;
|
|
value = _str.substr ( y+strlen(delimiter), std::string::npos) ;
|
|
value.erase ( value.size()-1, std::string::npos ) ;
|
|
return (true);
|
|
}
|
|
}
|
|
}
|
|
return (false);
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Name : get_bmc_version_string
|
|
*
|
|
* Description: Return the bmc version string from the specified filename.
|
|
*
|
|
* Looking for 'Firmware Revision' label fromspecified file
|
|
*
|
|
* Firmware Revision : 3.29
|
|
*
|
|
**************************************************************************/
|
|
|
|
#define BUFFER (80)
|
|
|
|
#define BMC_INFO_LABEL_FW_VERSION ((const char *)("Firmware Revision"))
|
|
#define BMC_INFO_LABEL_DELIMITER ((const char *)(": "))
|
|
string get_bmc_version_string ( string hostname,
|
|
const char * filename )
|
|
{
|
|
string bmc_fw_version = "" ;
|
|
if ( daemon_is_file_present ( filename ) )
|
|
{
|
|
FILE * _stream = fopen ( filename, "r" );
|
|
if ( _stream )
|
|
{
|
|
char buffer [BUFFER];
|
|
MEMSET_ZERO(buffer);
|
|
while ( fgets (buffer, BUFFER, _stream) )
|
|
{
|
|
if ( got_delimited_value ( buffer, BMC_INFO_LABEL_FW_VERSION,
|
|
BMC_INFO_LABEL_DELIMITER,
|
|
bmc_fw_version ))
|
|
{
|
|
break ;
|
|
}
|
|
MEMSET_ZERO(buffer);
|
|
}
|
|
fclose(_stream);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
elog ("%s failed to open mc info file '%s'\n", hostname.c_str(),
|
|
filename);
|
|
}
|
|
|
|
return (bmc_fw_version);
|
|
}
|