starlingx/metal
Code Issues Proposed changes

Merge "Enable protocol switch between ipmi and redfish for hwmon"

Browse Source
This commit is contained in:
Zuul 2019-09-23 19:01:39 +00:00 committed by Gerrit Code Review
commit e3548596ef
9 changed files with 349 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
mtce-common/src/common/bmcUtil.cpp
View File

@ -17,7 +17,7 @@ using namespace std;
#include "nodeBase.h" /* for ... mtce-common node definitions */
#include "hostUtil.h" /* for ... mtce-common host definitions */
#include "bmcUtil.h" /* for ... mtce-common bmc utility header */
#include "jsonUtil.h" /* for ... json_tokener_parse */
/**********************************************************************
*
@ -93,6 +93,31 @@ string bmcUtil_getProtocol_str ( bmc_protocol_enum protocol )
}
}
/**********************************************************************
*
* Name : bmcUtil_chop_system_req
*
* Purpose : logging ; reduce the length of the system call
* request for logging purposes.
*
* Warning : Do not use the chopped string to make the system
* call request. Only use it for logging.
*
* Description: return the chopped string.
*
**********************************************************************/
string bmcUtil_chop_system_req ( string request )
{
string chopped_request = "" ;
size_t found = request.find(" > ") ;
if ( found != string::npos )
chopped_request = request.substr(9,found-9);
else
chopped_request = request.substr(9);
return (chopped_request);
}
/*************************************************************************
*
* Name : bmcUtil_init
@ -109,6 +134,7 @@ string bmcUtil_getProtocol_str ( bmc_protocol_enum protocol )
int bmcUtil_init ( void )
{
daemon_make_dir(BMC_OUTPUT_DIR) ;
daemon_make_dir(BMC_HWMON_TMP_DIR) ;
ipmiUtil_init ();
redfishUtil_init ();
@ -223,6 +249,97 @@ void bmcUtil_hwmon_info ( string hostname,
daemon_log ( bmc_info_path_n_filename.data(), info_str.data() );
}
/*****************************************************************************
*
* Name : bmcUtil_read_bmc_info
* Description : Read power status and protocol from bmc info file
* Parameters : hostname - host name
power_state - read from file
protocol - read from file
* Return : true - file exist
false - file not exist
*
*****************************************************************************/
bool bmcUtil_read_bmc_info( string hostname,
string & power_state,
bmc_protocol_enum & protocol )
{
struct json_object *json_obj = NULL;
string bmc_info_path_n_filename = BMC_OUTPUT_DIR + hostname ;
if ( ! daemon_is_file_present ( bmc_info_path_n_filename.data() ))
return (false);
string filedata = daemon_read_file (bmc_info_path_n_filename.data()) ;
blog ("%s data:%s\n", hostname.c_str(), filedata.data());
json_obj = json_tokener_parse ( (char *)filedata.data() );
if ( json_obj )
{
power_state = jsonUtil_get_key_value_string ( json_obj, "power_state" );
if ( strcmp (power_state.data(), BMC_POWER_ON_STATUS) )
power_state = BMC_POWER_OFF_STATUS ;
string protocol_str = jsonUtil_get_key_value_string ( json_obj, "protocol" );
if ( strcmp (protocol_str.data(), BMC_PROTOCOL__REDFISHTOOL_STR) )
protocol = BMC_PROTOCOL__IPMITOOL ;
else
protocol = BMC_PROTOCOL__REDFISHTOOL ;
json_object_put(json_obj);
return (true);
}
else
{
/* Set to default value for power state and protocol */
power_state = BMC_POWER_OFF_STATUS ;
protocol = BMC_PROTOCOL__IPMITOOL ;
blog ("%s failed to parse bmc info! set to ipmitool by default!\n", hostname.c_str());
return (false);
}
}
/*****************************************************************************
*
* Name : bmcUtil_read_hwmond_protocol
* Description : Read hwmon protocol from hwmon_hostname_protocol file
* Parameters : hostname - host name
* Return : bmc protocol
*
*****************************************************************************/
bmc_protocol_enum bmcUtil_read_hwmond_protocol ( string hostname )
{
bmc_protocol_enum protocol = BMC_PROTOCOL__IPMITOOL ;
string hwmond_proto_filename = BMC_HWMON_TMP_DIR + hostname ;
string proto_str = daemon_read_file ( hwmond_proto_filename.data() ) ;
if ( strcmp (proto_str.data(), BMC_PROTOCOL__REDFISHTOOL_STR) )
protocol = BMC_PROTOCOL__REDFISHTOOL ;
return protocol;
}
/*****************************************************************************
*
* Name : bmcUtil_write_hwmond_protocol
* Description : Write hwmon protocol to hwmon_hostname_protocol file
* Parameters : hostname - host name
protocol - protocol stored to the file
*
*****************************************************************************/
void bmcUtil_write_hwmond_protocol ( string hostname,
bmc_protocol_enum protocol )
{
string hwmond_proto_filename = BMC_HWMON_TMP_DIR + hostname ;
/* remove old file if present and write current protocol to the file*/
daemon_remove_file ( hwmond_proto_filename.data() );
string proto_str = bmcUtil_getProtocol_str ( protocol ) ;
daemon_log ( hwmond_proto_filename.data(), proto_str.data() );
}
/*************************************************************************
*
* Name : bmcUtil_create_pw_file

17
mtce-common/src/common/bmcUtil.h
View File

@ -20,7 +20,8 @@ using namespace std;
#include "nodeBase.h" /* for ... */
#include "threadUtil.h" /* for ... thread_info_type and utilities */
#define BMC_OUTPUT_DIR ((const char *)("/var/run/bmc/"))
#define BMC_OUTPUT_DIR ((const char *)("/var/run/bmc/"))
#define BMC_HWMON_TMP_DIR ((const char *)("/etc/mtc/tmp/hwmon/"))
/* supported protocol strings */
#define BMC_PROTOCOL__IPMITOOL_STR ((const char *)("ipmitool"))
@ -96,12 +97,16 @@ typedef enum
#define BMC_POWER_STATUS_FILE_SUFFIX ((const char *)("_power_status"))
#define BMC_SENSOR_OUTPUT_FILE_SUFFIX ((const char *)("_sensor_data"))
#define BMC_POWER_ON_STATUS ((const char *)("on"))
#define BMC_POWER_OFF_STATUS ((const char *)("off"))
#define BMC_MAX_RECV_RETRIES (10)
/* get the thread command name string */
string bmcUtil_getCmd_str ( int command );
string bmcUtil_getAction_str ( int action );
string bmcUtil_getProtocol_str ( bmc_protocol_enum protocol );
string bmcUtil_chop_system_req ( string request );
/* module initialization */
int bmcUtil_init ( void );
@ -119,6 +124,16 @@ string bmcUtil_create_data_fn ( string & hostname,
string file_suffix,
bmc_protocol_enum protocol );
/* Read power status and protocol from bmc info file */
bool bmcUtil_read_bmc_info ( string hostname,
string & power_state,
bmc_protocol_enum & protocol);
bmc_protocol_enum bmcUtil_read_hwmond_protocol ( string hostname );
void bmcUtil_write_hwmond_protocol ( string hostname,
bmc_protocol_enum protocol );
/* this utility creates the bmc info file for hardware monitor */
void bmcUtil_hwmon_info ( string hostname,
bmc_protocol_enum proto,

34
mtce-common/src/common/threadUtil.cpp
View File

@ -122,6 +122,40 @@ void threadUtil_fini ( void )
; // ilog ("called\n");
}
/*****************************************************************************
*
* Name : threadUtil_bmcSystemCall
*
* Description: Execute a bmc system call using the supplied request string.
*
* If the call takes longer than the supplied latency threshold
* then print a log indicating how long it took.
*
* Returns : the system call's return code.
*
****************************************************************************/
#ifndef NSEC_TO_SEC
#define NSEC_TO_SEC (1000000000)
#endif
int threadUtil_bmcSystemCall (string hostname,
string request,
unsigned long long latency_threshold_secs)
{
unsigned long long before_time = gettime_monotonic_nsec () ;
int rc = system ( request.data()) ;
unsigned long long after_time = gettime_monotonic_nsec () ;
unsigned long long delta_time = after_time-before_time ;
if ( delta_time > (latency_threshold_secs*1000000000))
{
wlog ("%s bmc system call took %2llu.%-8llu sec", hostname.c_str(),
(delta_time > NSEC_TO_SEC) ? (delta_time/NSEC_TO_SEC) : 0,
(delta_time > NSEC_TO_SEC) ? (delta_time%NSEC_TO_SEC) : 0);
}
return (rc);
}
/*****************************************************************************
*
* Name : _stage_change

5
mtce-common/src/common/threadUtil.h
View File

@ -259,6 +259,11 @@ typedef struct
void threadUtil_fini ( void );
int threadUtil_init ( void (*handler)(int, siginfo_t*, void* ));
#define DEFAULT_SYSTEM_REQUEST_LATENCY_SECS (unsigned long long)(15)
int threadUtil_bmcSystemCall (string hostname,
string request,
unsigned long long latency_threshold_secs);
void threadUtil_setstack_size ( void );
/* Onetime thread init setup */

