784 lines
30 KiB
C++
784 lines
30 KiB
C++
|
|
/*
|
|
* Copyright (c) 2016-2017 Wind River Systems, Inc.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* Wind River Titanium Cloud Hardware Monitor Threads Implementation"
|
|
*
|
|
*/
|
|
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <pthread.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <sys/syscall.h>
|
|
|
|
using namespace std;
|
|
|
|
#include "daemon_common.h"
|
|
|
|
#include "nodeBase.h"
|
|
#include "nodeBase.h" /* for ... mtce node common definitions */
|
|
#include "hostUtil.h" /* for ... mtce host common definitions */
|
|
#include "nodeMacro.h"
|
|
#include "ipmiUtil.h"
|
|
#include "threadUtil.h"
|
|
#include "hwmonThreads.h" /* for ... IPMITOOL_THREAD_CMD__READ_SENSORS */
|
|
#include "hwmonIpmi.h" /* for ... MAX_IPMITOOL_PARSE_ERRORS */
|
|
#include "hwmonClass.h" /* for ... thread_extra_info_type */
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Name : ipmitool_sample_type
|
|
*
|
|
* Description: An array of sensor data.
|
|
*
|
|
* _sample_list
|
|
*
|
|
***************************************************************************/
|
|
|
|
static ipmitool_sample_type _sample_list[MAX_HOST_SENSORS] ;
|
|
|
|
/***************************************************************************
|
|
*
|
|
* P R I V A T E I N T E R F A C E S
|
|
*
|
|
**************************************************************************/
|
|
|
|
static void _command_not_supported ( thread_info_type * info_ptr )
|
|
{
|
|
info_ptr->data = "{\"" ;
|
|
info_ptr->data.append(IPMITOOL_JSON__SENSOR_DATA_MESSAGE_HEADER);
|
|
info_ptr->data.append("\":{");
|
|
info_ptr->data.append("\"status\":");
|
|
info_ptr->data.append(itos(info_ptr->status));
|
|
info_ptr->data.append(",");
|
|
info_ptr->data.append("\"status_string\":\"command '");
|
|
info_ptr->data.append(itos(info_ptr->command));
|
|
info_ptr->data.append("' not supported\"}}");
|
|
|
|
wlog_t ("%s %s\n", info_ptr->log_prefix, info_ptr->data.c_str());
|
|
}
|
|
|
|
|
|
static void _add_json_sensor_tuple ( ipmitool_sample_type * ptr, string & response )
|
|
{
|
|
response.append ("{\"n\":\"");
|
|
response.append (ptr->name);
|
|
response.append ("\",\"v\":\"");
|
|
response.append (ptr->value);
|
|
response.append ("\",\"u\":\"");
|
|
response.append (ptr->unit);
|
|
response.append ("\",\"s\":\"");
|
|
response.append (ptr->status);
|
|
response.append ("\"");
|
|
|
|
/* Include the threshold value of each below if not 'na' */
|
|
if ( strcmp (ptr->lnr,"na" ))
|
|
{
|
|
response.append (",\"lnr\":\"");
|
|
response.append (ptr->lnr);
|
|
response.append ("\"");
|
|
}
|
|
if ( strcmp (ptr->lcr,"na" ))
|
|
{
|
|
response.append (",\"lcr\":\"");
|
|
response.append (ptr->lcr);
|
|
response.append ("\"");
|
|
}
|
|
if ( strcmp (ptr->lnc,"na" ))
|
|
{
|
|
response.append (",\"lnc\":\"");
|
|
response.append (ptr->lnc);
|
|
response.append ("\"");
|
|
}
|
|
if ( strcmp (ptr->unc,"na" ))
|
|
{
|
|
response.append (",\"unc\":\"");
|
|
response.append (ptr->unc);
|
|
response.append ("\"");
|
|
}
|
|
if ( strcmp (ptr->ucr,"na" ))
|
|
{
|
|
response.append (",\"ucr\":\"");
|
|
response.append (ptr->ucr);
|
|
response.append ("\"");
|
|
}
|
|
if ( strcmp (ptr->unr,"na" ))
|
|
{
|
|
response.append (",\"unr\":\"");
|
|
response.append (ptr->unr);
|
|
response.append ("\"");
|
|
}
|
|
response.append("}");
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Name : _parse_sensor_data
|
|
*
|
|
* Description: Create a sensor data json string using pertinent data in the
|
|
* control structure data and of course the _sample_list.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
static void _parse_sensor_data ( thread_info_type * info_ptr )
|
|
{
|
|
if ( info_ptr && info_ptr->extra_info_ptr )
|
|
{
|
|
/*
|
|
* Get local copies rather than continuously use
|
|
* the pointer in the parse process ; just safer
|
|
*/
|
|
thread_extra_info_type * extra_info_ptr = (thread_extra_info_type*)info_ptr->extra_info_ptr ;
|
|
int samples = extra_info_ptr->samples ;
|
|
|
|
info_ptr->data = "{\"" ;
|
|
info_ptr->data.append (IPMITOOL_JSON__SENSOR_DATA_MESSAGE_HEADER);
|
|
info_ptr->data.append ("\":{\"status\":");
|
|
info_ptr->data.append(itos(info_ptr->status));
|
|
info_ptr->data.append(",");
|
|
info_ptr->data.append("\"status_string\":\"");
|
|
|
|
if ( info_ptr->status == PASS )
|
|
{
|
|
info_ptr->data.append("pass\"");
|
|
}
|
|
else
|
|
{
|
|
info_ptr->data.append(info_ptr->status_string);
|
|
info_ptr->data.append ("}}"); /* success path */
|
|
}
|
|
|
|
info_ptr->data.append (",\"");
|
|
info_ptr->data.append (IPMITOOL_JSON__SENSORS_LABEL);
|
|
info_ptr->data.append ("\":[");
|
|
for ( int i = 0 ; i < samples ; )
|
|
{
|
|
_add_json_sensor_tuple ( &_sample_list[i], info_ptr->data ) ;
|
|
if ( ++i < samples )
|
|
info_ptr->data.append (",");
|
|
}
|
|
info_ptr->data.append ("]");
|
|
|
|
info_ptr->data.append ("}}"); /* success path */
|
|
blog3_t ("%s %s\n", info_ptr->log_prefix, info_ptr->data.c_str());
|
|
}
|
|
else if ( info_ptr )
|
|
{
|
|
info_ptr->status_string = "null 'extra info' pointer" ;
|
|
info_ptr->status = FAIL_NULL_POINTER ;
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Name : _get_field
|
|
*
|
|
* Description: Assumes a specific string format where fields are delimted
|
|
* with the '|' character.
|
|
*
|
|
* Warnings : The src and dst variable track the src_ptr and dst_ptr to
|
|
* ensure we never run longer than that string length
|
|
*
|
|
* IPMITOOL_MAX_FIELD_LEN for dst_ptr and
|
|
* IPMITOOL_MAX_LINE_LEN for src_ptr
|
|
*
|
|
* A parse error causes dst_ptr to be updated with
|
|
* PARSE_ERROR_STR and return.
|
|
*
|
|
* Assumptions: Extra white spaces at the beginning and end of a field
|
|
* are removed. There may or may not be such white spaces.
|
|
*
|
|
* Field 0 1 2 3 4 5 6 7 8 9
|
|
* ----------+--------+-------------+----+----+----+----+--------+--------+----+
|
|
* Temp_CPU1 | 42.000 | % degrees C | ok | na | na | na | 86.000 | 87.000 | na
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define PARSE_ERROR_STR ((const char *)("parse error"))
|
|
|
|
void _get_field ( char * src_ptr , int field, char * dst_ptr )
|
|
{
|
|
int src = 0 ;
|
|
char * saved_dst_ptr = dst_ptr ;
|
|
|
|
/* advance to requested field */
|
|
for ( int y = 0 ; y < field ; src_ptr++, src++ )
|
|
{
|
|
/* error detection */
|
|
if (( *src_ptr == '\0' ) || ( src >= IPMITOOL_MAX_LINE_LEN ))
|
|
{
|
|
goto _get_field_parse_error1 ;
|
|
}
|
|
if ( *src_ptr == '|' )
|
|
{
|
|
y++ ;
|
|
}
|
|
}
|
|
|
|
/* eat first white-space(s) */
|
|
for ( ; *src_ptr == ' ' ; src_ptr++ , src++)
|
|
{
|
|
/* error detection */
|
|
if ( src >= IPMITOOL_MAX_LINE_LEN )
|
|
{
|
|
goto _get_field_parse_error2 ;
|
|
}
|
|
}
|
|
|
|
/* copy the source to destination ; until we see a '|' */
|
|
for ( int dst = 0 ; ; src_ptr++ , dst_ptr++ , src++ , dst++ )
|
|
{
|
|
unsigned char ch = 0 ;
|
|
|
|
/* error detection */
|
|
if ( src >= IPMITOOL_MAX_LINE_LEN )
|
|
{
|
|
goto _get_field_parse_error3 ;
|
|
}
|
|
if ( dst >= IPMITOOL_MAX_FIELD_LEN )
|
|
{
|
|
goto _get_field_parse_error4 ;
|
|
}
|
|
ch = *src_ptr ;
|
|
if (( ch != '|' ) && ( ch != '\0' ) && ( ch != 10 ) && ( ch != 13 ))
|
|
{
|
|
*dst_ptr = ch ;
|
|
}
|
|
else
|
|
break ;
|
|
}
|
|
|
|
/* remove last space(s) if they exists */
|
|
for ( dst_ptr-- ; *dst_ptr == ' ' ; dst_ptr-- ) { *dst_ptr = '\0' ; }
|
|
|
|
/* terminate the line after the last real non-space char */
|
|
++dst_ptr = '\0' ;
|
|
|
|
return ;
|
|
|
|
_get_field_parse_error1:
|
|
wlog_t ("%s 1\n", PARSE_ERROR_STR );
|
|
snprintf ( saved_dst_ptr , strlen(PARSE_ERROR_STR)+1, "%s", PARSE_ERROR_STR );
|
|
return ;
|
|
|
|
_get_field_parse_error2:
|
|
wlog_t ("%s 2\n", PARSE_ERROR_STR );
|
|
snprintf ( saved_dst_ptr , strlen(PARSE_ERROR_STR)+1, "%s", PARSE_ERROR_STR );
|
|
return ;
|
|
|
|
_get_field_parse_error3:
|
|
wlog_t ("%s 3\n", PARSE_ERROR_STR );
|
|
snprintf ( saved_dst_ptr , strlen(PARSE_ERROR_STR)+1, "%s", PARSE_ERROR_STR );
|
|
return ;
|
|
|
|
_get_field_parse_error4:
|
|
wlog_t ("%s 4\n", PARSE_ERROR_STR);
|
|
snprintf ( saved_dst_ptr , strlen(PARSE_ERROR_STR)+1, "%s", PARSE_ERROR_STR );
|
|
return ;
|
|
|
|
}
|
|
|
|
/* Temp_CPU1 | 42.000 | % degrees C | ok | na | na | na | 86.000 | 87.000 | na */
|
|
#define IPMITOOL_FULL_OUTPUT_COLUMNS (10)
|
|
|
|
void * hwmonThread_ipmitool ( void * arg )
|
|
{
|
|
int samples ;
|
|
|
|
thread_info_type * info_ptr ;
|
|
thread_extra_info_type * extra_ptr ;
|
|
int parse_errors = 0 ;
|
|
|
|
/* Pointer Error Detection and Handling */
|
|
if ( !arg )
|
|
{
|
|
slog ("*** ipmitool thread called with null arg pointer *** corruption\n");
|
|
return NULL ;
|
|
}
|
|
|
|
/* cast pointers from arg */
|
|
info_ptr = (thread_info_type*)arg ;
|
|
extra_ptr = (thread_extra_info_type*)info_ptr->extra_info_ptr ;
|
|
|
|
info_ptr->pw_file_fd = 0 ;
|
|
|
|
/* allow the parent to confirm thread id */
|
|
info_ptr->id = pthread_self() ;
|
|
if ( extra_ptr == NULL )
|
|
{
|
|
info_ptr->status_string = "null 'extra info' pointer" ;
|
|
info_ptr->status = FAIL_NULL_POINTER ;
|
|
goto ipmitool_thread_done ;
|
|
}
|
|
|
|
/* Set cancellation option so that a delete operation
|
|
* can kill this thread immediately */
|
|
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
|
|
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL );
|
|
|
|
/* the number of sensors are learned */
|
|
extra_ptr->samples = samples = 0 ;
|
|
switch ( info_ptr->command )
|
|
{
|
|
case IPMITOOL_THREAD_CMD__POWER_STATUS:
|
|
{
|
|
int rc = PASS ;
|
|
|
|
info_ptr->status_string = "" ;
|
|
info_ptr->status = PASS ;
|
|
string command = IPMITOOL_POWER_STATUS_CMD ;
|
|
|
|
blog2_t ("%s query power status\n", info_ptr->log_prefix);
|
|
|
|
if ( info_ptr->extra_info_ptr == NULL )
|
|
{
|
|
info_ptr->status = FAIL_NULL_POINTER ;
|
|
info_ptr->status_string = "null extra info pointer" ;
|
|
goto ipmitool_thread_done ;
|
|
}
|
|
|
|
/**************** Create the password file *****************/
|
|
ipmiUtil_create_pw_fn ( info_ptr, extra_ptr->bm_pw ) ;
|
|
if ( info_ptr->password_file.empty() )
|
|
{
|
|
info_ptr->status_string = "failed to get a temporary password filename" ;
|
|
info_ptr->status = FAIL_FILE_CREATE ;
|
|
goto ipmitool_thread_done ;
|
|
}
|
|
dlog_t ("%s password filename : %s\n",
|
|
info_ptr->log_prefix,
|
|
info_ptr->password_file.c_str());
|
|
|
|
/*************** Create the output filename ***************/
|
|
string ipmitool_datafile =
|
|
ipmiUtil_create_data_fn (info_ptr->hostname, IPMITOOL_POWER_STATUS_FILE_SUFFIX ) ;
|
|
dlog_t ("%s power query filename : %s\n",
|
|
info_ptr->log_prefix,
|
|
ipmitool_datafile.c_str());
|
|
|
|
/************** Create the ipmitool request **************/
|
|
string ipmitool_request =
|
|
ipmiUtil_create_request ( command,
|
|
extra_ptr->bm_ip,
|
|
extra_ptr->bm_un,
|
|
info_ptr->password_file,
|
|
ipmitool_datafile );
|
|
dlog_t ("%s power status query cmd: %s\n",
|
|
info_ptr->log_prefix,
|
|
ipmitool_request.c_str());
|
|
|
|
if ( daemon_is_file_present ( MTC_CMD_FIT__POWER_STATUS ))
|
|
{
|
|
slog ("%s FIT IPMITOOL_POWER_STATUS_CMD\n", info_ptr->hostname.c_str());
|
|
rc = PASS ;
|
|
}
|
|
else
|
|
{
|
|
/* Make the request */
|
|
rc = system ( ipmitool_request.data()) ;
|
|
}
|
|
|
|
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 = "failed power status query ; " ;
|
|
info_ptr->status_string.append(ipmitool_request);
|
|
info_ptr->status = FAIL_SYSTEM_CALL ;
|
|
}
|
|
else
|
|
{
|
|
bool ipmitool_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() ))
|
|
{
|
|
ipmitool_datafile_present = true ;
|
|
break ;
|
|
}
|
|
info_ptr->progress++ ;
|
|
sleep (1);
|
|
}
|
|
|
|
if ( ipmitool_datafile_present )
|
|
{
|
|
info_ptr->data = daemon_read_file (ipmitool_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 ;
|
|
}
|
|
else
|
|
{
|
|
info_ptr->status_string = "command did not produce output file ; timeout" ;
|
|
info_ptr->status = FAIL_FILE_ACCESS ;
|
|
}
|
|
}
|
|
break ;
|
|
}
|
|
case IPMITOOL_THREAD_CMD__READ_SENSORS:
|
|
{
|
|
int rc = PASS ;
|
|
|
|
info_ptr->status_string = "" ;
|
|
info_ptr->status = PASS ;
|
|
|
|
blog3_t ("%s read sensors request\n", info_ptr->log_prefix);
|
|
|
|
if ( info_ptr->extra_info_ptr == NULL )
|
|
{
|
|
info_ptr->status = FAIL_NULL_POINTER ;
|
|
info_ptr->status_string = "null extra info pointer" ;
|
|
goto ipmitool_thread_done ;
|
|
}
|
|
|
|
ipmiUtil_create_pw_fn ( info_ptr, extra_ptr->bm_pw ) ;
|
|
if ( info_ptr->password_file.empty() )
|
|
{
|
|
info_ptr->status_string = "failed to get a temporary password filename" ;
|
|
info_ptr->status = FAIL_FILE_CREATE ;
|
|
goto ipmitool_thread_done ;
|
|
}
|
|
|
|
dlog_t ("%s password filename : %s\n",
|
|
info_ptr->log_prefix,
|
|
info_ptr->password_file.c_str());
|
|
|
|
/*************** Create the output filename ***************/
|
|
string sensor_datafile =
|
|
ipmiUtil_create_data_fn (info_ptr->hostname, IPMITOOL_SENSOR_OUTPUT_FILE_SUFFIX ) ;
|
|
|
|
dlog_t ("%s sensor output file%s\n",
|
|
info_ptr->log_prefix,
|
|
sensor_datafile.c_str());
|
|
|
|
/************** Create the ipmitool request **************/
|
|
string sensor_query_request =
|
|
ipmiUtil_create_request ( IPMITOOL_SENSOR_QUERY_CMD,
|
|
extra_ptr->bm_ip,
|
|
extra_ptr->bm_un,
|
|
info_ptr->password_file,
|
|
sensor_datafile );
|
|
|
|
dlog_t ("%s sensor query cmd:%s\n",
|
|
info_ptr->log_prefix,
|
|
sensor_query_request.c_str());
|
|
|
|
|
|
/****************************************************************
|
|
*
|
|
* This fault insertion case is added for PV.
|
|
* If MTC_CMD_FIT__SENSOR_DATA file is present then no ipmitool
|
|
* sensor read is performed. Instead, a raw output file can be
|
|
* placed in /var/run/fit/<hostname>_sensor_data and used to
|
|
* perform sensor fault insertion that way.
|
|
*
|
|
*****************************************************************/
|
|
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_IPMITOOL_REQUEST, info_ptr->hostname ))
|
|
{
|
|
rc = FAIL ; // ilog ("%s FIT Avoiding Sensor Query\n", info_ptr->hostname.c_str());
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
/* remove the last query */
|
|
// daemon_remove_file ( sensor_datafile.data() ) ;
|
|
rc = system ( sensor_query_request.data()) ;
|
|
}
|
|
|
|
#ifdef WANT_FIT_TESTING
|
|
if ( daemon_want_fit ( FIT_CODE__THREAD_TIMEOUT, info_ptr->hostname ) )
|
|
{
|
|
for ( ; ; )
|
|
{
|
|
pthread_signal_handler ( info_ptr );
|
|
sleep (1);
|
|
}
|
|
}
|
|
if ( daemon_want_fit ( FIT_CODE__THREAD_SEGFAULT, info_ptr->hostname ) )
|
|
{
|
|
daemon_do_segfault();
|
|
}
|
|
#endif
|
|
|
|
unlink(info_ptr->password_file.data());
|
|
daemon_remove_file (info_ptr->password_file.data());
|
|
// info_ptr->password_file.clear();
|
|
|
|
/* check for system call error case */
|
|
if ( rc != PASS )
|
|
{
|
|
info_ptr->status_string = "failed query ; " ;
|
|
info_ptr->status_string.append(sensor_query_request);
|
|
info_ptr->status = FAIL_SYSTEM_CALL ;
|
|
}
|
|
else
|
|
{
|
|
FILE * _fp = fopen ( sensor_datafile.data(), "r" );
|
|
if ( _fp )
|
|
{
|
|
char buffer [IPMITOOL_MAX_LINE_LEN];
|
|
int line = 0 ;
|
|
while ( fgets (buffer, IPMITOOL_MAX_LINE_LEN, _fp) != NULL )
|
|
{
|
|
if ( strnlen ( buffer, IPMITOOL_MAX_LINE_LEN ) )
|
|
{
|
|
int bars = 0 ; /* tracks the number of '|'s found in a line */
|
|
bool long_field_error = false ; /* set to true if we get a field in line error */
|
|
int char_field_count = 0 ; /* counts the number of characters in a field */
|
|
// ilog ("\n");
|
|
// ilog ("ipmitool:%d:%s\n", line, buffer );
|
|
|
|
/****************************************
|
|
* sanity check the ipmitool output
|
|
*
|
|
* ipmitool line output looks like
|
|
*
|
|
* Temp_CPU1 | 42.000 | % degrees C | ok | na | na | na | 86.000 | 87.000 | na
|
|
*
|
|
*****************************************
|
|
* start at 1 to handle the 'i-1' case */
|
|
|
|
int i = 1 ; /* aka character in line count or index */
|
|
while (( buffer[i+1] != '\0' ) && ( i < IPMITOOL_MAX_LINE_LEN ))
|
|
{
|
|
if ( buffer[i] == '|' )
|
|
{
|
|
if ( char_field_count > IPMITOOL_MAX_FIELD_LEN )
|
|
{
|
|
long_field_error = true ;
|
|
}
|
|
char_field_count = 0 ;
|
|
++bars ;
|
|
}
|
|
++char_field_count ;
|
|
i++ ; /* advance through the line, character by character */
|
|
}
|
|
|
|
/* scan the sample as long as no field exceeds the max string length */
|
|
if ( long_field_error == false )
|
|
{
|
|
/* Only process properly formatted lines that
|
|
* don't have field lengths longer than IPMITOOL_MAX_FIELD_LEN*/
|
|
if ( bars == (IPMITOOL_FULL_OUTPUT_COLUMNS-1) )
|
|
{
|
|
char type[IPMITOOL_MAX_FIELD_LEN] ;
|
|
int i = 0 ;
|
|
int x = 0 ;
|
|
int y = 0 ;
|
|
/* get type */
|
|
/* advance to type field */
|
|
for ( i = 0 , y = 0 ; y < 2 ; i++ )
|
|
{
|
|
/* handle case where we cant find the '|'s and y never reaches 2 */
|
|
if ( i < IPMITOOL_MAX_LINE_LEN )
|
|
{
|
|
if ( buffer[i] == '|' )
|
|
{
|
|
y++ ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( ++parse_errors == MAX_IPMITOOL_PARSE_ERRORS )
|
|
{
|
|
info_ptr->status = FAIL_JSON_TOO_LONG ;
|
|
info_ptr->status_string = "sensor format error ; line format error";
|
|
goto ipmitool_thread_done ;
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
/* ignore this line */
|
|
if ( i >= IPMITOOL_MAX_LINE_LEN )
|
|
{
|
|
continue ;
|
|
}
|
|
|
|
/* eat first white-space(s) */
|
|
for ( ; buffer[i] == ' ' ; i++ ) ;
|
|
|
|
/* copy the senor unit type to type */
|
|
for ( x = 0 ; buffer[i] != '|' ; i++, x++ ) { type[x] = buffer[i] ; }
|
|
|
|
/* remove last space(s) if they exists */
|
|
for ( x-- ; type[x] == ' ' ; x-- ) { type[x] = '\0' ; }
|
|
|
|
/* terminate the line after the last real non-space char */
|
|
type[x+1] = '\0' ;
|
|
|
|
if (!strlen(type))
|
|
{
|
|
blog3_t ("%s skipping sensor with empty unit type\n", info_ptr->log_prefix);
|
|
blog3_t ("%s ... line:%d - %s", info_ptr->log_prefix, line, buffer );
|
|
continue ;
|
|
}
|
|
else
|
|
{
|
|
blog3_t ("%s Line:%d is a '%s' sensor\n", info_ptr->log_prefix, line, type );
|
|
}
|
|
|
|
_get_field ( buffer, 0, _sample_list[samples].name );
|
|
_get_field ( buffer, 1, _sample_list[samples].value );
|
|
|
|
/* copy already learned type to unit field 2 */
|
|
snprintf ( _sample_list[samples].unit, strlen(type)+1, "%s", type );
|
|
|
|
_get_field ( buffer, 3, _sample_list[samples].status );
|
|
_get_field ( buffer, 4, _sample_list[samples].lnr );
|
|
_get_field ( buffer, 5, _sample_list[samples].lcr );
|
|
_get_field ( buffer, 6, _sample_list[samples].lnc );
|
|
_get_field ( buffer, 7, _sample_list[samples].unc );
|
|
_get_field ( buffer, 8, _sample_list[samples].ucr );
|
|
_get_field ( buffer, 9, _sample_list[samples].unr );
|
|
blog2_t ("%s | %20s | %8s | %12s | %3s | %8s | %8s | %8s | %8s | %8s | %8s |\n",
|
|
info_ptr->log_prefix,
|
|
_sample_list[samples].name,
|
|
_sample_list[samples].value,
|
|
_sample_list[samples].unit,
|
|
_sample_list[samples].status,
|
|
_sample_list[samples].lnr,
|
|
_sample_list[samples].lcr,
|
|
_sample_list[samples].lnc,
|
|
_sample_list[samples].unc,
|
|
_sample_list[samples].ucr,
|
|
_sample_list[samples].unr);
|
|
samples++ ;
|
|
if ( samples >= MAX_HOST_SENSORS )
|
|
{
|
|
samples-- ;
|
|
rc = info_ptr->status = FAIL_OUT_OF_RANGE ;
|
|
info_ptr->status_string = "max number of sensors reached";
|
|
break ;
|
|
}
|
|
rc = PASS ;
|
|
}
|
|
else
|
|
{
|
|
/* ignore commented lines */
|
|
if (( buffer[0] != '#' ) && ( buffer[0] != ';' ))
|
|
{
|
|
if ( ++parse_errors == MAX_IPMITOOL_PARSE_ERRORS )
|
|
{
|
|
info_ptr->status = FAIL_BAD_PARM ;
|
|
info_ptr->status_string = "sensor format error ; line format error 1";
|
|
}
|
|
blog3_t ("%s %s (e:%d d:%d)", info_ptr->log_prefix,
|
|
info_ptr->status_string.c_str(),
|
|
(IPMITOOL_FULL_OUTPUT_COLUMNS), bars+1 );
|
|
|
|
blog3_t ("%s ... line:%d - %s", info_ptr->log_prefix, line, buffer );
|
|
}
|
|
else
|
|
{
|
|
blog3_t ("%s COMMENT %s", info_ptr->log_prefix, &buffer[0]);
|
|
}
|
|
} /* end else */
|
|
}
|
|
else
|
|
{
|
|
if ( ++parse_errors == MAX_IPMITOOL_PARSE_ERRORS )
|
|
{
|
|
info_ptr->status = FAIL_JSON_TOO_LONG ;
|
|
info_ptr->status_string = "sensor format error ; line format error 2" ;
|
|
}
|
|
blog3_t ("%s ... line:%d - %s", info_ptr->log_prefix, line, buffer );
|
|
}
|
|
}
|
|
MEMSET_ZERO(buffer) ;
|
|
line++ ;
|
|
pthread_signal_handler ( info_ptr );
|
|
} /* end while loop */
|
|
|
|
extra_ptr->samples = samples ;
|
|
|
|
if ( samples == 0 )
|
|
{
|
|
info_ptr->status = FAIL_NO_DATA ;
|
|
info_ptr->status_string = "no sensor data found";
|
|
}
|
|
fclose(_fp);
|
|
} /* fopen */
|
|
else
|
|
{
|
|
info_ptr->status = FAIL_FILE_ACCESS ;
|
|
info_ptr->status_string = "failed to open sensor data file: <";
|
|
info_ptr->status_string.append(sensor_datafile);
|
|
info_ptr->status_string.append(">");
|
|
}
|
|
} /* end else handling of successful system command */
|
|
break ;
|
|
}
|
|
default:
|
|
{
|
|
info_ptr->status = FAIL_BAD_CASE ;
|
|
_command_not_supported ( info_ptr );
|
|
break ;
|
|
}
|
|
}
|
|
|
|
ipmitool_thread_done:
|
|
|
|
if ( info_ptr->pw_file_fd > 0 )
|
|
close(info_ptr->pw_file_fd);
|
|
info_ptr->pw_file_fd = 0 ;
|
|
|
|
if ( ! info_ptr->password_file.empty() )
|
|
{
|
|
unlink(info_ptr->password_file.data());
|
|
daemon_remove_file ( info_ptr->password_file.data() ) ;
|
|
info_ptr->password_file.clear();
|
|
}
|
|
|
|
pthread_signal_handler ( info_ptr );
|
|
|
|
/* Sensor reading specific exit */
|
|
if ( info_ptr->command == IPMITOOL_THREAD_CMD__READ_SENSORS )
|
|
{
|
|
if ( parse_errors )
|
|
{
|
|
wlog_t ("%s exiting with %d parse errors (rc:%d)\n",
|
|
info_ptr->log_prefix, parse_errors, info_ptr->status);
|
|
}
|
|
else
|
|
{
|
|
dlog_t ("%s exit", info_ptr->log_prefix );
|
|
}
|
|
_parse_sensor_data ( info_ptr );
|
|
}
|
|
|
|
info_ptr->progress++ ;
|
|
info_ptr->runcount++ ;
|
|
info_ptr->id = 0 ;
|
|
pthread_exit (&info_ptr->status );
|
|
return NULL ;
|
|
}
|