423 lines
14 KiB
C++
423 lines
14 KiB
C++
/*
|
|
* Copyright (c) 2013, 2016 Wind River Systems, Inc.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* Wind River CGCS Platform common Alarm utilities
|
|
*/
|
|
|
|
#include "daemon_common.h" /* for ... daemon_is_file_present */
|
|
|
|
#include "nodeBase.h"
|
|
#include "nodeUtil.h" /* for ... get_mtclogd_sockPtr */
|
|
#include "alarmUtil.h" /* for ... alarmUtilClass and Utilities */
|
|
|
|
|
|
alarmUtilClass __alarmObject ;
|
|
|
|
/* module init */
|
|
void alarmUtil_init ( void )
|
|
{
|
|
snprintf ( &__alarmObject.varlog_filename[0], MAX_FILENAME_LEN, "/var/log/%s_alarm.log",
|
|
program_invocation_short_name );
|
|
}
|
|
|
|
/********************** alarmUtilClass API Implementation ************************/
|
|
|
|
alarmUtilClass::alarmUtilClass()
|
|
{
|
|
temp_str[0] = '\0';
|
|
varlog_filename[0] = '\0';
|
|
//ilog ("class constructor\n");
|
|
alarmUtil_init ();
|
|
}
|
|
|
|
alarmUtilClass::~alarmUtilClass()
|
|
{
|
|
// ilog ("class destructor\n");
|
|
}
|
|
|
|
/***************************** Open API Implementation ***************************/
|
|
|
|
string alarmUtil_getSev_str ( EFmAlarmSeverityT sev )
|
|
{
|
|
switch ( sev )
|
|
{
|
|
case FM_ALARM_SEVERITY_CLEAR: return ("clear");
|
|
case FM_ALARM_SEVERITY_WARNING: return ("warning");
|
|
case FM_ALARM_SEVERITY_MINOR: return ("minor");
|
|
case FM_ALARM_SEVERITY_MAJOR: return ("major");
|
|
case FM_ALARM_SEVERITY_CRITICAL:return ("critical");
|
|
default : return ("unknown");
|
|
}
|
|
}
|
|
|
|
EFmAlarmSeverityT alarmUtil_getSev_enum ( string sev )
|
|
{
|
|
if ( !sev.compare("clear")) return (FM_ALARM_SEVERITY_CLEAR) ;
|
|
if ( !sev.compare("warning")) return (FM_ALARM_SEVERITY_WARNING);
|
|
if ( !sev.compare("minor")) return (FM_ALARM_SEVERITY_MINOR);
|
|
if ( !sev.compare("major")) return (FM_ALARM_SEVERITY_MAJOR);
|
|
if ( !sev.compare("critical")) return (FM_ALARM_SEVERITY_CRITICAL);
|
|
wlog ("Unsupported severity '%s'\n", sev.c_str() );
|
|
return (FM_ALARM_SEVERITY_CLEAR) ;
|
|
}
|
|
|
|
|
|
/* update the passed in alarm struct's instance_id entity path for the specified host */
|
|
void _build_entity_path ( string & hostname, string & instance, SFmAlarmDataT & alarm )
|
|
{
|
|
snprintf ( &alarm.entity_type_id[0], FM_MAX_BUFFER_LENGTH, "system.host" );
|
|
|
|
if ( instance.empty() )
|
|
{
|
|
snprintf ( &alarm.entity_instance_id[0], FM_MAX_BUFFER_LENGTH, "%s%s",
|
|
ENTITY_PREFIX, hostname.data());
|
|
}
|
|
else
|
|
{
|
|
snprintf ( &alarm.entity_instance_id[0], FM_MAX_BUFFER_LENGTH, "%s%s.%s",
|
|
ENTITY_PREFIX, hostname.data(), instance.data());
|
|
}
|
|
}
|
|
|
|
void alarmUtil_clear_all ( string hostname )
|
|
{
|
|
SFmAlarmDataT alarm ;
|
|
string instance = "" ;
|
|
|
|
_build_entity_path ( hostname, instance, alarm );
|
|
|
|
/* This will clear all the alarms for this host ;
|
|
* even ones that are raised against this host by other daemons */
|
|
fm_clear_all_async ( &alarm.entity_instance_id );
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Name : alarmUtil_query
|
|
*
|
|
* Description: Utility will query a specific alarm for its current severity
|
|
*
|
|
* @param : identity may be 200.xxx
|
|
*
|
|
* @param : instance may be
|
|
*
|
|
* host=<hostname>
|
|
*
|
|
* example:
|
|
*
|
|
* hostname=compute-1
|
|
*
|
|
* host=<hostname>.<function>=<specific>
|
|
*
|
|
* example:
|
|
*
|
|
* hostname=compute-1.process=mtcClient
|
|
*
|
|
* hostname=compute-1.sensor=Fan_PSU2
|
|
*
|
|
* Updates : None
|
|
*
|
|
* Returns : FM severity code for the specified alarm.
|
|
* FM_ALARM_SEVERITY_CLEAR if it not set.
|
|
*
|
|
******************************************************************************/
|
|
EFmAlarmSeverityT alarmUtil_query ( string & hostname,
|
|
string & identity,
|
|
string & instance )
|
|
{
|
|
SFmAlarmDataT alarm_query ;
|
|
AlarmFilter alarm_filter ;
|
|
EFmErrorT rc ;
|
|
|
|
memset(&alarm_query, 0, sizeof(alarm_query));
|
|
memset(&alarm_filter, 0, sizeof(alarm_filter));
|
|
|
|
snprintf ( &alarm_filter.alarm_id[0], FM_MAX_BUFFER_LENGTH, "%s", identity.data());
|
|
|
|
if ( instance.empty() )
|
|
{
|
|
snprintf ( &alarm_filter.entity_instance_id[0], FM_MAX_BUFFER_LENGTH, "%s%s",
|
|
ENTITY_PREFIX, hostname.data());
|
|
}
|
|
else
|
|
{
|
|
snprintf ( &alarm_filter.entity_instance_id[0], FM_MAX_BUFFER_LENGTH, "%s%s.%s",
|
|
ENTITY_PREFIX, hostname.data(), instance.data());
|
|
}
|
|
|
|
alog1 ("entity_instance:%s\n", alarm_filter.entity_instance_id );
|
|
if (( rc = fm_get_fault ( &alarm_filter, &alarm_query )) == FM_ERR_OK )
|
|
{
|
|
dlog ("Found with Severity: %d\n", alarm_query.severity );
|
|
return (alarm_query.severity) ;
|
|
}
|
|
else if ( rc != FM_ERR_ENTITY_NOT_FOUND )
|
|
{
|
|
elog ("%s fm_get_fault returned error (%d)\n", hostname.c_str(), rc );
|
|
}
|
|
return (FM_ALARM_SEVERITY_CLEAR);
|
|
}
|
|
|
|
int alarmUtil_query_identity ( string identity, SFmAlarmDataT * alarm_list_ptr, unsigned int max_alarms )
|
|
{
|
|
int rc = 0 ;
|
|
|
|
if ( max_alarms == 0 )
|
|
{
|
|
slog ("max alarms is zero !\n");
|
|
}
|
|
else if ( identity.empty() )
|
|
{
|
|
slog ("empty alarm 'identity'\n");
|
|
}
|
|
else if ( alarm_list_ptr )
|
|
{
|
|
AlarmFilter alarm_filter ;
|
|
|
|
memset(&alarm_filter, 0, sizeof(alarm_filter));
|
|
snprintf ( alarm_filter.alarm_id, FM_MAX_BUFFER_LENGTH, "%s", identity.data());
|
|
rc = fm_get_faults_by_id ( &alarm_filter.alarm_id, alarm_list_ptr, &max_alarms );
|
|
alog1 ("%s fm_get_faults_by_id rc = %d\n", alarm_filter.alarm_id, rc );
|
|
if ( rc == FM_ERR_OK )
|
|
{
|
|
return (PASS);
|
|
}
|
|
else if ( rc == FM_ERR_ENTITY_NOT_FOUND )
|
|
{
|
|
return (RETRY);
|
|
}
|
|
else
|
|
{
|
|
return (FAIL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
slog ("caller supplied null alarm_list_ptr\n");
|
|
}
|
|
return (FAIL_NULL_POINTER);
|
|
}
|
|
|
|
|
|
/*********************************************************************************
|
|
*
|
|
* Name : alarmUtil
|
|
*
|
|
* Purpose : Primary module API used to set/clear severity alarms and logs in FM.
|
|
*
|
|
* Description : Other maintenance services are expected to use ths interface to
|
|
*
|
|
*
|
|
********************************************************************************/
|
|
int alarmUtil ( string & hostname,
|
|
string & identity,
|
|
string & instance,
|
|
SFmAlarmDataT & alarm )
|
|
{
|
|
int rc = PASS ;
|
|
|
|
// msgSock_type * mtclogd_ptr = get_mtclogd_sockPtr() ;
|
|
|
|
/* Don't report events while we are in reset mode */
|
|
if ( daemon_is_file_present ( NODE_RESET_FILE ) )
|
|
{
|
|
return (rc);
|
|
}
|
|
|
|
_build_entity_path ( hostname, instance, alarm );
|
|
|
|
#ifdef WANT_ALARM_QUERY
|
|
|
|
/* See if the alarm is already in the requested state */
|
|
EFmAlarmSeverityT curr_sev = alarmUtil_query ( hostname, identity, instance ) ;
|
|
|
|
/* If its not a log message and we are already at this
|
|
* severity level then ignore the call */
|
|
if (( alarm.alarm_state != FM_ALARM_STATE_MSG ) &&
|
|
( curr_sev == alarm.severity ))
|
|
{
|
|
alog1 ("%s %s %s already at desired (%s) severity level\n",
|
|
hostname.c_str(),
|
|
identity.c_str(),
|
|
instance.c_str(),
|
|
alarmUtil_getSev_str(alarm.severity).c_str());
|
|
return (rc);
|
|
}
|
|
|
|
#endif
|
|
|
|
snprintf(&alarm.alarm_id[0], FM_MAX_BUFFER_LENGTH, "%s", identity.data());
|
|
|
|
if (( alarm.alarm_state == FM_ALARM_STATE_SET ) ||
|
|
( alarm.alarm_state == FM_ALARM_STATE_MSG ))
|
|
{
|
|
if ( alarm.alarm_state == FM_ALARM_STATE_SET )
|
|
{
|
|
alog1 ("%s setting %s %s alarm\n", hostname.c_str(), alarm.alarm_id, alarm.entity_instance_id );
|
|
}
|
|
else
|
|
{
|
|
alog1 ("%s creating %s %s log\n", hostname.c_str(), alarm.alarm_id, alarm.entity_instance_id );
|
|
}
|
|
|
|
/* Debug Logs */
|
|
alog1 ("%s Alarm Reason: %s\n", hostname.c_str(), alarm.reason_text );
|
|
alog1 ("%s Alarm Action: %s\n", hostname.c_str(), alarm.proposed_repair_action );
|
|
alog1 ("%s Alarm Ident : %s : %s\n", hostname.c_str(), alarm.entity_type_id, alarm.entity_instance_id );
|
|
alog1 ("%s Alarm State : state:%d sev:%d type:%d cause:%d sa:%c supp:%c\n",
|
|
hostname.c_str(),
|
|
alarm.alarm_state,
|
|
alarm.severity,
|
|
alarm.alarm_type,
|
|
alarm.probable_cause,
|
|
alarm.service_affecting ? 'Y' : 'N',
|
|
alarm.suppression ? 'Y' : 'N' );
|
|
|
|
snprintf (&__alarmObject.temp_str[0], MAX_API_LOG_LEN-1,
|
|
"\n%s [%5d] fm_set_fault: %s %s state:%d sev:%d type:%d cause:%d sa:%c supp:%c",
|
|
pt(), getpid(), hostname.c_str(), alarm.alarm_id, alarm.alarm_state,
|
|
alarm.severity,
|
|
alarm.alarm_type,
|
|
alarm.probable_cause,
|
|
alarm.service_affecting ? 'Y' : 'N',
|
|
alarm.suppression ? 'Y' : 'N' );
|
|
|
|
//send_log_message ( mtclogd_ptr, hostname.data(), &__alarmObject.varlog_filename[0],
|
|
// &__alarmObject.temp_str[0] );
|
|
|
|
nodeUtil_latency_log ( hostname, NODEUTIL_LATENCY_MON_START , 0 );
|
|
rc = fm_set_fault_async ( &alarm , NULL );
|
|
nodeUtil_latency_log ( hostname, "fm_set_fault - alarm - common" , LATENCY_1SEC );
|
|
|
|
snprintf (&__alarmObject.temp_str[0], MAX_API_LOG_LEN-1,
|
|
"%s [%5d] fm_set_fault: %s returned %d",
|
|
pt(), getpid(), hostname.c_str(), rc );
|
|
|
|
//send_log_message ( mtclogd_ptr, hostname.data(), &__alarmObject.varlog_filename[0],
|
|
// &__alarmObject.temp_str[0] );
|
|
|
|
if ( rc != FM_ERR_OK )
|
|
{
|
|
elog ("%s failed to set alarm %s (rc:%d)\n", hostname.c_str(), alarm.alarm_id, rc);
|
|
rc = FAIL ;
|
|
}
|
|
}
|
|
else // ( alarm.alarm_state == FM_ALARM_STATE_CLEAR )
|
|
{
|
|
AlarmFilter filter ; memset(&filter, 0, sizeof(filter));
|
|
|
|
/* Setup the alarm filter */
|
|
snprintf(filter.alarm_id, FM_MAX_BUFFER_LENGTH, "%s", alarm.alarm_id);
|
|
snprintf(filter.entity_instance_id, FM_MAX_BUFFER_LENGTH, "%s", alarm.entity_instance_id);
|
|
|
|
snprintf (&__alarmObject.temp_str[0], MAX_API_LOG_LEN-1, "\n%s [%5d] fm_clear_fault: %s %s:%s",
|
|
pt(), getpid(), hostname.c_str(), alarm.entity_instance_id, alarm.alarm_id );
|
|
|
|
// send_log_message ( mtclogd_ptr, hostname.data(), &__alarmObject.varlog_filename[0],
|
|
// &__alarmObject.temp_str[0] );
|
|
|
|
alog1 ("%s clearing %s %s alarm\n", hostname.c_str(), alarm.alarm_id, alarm.entity_instance_id);
|
|
nodeUtil_latency_log ( hostname, NODEUTIL_LATENCY_MON_START , 0 );
|
|
if ( ( rc = fm_clear_fault_async ( &filter )) != FM_ERR_OK )
|
|
{
|
|
if ( rc != FM_ERR_ENTITY_NOT_FOUND )
|
|
{
|
|
elog ("%s failed to fm_clear_fault (rc:%d)\n", hostname.c_str(), rc );
|
|
rc = FAIL ;
|
|
}
|
|
}
|
|
nodeUtil_latency_log ( hostname, "fm_clear_fault - common" , LATENCY_1SEC );
|
|
}
|
|
|
|
return (rc);
|
|
}
|
|
|
|
/* Clear the specified hosts's alarm */
|
|
int alarmUtil_clear ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_CLEAR ;
|
|
alarm.alarm_state = FM_ALARM_STATE_CLEAR ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|
|
|
|
/************************* A L A R M I N G **************************/
|
|
|
|
/** Assert a specified hosts's alarm with a CRITICAL severity level */
|
|
int alarmUtil_critical ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_CRITICAL ;
|
|
alarm.alarm_state = FM_ALARM_STATE_SET ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|
|
|
|
/** Assert a specified host's alarm with a MAJOR severity level */
|
|
int alarmUtil_major ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_MAJOR ;
|
|
alarm.alarm_state = FM_ALARM_STATE_SET ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|
|
|
|
/** Assert a specified host's alarm with a MINOR severity level */
|
|
int alarmUtil_minor ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_MINOR ;
|
|
alarm.alarm_state = FM_ALARM_STATE_SET ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|
|
|
|
/** Assert a specified host's mtce alarm with a WARNING severity level */
|
|
int alarmUtil_warning ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_WARNING ;
|
|
alarm.alarm_state = FM_ALARM_STATE_SET ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|
|
|
|
/*************************** L O G G I N G **********************************/
|
|
|
|
/** Create a CRITICAL log */
|
|
int alarmUtil_critical_log ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_CRITICAL ;
|
|
alarm.alarm_state = FM_ALARM_STATE_MSG ;
|
|
return ( alarmUtil ( hostname,identity, instance, alarm ));
|
|
}
|
|
|
|
/** Create a MAJOR log */
|
|
int alarmUtil_major_log ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_MAJOR ;
|
|
alarm.alarm_state = FM_ALARM_STATE_MSG ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|
|
|
|
/** Create a MINOR log */
|
|
int alarmUtil_minor_log ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_MINOR ;
|
|
alarm.alarm_state = FM_ALARM_STATE_MSG ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|
|
|
|
/** Create a WARNING log */
|
|
int alarmUtil_warning_log ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.severity = FM_ALARM_SEVERITY_WARNING ;
|
|
alarm.alarm_state = FM_ALARM_STATE_MSG ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|
|
|
|
/** Create a neutral log */
|
|
int alarmUtil_log ( string hostname, string identity, string instance, SFmAlarmDataT & alarm )
|
|
{
|
|
alarm.alarm_state = FM_ALARM_STATE_MSG ;
|
|
return ( alarmUtil ( hostname, identity, instance, alarm ));
|
|
}
|