7
mtce/src/hwmon/hwmonClass.cpp
View File

@ -734,7 +734,7 @@ int hwmonHostClass::add_host ( node_inv_type & inv )
thread_init ( host_ptr->bmc_thread_ctrl,
host_ptr->bmc_thread_info,
&host_ptr->thread_extra_info,
hwmonThread_ipmitool,
hwmonThread_bmc,
DEFAULT_THREAD_TIMEOUT_SECS,
host_ptr->hostname,
THREAD_NAME__BMC);
@ -757,6 +757,11 @@ int hwmonHostClass::add_host ( node_inv_type & inv )
host_ptr->group_index = 0 ;
/* Set default BMC protocol */
host_ptr->protocol = BMC_PROTOCOL__IPMITOOL ;
host_ptr->bmc_thread_info.proto = BMC_PROTOCOL__IPMITOOL ;
bmcUtil_write_hwmond_protocol ( host_ptr->hostname, BMC_PROTOCOL__IPMITOOL ) ;
/* Init sensor model relearn controls, state and status */
host_ptr->relearn = false ;
host_ptr->relearn_request = false ;

3
mtce/src/hwmon/hwmonClass.h
View File

@ -81,6 +81,9 @@ class hwmonHostClass
/* throttle degrade audit logs */
int degrade_audit_log_throttle ;
/* throttle log stating its waiting for prococol from mtce */
int general_log_throttle ;
/** set to the protocol used to communicate with this server's BMC */
bmc_protocol_enum protocol ;

65
mtce/src/hwmon/hwmonHdlr.cpp
View File

@ -446,11 +446,38 @@ int hwmonHostClass::add_host_handler ( struct hwmonHostClass::hwmon_host * host_
mtcTimer_start ( host_ptr->addTimer, hwmonTimer_handler, delay );
break ;
}
/* get protocol used for last relearn from the file */
host_ptr->protocol = bmcUtil_read_hwmond_protocol ( host_ptr->hostname ) ;
}
else
{
ilog ("%s no sensor model in database ; must be learned\n",
host_ptr->hostname.c_str());
string power_state ;
bmc_protocol_enum protocol ;
if ( bmcUtil_read_bmc_info( host_ptr->hostname, power_state, protocol ))
{
ilog ("%s no sensor model in database ; must be learned\n",
host_ptr->hostname.c_str());
if ( protocol != host_ptr->protocol)
{
ilog ("%s bmc protocol changed to %s",
host_ptr->hostname.c_str(),
bmcUtil_getProtocol_str(protocol).c_str());
}
host_ptr->protocol = protocol ;
bmcUtil_write_hwmond_protocol ( host_ptr->hostname, protocol ) ;
host_ptr->general_log_throttle = 0 ;
}
else
{
/* mtc has not yet determined bmc protocol */
mtcTimer_start ( host_ptr->addTimer, hwmonTimer_handler, MTC_SECS_5 );
/* log every minute ; 5*12 */
ilog_throttled (host_ptr->general_log_throttle, 12,
"%s waiting for bmc protocol from mtce ; %d seconds between retries\n",
host_ptr->hostname.c_str(), MTC_SECS_5);
break;
}
}
addStageChange ( host_ptr , HWMON_ADD__DONE );
}
@ -691,14 +718,29 @@ int hwmonHostClass::bmc_sensor_monitor ( struct hwmonHostClass::hwmon_host * hos
/* enter relearn mode */
host_ptr->relearn = true ;
/* Update bmc protocol and hwmond_hostname_protocol file */
string power_state;
bmc_protocol_enum protocol;
bmcUtil_read_bmc_info ( host_ptr->hostname, power_state, protocol ) ;
if ( protocol != host_ptr->protocol)
{
ilog ("%s bmc protocol changed to %s",
host_ptr->hostname.c_str(),
bmcUtil_getProtocol_str(protocol).c_str());
}
host_ptr->protocol = protocol ;
bmcUtil_write_hwmond_protocol ( host_ptr->hostname, protocol ) ;
/* exit relearn request mode.
* allow the relearn operation to proceed */
host_ptr->relearn_request = false ;
host_ptr->relearn_done_date = future_time ( relearn_time );
ilog ("%s next relearn permitted after %s\n",
ilog ("%s next relearn permitted after %s (%s)\n",
host_ptr->hostname.c_str(),
host_ptr->relearn_done_date.c_str());
host_ptr->relearn_done_date.c_str(),
bmcUtil_getProtocol_str(host_ptr->protocol).c_str());
this->monitor_soon ( host_ptr );
@ -796,6 +838,7 @@ int hwmonHostClass::bmc_sensor_monitor ( struct hwmonHostClass::hwmon_host * hos
host_ptr->bmc_thread_info.id = 0 ;
host_ptr->bmc_thread_info.signal = 0 ;
host_ptr->bmc_thread_info.command = BMC_THREAD_CMD__POWER_STATUS ;
host_ptr->bmc_thread_info.proto = host_ptr->protocol ;
/* Update / Setup the BMC query credentials */
host_ptr->thread_extra_info.bm_ip = host_ptr->bm_ip ;
@ -852,7 +895,7 @@ int hwmonHostClass::bmc_sensor_monitor ( struct hwmonHostClass::hwmon_host * hos
else
{
host_ptr->interval_changed = true ;
wlog ("%s audit interval is zero ; auto correcting\n", host_ptr->hostname.c_str());
blog ("%s audit interval is zero ; auto correcting\n", host_ptr->hostname.c_str());
break ;
}
}
@ -943,19 +986,17 @@ int hwmonHostClass::bmc_sensor_monitor ( struct hwmonHostClass::hwmon_host * hos
wlog ("%s power query status empty ; retrying query\n",
host_ptr->hostname.c_str());
}
else if ( host_ptr->bmc_thread_info.data.find (IPMITOOL_POWER_ON_STATUS) == string::npos )
else if ( host_ptr->bmc_thread_info.data.find (BMC_POWER_ON_STATUS) == string::npos )
{
ilog ("%s %s\n", host_ptr->hostname.c_str(),
host_ptr->bmc_thread_info.data.c_str());
wlog ("%s sensor learning delayed ; need power on\n",
host_ptr->hostname.c_str());
wlog ("%s power %s sensor learning delayed ; need power on\n",
host_ptr->hostname.c_str(),
host_ptr->bmc_thread_info.data.c_str());
}
else
{
ilog ("%s %s\n", host_ptr->hostname.c_str(),
host_ptr->bmc_thread_info.data.c_str());
/* OK, this is what we have been waiting for */
host_ptr->poweron = true ;
}
@ -1083,13 +1124,13 @@ int hwmonHostClass::bmc_sensor_monitor ( struct hwmonHostClass::hwmon_host * hos
host_ptr->bmc_thread_info.id = 0 ;
host_ptr->bmc_thread_info.signal = 0 ;
host_ptr->bmc_thread_info.command = BMC_THREAD_CMD__READ_SENSORS ;
host_ptr->bmc_thread_info.proto = host_ptr->protocol ;
/* Update / Setup the BMC query credentials */
host_ptr->thread_extra_info.bm_ip = host_ptr->bm_ip ;
host_ptr->thread_extra_info.bm_un = host_ptr->bm_un ;
host_ptr->thread_extra_info.bm_pw = host_ptr->bm_pw ;
rc = thread_launch ( host_ptr->bmc_thread_ctrl, host_ptr->bmc_thread_info ) ;
if ( rc != PASS )
{

233
mtce/src/hwmon/hwmonThreads.cpp
View File

@ -362,25 +362,25 @@ void * hwmonThread_ipmitool ( void * arg )
info_ptr->password_file.c_str());
/*************** Create the output filename ***************/
string ipmitool_datafile =
string datafile =
bmcUtil_create_data_fn (info_ptr->hostname,
BMC_POWER_STATUS_FILE_SUFFIX,
BMC_PROTOCOL__IPMITOOL ) ;
dlog_t ("%s power query filename : %s\n",
info_ptr->log_prefix,
ipmitool_datafile.c_str());
datafile.c_str());
/************** Create the ipmitool request **************/
string ipmitool_request =
string request =
ipmiUtil_create_request ( command,
extra_ptr->bm_ip,
extra_ptr->bm_un,
info_ptr->password_file,
ipmitool_datafile );
datafile );
dlog_t ("%s power status query cmd: %s\n",
info_ptr->log_prefix,
ipmitool_request.c_str());
request.c_str());
if ( daemon_is_file_present ( MTC_CMD_FIT__POWER_STATUS ))
{
@ -390,7 +390,7 @@ void * hwmonThread_ipmitool ( void * arg )
else
{
/* Make the request */
rc = system ( ipmitool_request.data()) ;
rc = system ( request.data()) ;
}
unlink(info_ptr->password_file.data());
@ -400,29 +400,29 @@ void * hwmonThread_ipmitool ( void * arg )
if ( rc != PASS )
{
info_ptr->status_string = "failed power status query ; " ;
info_ptr->status_string.append(ipmitool_request);
info_ptr->status_string.append(request);
info_ptr->status = FAIL_SYSTEM_CALL ;
}
else
{
bool ipmitool_datafile_present = false ;
bool datafile_present = false ;
/* look for the output data file */
for ( int i = 0 ; i < 10 ; i++ )
{
pthread_signal_handler ( info_ptr );
if ( daemon_is_file_present ( ipmitool_datafile.data() ))
if ( daemon_is_file_present ( datafile.data() ))
{
ipmitool_datafile_present = true ;
datafile_present = true ;
break ;
}
info_ptr->progress++ ;
sleep (1);
}
if ( ipmitool_datafile_present )
if ( datafile_present )
{
info_ptr->data = daemon_read_file (ipmitool_datafile.data()) ;
info_ptr->data = daemon_read_file (datafile.data()) ;
dlog_t ("%s data:%s\n",
info_ptr->hostname.c_str(),
info_ptr->data.data());
@ -950,18 +950,18 @@ static int _parse_redfish_sensor_data( char * json_str_ptr, thread_info_type * i
* Name : _redfishUtil_send_request
* Description : Construct redfishtool request and send it out
* Parameters : info_ptr - thread info
redfishtool_datafile - date file used for storing redfishtool comand response
file_suffix - file suffix for redfishtool_datafile name
datafile - date file used for storing redfishtool comand response
file_suffix - file suffix for datafile name
redfish_cmd_str - redfish command string
* Returns : PASS if command sent out successfully.
*
*****************************************************************************/
static int _redfishUtil_send_request( thread_info_type * info_ptr, string & redfishtool_datafile,
static int _redfishUtil_send_request( thread_info_type * info_ptr, string & datafile,
const char * file_suffix, const char * redfish_cmd_str )
{
string redfishtool_request = "" ;
string pw_file_content = "" ;
string request = "" ;
string config_file_content = "" ;
int rc = PASS ;
thread_extra_info_type * extra_ptr = (thread_extra_info_type*)info_ptr->extra_info_ptr ;
@ -976,13 +976,15 @@ static int _redfishUtil_send_request( thread_info_type * info_ptr, string & redf
}
/**************** Create the password file *****************/
pw_file_content = "{\"user\" : \"" ;
pw_file_content.append(extra_ptr->bm_un) ;
pw_file_content.append("\", \"password\" : \"") ;
pw_file_content.append(extra_ptr->bm_pw) ;
pw_file_content.append("\"}") ;
config_file_content = "{\"username\":\"" ;
config_file_content.append(extra_ptr->bm_un) ;
config_file_content.append("\",\"user\":\"") ;
config_file_content.append(extra_ptr->bm_un) ;
config_file_content.append("\",\"password\":\"") ;
config_file_content.append(extra_ptr->bm_pw) ;
config_file_content.append("\"}") ;
bmcUtil_create_pw_file ( info_ptr, pw_file_content, BMC_PROTOCOL__REDFISHTOOL ) ;
bmcUtil_create_pw_file ( info_ptr, config_file_content, BMC_PROTOCOL__REDFISHTOOL ) ;
if ( info_ptr->password_file.empty() )
{
info_ptr->status_string = "failed to get a temporary password filename" ;
@ -995,69 +997,54 @@ static int _redfishUtil_send_request( thread_info_type * info_ptr, string & redf
info_ptr->password_file.c_str());
/*************** Create the output filename ***************/
redfishtool_datafile =
bmcUtil_create_data_fn (info_ptr->hostname, file_suffix, BMC_PROTOCOL__REDFISHTOOL ) ;
dlog_t ("%s create data filename : %s\n",
info_ptr->log_prefix,
redfishtool_datafile.c_str());
datafile = bmcUtil_create_data_fn (info_ptr->hostname, file_suffix, BMC_PROTOCOL__REDFISHTOOL ) ;
dlog_t ("%s create data filename : %s\n", info_ptr->log_prefix, datafile.c_str());
/************** Create the redfishtool request **************/
redfishtool_request =
redfishUtil_create_request ( redfish_cmd_str,
extra_ptr->bm_ip,
info_ptr->password_file,
redfishtool_datafile );
request = redfishUtil_create_request ( redfish_cmd_str,
extra_ptr->bm_ip,
info_ptr->password_file,
datafile );
dlog_t ("%s query cmd: %s\n",
info_ptr->log_prefix,
redfishtool_request.c_str());
request.c_str());
if ( ( info_ptr->command == BMC_THREAD_CMD__BMC_INFO
&& daemon_is_file_present ( MTC_CMD_FIT__MC_INFO ) )
|| ( info_ptr->command == BMC_THREAD_CMD__POWER_STATUS
&& daemon_is_file_present ( MTC_CMD_FIT__POWER_STATUS ) ) )
if (( info_ptr->command == BMC_THREAD_CMD__READ_SENSORS ) &&
( daemon_is_file_present ( MTC_CMD_FIT__SENSOR_DATA )))
{
slog ("%s FIT CMD ： %s\n", info_ptr->hostname.c_str(), redfish_cmd_str);
rc = PASS ;
}
else if ( info_ptr->command == BMC_THREAD_CMD__READ_SENSORS )
{
if( daemon_is_file_present ( MTC_CMD_FIT__SENSOR_DATA ))
{
rc = PASS ;
}
#ifdef WANT_FIT_TESTING
else if ( daemon_want_fit ( FIT_CODE__HWMON__AVOID_SENSOR_QUERY, info_ptr->hostname ))
{
rc = PASS ; // ilog ("%s FIT Avoiding Sensor Query\n", info_ptr->hostname.c_str());
}
else if ( daemon_want_fit ( FIT_CODE__AVOID_N_FAIL_BMC_REQUEST, info_ptr->hostname ))
{
rc = FAIL ; // ilog ("%s FIT Avoiding Sensor Query\n", info_ptr->hostname.c_str());
}
else
{
/* Make the request */
rc = system ( redfishtool_request.data()) ;
}
#endif
}
else
{
/* Make the request */
rc = system ( redfishtool_request.data()) ;
daemon_remove_file ( datafile.data() ) ;
rc = threadUtil_bmcSystemCall (info_ptr->hostname, request,
DEFAULT_SYSTEM_REQUEST_LATENCY_SECS) ;
if ( rc != PASS )
{
/* crop garbage from the command to reduce log length */
string cmd_only = bmcUtil_chop_system_req ( request ) ;
elog_t ("%s system call failed [%s] (%d:%d:%m)\n",
info_ptr->hostname.c_str(),
cmd_only.c_str(),
rc, errno );
info_ptr->status = FAIL_SYSTEM_CALL ;
if ( daemon_is_file_present ( datafile.data() ))
{
/* load in the error. stdio is redirected to the datafile */
info_ptr->status_string = daemon_read_file(datafile.data());
}
else
{
info_ptr->status_string = "system call failed for info query ; " ;
info_ptr->status_string.append(request);
}
}
}
unlink(info_ptr->password_file.data());
daemon_remove_file (info_ptr->password_file.data());
/* check for system call error case */
if ( rc != PASS )
{
info_ptr->status_string = "system call failed for info query ; " ;
info_ptr->status_string.append(redfishtool_request);
info_ptr->status = FAIL_SYSTEM_CALL ;
}
return (rc) ;
}
@ -1065,20 +1052,20 @@ static int _redfishUtil_send_request( thread_info_type * info_ptr, string & redf
*
* Name : wait_for_command_output
* Description : Wait for some time to check if redfishtool command output is available.
* Parameters : info_ptr - thread info
redfishtool_datafile - date file used for storing redfishtool comand response
* Parameters : info_ptr - thread info
datafile - date file used for storing redfishtool comand response
* Returns : True if command response file is availalbe
False if command response file is unavailable after timeout.
*
*****************************************************************************/
static bool _wait_for_command_output( thread_info_type * info_ptr, string & redfishtool_datafile )
static bool _wait_for_command_output( thread_info_type * info_ptr, string & datafile )
{
/* look for the output data file */
for ( int i = 0 ; i < 10 ; i++ )
{
pthread_signal_handler ( info_ptr );
if ( daemon_is_file_present ( redfishtool_datafile.data() ))
if ( daemon_is_file_present ( datafile.data() ))
{
return true ;
}
@ -1097,7 +1084,7 @@ static bool _wait_for_command_output( thread_info_type * info_ptr, string & redf
* Description : Parse power and thermal sensor data
* Parameters : info_ptr - thread info
sensor_group - power & thermal group
redfishtool_datafile - date file used for storing redfishtool comand response
datafile - date file used for storing redfishtool comand response
samples - sensor data index for _sample_list array.
* Returns : PASS if file access is OK
*
@ -1105,10 +1092,10 @@ static bool _wait_for_command_output( thread_info_type * info_ptr, string & redf
static int _parse_redfish_sensor_data_output_file( thread_info_type * info_ptr,
int sensor_group,
string & redfishtool_datafile,
string & datafile,
int & samples )
{
FILE * _fp = fopen ( redfishtool_datafile.data(), "r" );
FILE * _fp = fopen ( datafile.data(), "r" );
if ( _fp )
{
@ -1160,7 +1147,7 @@ static int _parse_redfish_sensor_data_output_file( thread_info_type * info_ptr,
{
info_ptr->status = FAIL_FILE_ACCESS ;
info_ptr->status_string = "failed to open sensor data file: ";
info_ptr->status_string.append(redfishtool_datafile);
info_ptr->status_string.append(datafile);
}
return FAIL ;
@ -1180,7 +1167,7 @@ void * hwmonThread_redfish ( void * arg )
thread_info_type * info_ptr ;
thread_extra_info_type * extra_ptr ;
string redfishtool_datafile = "";
string datafile = "";
/* Pointer Error Detection and Handling */
if ( !arg )
@ -1217,15 +1204,15 @@ void * hwmonThread_redfish ( void * arg )
case BMC_THREAD_CMD__READ_SENSORS:
{
blog2_t ("%s read power sensors \n", info_ptr->log_prefix);
if ( _redfishUtil_send_request( info_ptr, redfishtool_datafile,
if ( _redfishUtil_send_request( info_ptr, datafile,
BMC_SENSOR_OUTPUT_FILE_SUFFIX,
REDFISHTOOL_READ_POWER_SENSORS_CMD ) == PASS )
{
/* look for the output data file */
if( _wait_for_command_output(info_ptr, redfishtool_datafile) )
if( _wait_for_command_output(info_ptr, datafile) )
{
_parse_redfish_sensor_data_output_file( info_ptr, BMC_SENSOR_POWER_GROUP,
redfishtool_datafile, samples );
datafile, samples );
}
else
{
@ -1234,15 +1221,15 @@ void * hwmonThread_redfish ( void * arg )
}
blog2_t ("%s read thermal sensors \n", info_ptr->log_prefix);
if (_redfishUtil_send_request( info_ptr, redfishtool_datafile,
if (_redfishUtil_send_request( info_ptr, datafile,
BMC_SENSOR_OUTPUT_FILE_SUFFIX,
REDFISHTOOL_READ_THERMAL_SENSORS_CMD ) == PASS )
{
/* look for the output data file */
if( _wait_for_command_output(info_ptr, redfishtool_datafile) )
if( _wait_for_command_output(info_ptr, datafile) )
{
_parse_redfish_sensor_data_output_file( info_ptr, BMC_SENSOR_THERMAL_GROUP,
redfishtool_datafile, samples );
datafile, samples );
}
}
@ -1259,46 +1246,22 @@ void * hwmonThread_redfish ( void * arg )
}
break ;
}
case BMC_THREAD_CMD__BMC_INFO:
{
blog2_t ("%s query BMC info\n", info_ptr->log_prefix);
if (_redfishUtil_send_request( info_ptr, redfishtool_datafile,
BMC_INFO_FILE_SUFFIX, REDFISHTOOL_BMC_INFO_CMD )
== PASS )
{
/* look for the output data file */
if( _wait_for_command_output(info_ptr, redfishtool_datafile) )
{
info_ptr->data = daemon_read_file (redfishtool_datafile.data()) ;
dlog_t ("%s data:%s\n",
info_ptr->hostname.c_str(),
info_ptr->data.data());
info_ptr->status_string = "pass" ;
info_ptr->status = PASS ;
}
}
break ;
}
case BMC_THREAD_CMD__POWER_STATUS:
{
string power_status = "" ;
bmc_protocol_enum protocol ;
blog2_t ("%s query power status info\n", info_ptr->log_prefix);
if ( _redfishUtil_send_request( info_ptr, redfishtool_datafile,
BMC_POWER_STATUS_FILE_SUFFIX,
REDFISHTOOL_POWER_STATUS_CMD ) == PASS )
bmcUtil_read_bmc_info (info_ptr->hostname, power_status, protocol);
if (power_status.find (BMC_POWER_ON_STATUS) == string::npos)
{
/* look for the output data file */
if( _wait_for_command_output(info_ptr, redfishtool_datafile) )
{
info_ptr->data = daemon_read_file (redfishtool_datafile.data()) ;
dlog_t ("%s data:%s\n",
info_ptr->hostname.c_str(),
info_ptr->data.data());
info_ptr->status_string = "pass" ;
info_ptr->status = PASS ;
}
info_ptr->data = BMC_POWER_OFF_STATUS ;
}
else
{
info_ptr->data = BMC_POWER_ON_STATUS ;
}
info_ptr->status_string = "pass" ;
info_ptr->status = PASS ;
break ;
}
default:
@ -1336,3 +1299,31 @@ redfishtool_thread_done:
pthread_exit (&info_ptr->status );
return NULL ;
}
/*****************************************************************************
*
* Name : hwmonThread_bmc
* Purpose : This thread used for sending bmc command
* Description : hwmon thread main function
*
*****************************************************************************/
void * hwmonThread_bmc ( void * arg )
{
string power_status = "";
string protocol = "";
/* cast pointers from arg */
thread_info_type * info_ptr = (thread_info_type*)arg ;
if (info_ptr->proto == BMC_PROTOCOL__REDFISHTOOL )
{
hwmonThread_redfish ( arg );
}
else
{
hwmonThread_ipmitool ( arg );
}
return NULL ;
}

6
mtce/src/hwmon/hwmonThreads.h
View File

@ -42,8 +42,8 @@
#define BMC_SENSOR_POWER_GROUP 0
#define BMC_SENSOR_THERMAL_GROUP 1
void * hwmonThread_ipmitool ( void * );
void * hwmonThread_redfish ( void * );
void * hwmonThread_bmc ( void * );
/* --------------------
* ipmitool_sensor_data: outgoing message
* --------------------
@ -162,10 +162,8 @@ using namespace std;
#define BMC_SENSOR_OUTPUT_FILE_SUFFIX ((const char *)("_sensor_data"))
/* TBD */
#define REDFISHTOOL_READ_POWER_SENSORS_CMD ((const char *)("Chassis Power"))
#define REDFISHTOOL_READ_THERMAL_SENSORS_CMD ((const char *)("Chassis Thermal"))
#define REDFISHTOOL_POWER_STATUS_CMD ((const char *)(" "))
typedef struct
{