metal/mtce-common/cgts-mtce-common-1.0/common/nodeTimers.cpp
Dean Troyer 18922761a6 StarlingX open source release updates
Signed-off-by: Dean Troyer <dtroyer@gmail.com>
2018-05-31 07:36:43 -07:00

605 lines
16 KiB
C++
Executable File

/*
* Copyright (c) 2013, 2016 Wind River Systems, Inc.
*
* SPDX-License-Identifier: Apache-2.0
*
*/
/**
* @file
* Wind River CGTS Platform Node Maintenance "Timer Facility"
* Implementation
*/
/**
* @detail
* Detailed description ...
*
* Common timer struct
*
*/
#include "daemon_common.h"
#include "nodeBase.h"
#include "nodeTimers.h"
static int timer_count = 0 ;
int _timer_start ( struct mtc_timer * mtcTimer_ptr,
void (*handler)(int, siginfo_t*, void*),
int secs, int msec )
{
int rc = PASS ;
if ( mtcTimer_ptr == NULL)
{
return (FAIL_NULL_POINTER);
}
mtcTimer_ptr->mutex = true ;
mtcTimer_ptr->ring = true ; /* default to rung for failure path cases */
/* Avoid programming mistake that leads to over-writing
* a seemingly active timer; if .tid is not null then
* cancel that timr first */
if (( mtcTimer_ptr->tid ) && ( timer_count > 0 ))
{
wlog ("%s (%s) called with active timer ; stopping first \n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str());
mtcTimer_stop ( mtcTimer_ptr );
}
if (( handler == NULL ) ||
(( secs == 0 ) && ( msec == 0 )) ||
( secs > MAX_TIMER_DURATION ))
{
elog ("%s (%s) Invalid Duration (%d:%d)\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str(),
secs, msec );
rc = FAIL_BAD_PARM ;
goto _timer_start_out ;
}
/* Clean the timer struct */
memset ( &mtcTimer_ptr->sev, 0, sizeof(struct sigevent));
memset ( &mtcTimer_ptr->value, 0, sizeof(struct itimerspec));
memset ( &mtcTimer_ptr->sa, 0, sizeof(struct sigaction));
/* Setup the timer */
mtcTimer_ptr->sa.sa_flags = SA_SIGINFO;
mtcTimer_ptr->sa.sa_sigaction = handler;
sigemptyset(&mtcTimer_ptr->sa.sa_mask);
if (sigaction(SIGRTMIN, &mtcTimer_ptr->sa, NULL) == -1)
{
elog ("%s (%s) Timer 'set action' (sigaction) failed\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str());
rc = FAIL_TIMER_SET_ACTION ;
goto _timer_start_out ;
}
/* set and enable alarm */
mtcTimer_ptr->sev.sigev_notify = SIGEV_SIGNAL;
mtcTimer_ptr->sev.sigev_signo = SIGRTMIN;
mtcTimer_ptr->sev.sigev_value.sival_ptr = &mtcTimer_ptr->tid;
/* TODO: move up or set block till time is set ? */
mtcTimer_ptr->value.it_value.tv_sec = secs;
mtcTimer_ptr->value.it_value.tv_nsec = (msec*1000000) ;
mtcTimer_ptr->value.it_interval.tv_sec = secs ;
mtcTimer_ptr->value.it_interval.tv_nsec = (msec*1000000) ;
if ( timer_create (CLOCK_REALTIME, &mtcTimer_ptr->sev, &mtcTimer_ptr->tid) == -1 )
{
elog ("%s (%s) Timer 'create' (timer_create) failed (-1)\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str() );
rc = FAIL_TIMER_CREATE ;
goto _timer_start_out ;
}
/* make a backup copy just for fun */
mtcTimer_ptr->secs = secs ;
mtcTimer_ptr->msec = msec ;
timer_count++ ;
/* Set the ring to false DEFORE we start the timer */
mtcTimer_ptr->_guard = 0x12345678 ;
mtcTimer_ptr->guard_ = 0x77654321 ;
mtcTimer_ptr->ring = false ;
if ( timer_settime (mtcTimer_ptr->tid, 0, &mtcTimer_ptr->value, NULL) == -1 )
{
elog ("%s (%s) Timer 'set time' (timer_settime) failed (-1)\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str() );
timer_count-- ;
rc = FAIL_TIMER_SET ;
goto _timer_start_out ;
}
mtcTimer_ptr->active = true ;
/* moved here so that the tid will be valid in the log for debug purposes */
tlog ("%s (%s) Tid:%p with %d.%03d second timeout (count:%d)\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str(),
mtcTimer_ptr->tid,
mtcTimer_ptr->secs,
mtcTimer_ptr->msec,
timer_count );
_timer_start_out:
mtcTimer_ptr->mutex = false ;
return rc ;
}
int mtcTimer_start ( struct mtc_timer & mtcTimer,
void (*handler)(int, siginfo_t*, void*),
int secs )
{
return ( _timer_start ( &mtcTimer, handler, secs, 0 ));
}
int mtcTimer_start_msec ( struct mtc_timer & mtcTimer,
void (*handler)(int, siginfo_t*, void*),
int msec )
{
return ( _timer_start ( &mtcTimer, handler, 0, msec ));
}
int mtcTimer_start ( struct mtc_timer * mtcTimer_ptr,
void (*handler)(int, siginfo_t*, void*),
int secs )
{
return ( _timer_start ( mtcTimer_ptr, handler, secs, 0 ));
}
int mtcTimer_start_sec_msec ( struct mtc_timer * mtcTimer_ptr,
void (*handler)(int, siginfo_t*, void*),
int secs , int msec )
{
return ( _timer_start ( mtcTimer_ptr, handler, secs, msec ));
}
int mtcTimer_start_msec ( struct mtc_timer * mtcTimer_ptr,
void (*handler)(int, siginfo_t*, void*),
int msec )
{
return ( _timer_start ( mtcTimer_ptr, handler, 0, msec ));
}
/*************************************************************************/
int _timer_stop ( struct mtc_timer * mtcTimer_ptr , bool int_safe)
{
int rc = PASS ;
if ( mtcTimer_ptr == NULL)
{
return (FAIL_NULL_POINTER);
}
if ( timer_count == 0 )
{
if ( int_safe == false )
{
elog ("%s (%s) called with no outstanding timers\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str());
}
goto _timer_stop_out ;
}
else if ( mtcTimer_ptr->tid )
{
mtcTimer_ptr->value.it_value.tv_sec = 0;
mtcTimer_ptr->value.it_value.tv_nsec = 0;
mtcTimer_ptr->value.it_interval.tv_sec = 0;
mtcTimer_ptr->value.it_interval.tv_nsec = 0;
if ( timer_settime (mtcTimer_ptr->tid, 0, &mtcTimer_ptr->value, NULL) == -1 )
{
if ( int_safe == false )
{
elog ("%s (%s) timer_settime failed (tid:%p)\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str(),
mtcTimer_ptr->tid );
}
rc = FAIL_TIMER_STOP ;
goto _timer_stop_out ;
}
if ( int_safe == false )
{
tlog ("%s (%s) Tid:%p with %d.%d second timeout (count:%d)\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str(),
mtcTimer_ptr->tid,
mtcTimer_ptr->secs,
mtcTimer_ptr->msec,
timer_count );
}
timer_delete (mtcTimer_ptr->tid);
mtcTimer_ptr->tid = NULL ;
if ( timer_count )
timer_count-- ;
}
else if ( int_safe == false )
{
elog ("%s (%s) called with null TID (count:%d)\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str(),
timer_count);
}
#ifdef WANT_OUTSTANDING_TIMER_COUNT
if ( int_safe == false )
{
tlog ("%s (%s) Outstanding timers: %d\n",
mtcTimer_ptr->hostname.c_str(),
mtcTimer_ptr->service.c_str(),
timer_count );
}
#endif
_timer_stop_out:
mtcTimer_ptr->active = false ;
return rc ;
}
/* Interrupt level safe timer stop utility by pointer */
int mtcTimer_stop_int_safe ( struct mtc_timer * mtcTimer_ptr )
{
return ( _timer_stop ( mtcTimer_ptr, true )) ;
}
/* Interrupt level safe timer stop utility by reference */
int mtcTimer_stop_int_safe ( struct mtc_timer & mtcTimer )
{
return ( _timer_stop ( &mtcTimer, true ) );
}
/* timer stop utility by pointer */
int mtcTimer_stop ( struct mtc_timer * mtcTimer_ptr )
{
return ( _timer_stop ( mtcTimer_ptr, false ) );
}
/* stop utility by reference */
int mtcTimer_stop ( struct mtc_timer & mtcTimer )
{
return ( _timer_stop ( &mtcTimer , false ));
}
bool mtcTimer_expired ( struct mtc_timer & mtcTimer )
{
if (( mtcTimer.ring == true ) ||
( mtcTimer.active == false ) ||
( mtcTimer.tid == NULL ))
{
return (true);
}
return (false);
}
bool mtcTimer_expired ( struct mtc_timer * mtcTimer_ptr )
{
if ( mtcTimer_ptr )
{
if (( mtcTimer_ptr->ring == true ) ||
( mtcTimer_ptr->active == false ) ||
( mtcTimer_ptr->tid == NULL ))
{
return (true);
}
}
return (false);
}
void mtcTimer_reset ( struct mtc_timer & mtcTimer )
{
if ( mtcTimer.tid )
_timer_stop ( &mtcTimer , false );
if ( mtcTimer.active )
mtcTimer.active = false ;
mtcTimer.ring = false ;
}
void mtcTimer_reset ( struct mtc_timer * mtcTimer_ptr )
{
if ( mtcTimer_ptr )
{
if ( mtcTimer_ptr->tid )
_timer_stop ( mtcTimer_ptr , false );
if ( mtcTimer_ptr->active )
mtcTimer_ptr->active = false ;
mtcTimer_ptr->ring = false ;
}
}
/*************************************************************************
*
* Issue: These static vars record unknown/stale timer data.
* The time of the ring, the TID, and the number of outstanding
* timers at that time. They are defaulted to zero and should
* remain that way. The mtcTimer_dump_data utility can be
* called periodically by a process audit, will create a Swerr
* log with the recorded data and then clear the these vars only
* to allow the next occurance to be recorded and loged on the
* next audit interval.
*
**************************************************************************/
static timer_t * stale_tid_ptr = NULL ;
static string stale_tid_time = "" ;
static int stale_tid_count = 0 ;
/* Dump the mtcTimer data - currently only dumps stale data */
void mtcTimer_dump_data ( void )
{
if ( stale_tid_ptr )
{
slog ("Unknown timer fired at '%s' with tid '%p' ; module has %d loaded timers\n",
stale_tid_time.c_str(),
stale_tid_ptr,
stale_tid_count );
stale_tid_ptr = NULL ;
stale_tid_time.clear() ;
stale_tid_count = 0 ;
}
}
int _timer_stop_tid ( timer_t * tid_ptr , bool int_safe )
{
int rc = PASS ;
#ifdef UNUSED
UNUSED (int_safe);
#endif
/*********************************************************************
*
* Issue reported a segfault that was a result of trying to cancel
* a timer based on a stale/unknown TID. Its better to record the error
* and leave the timer alone than to try and cancel and get a segfault.
*
* This update records the fact that this condition has happened only
* to be logged by the host process with a call to mtcTimer_dump_data
* and debugged after-the-fact.
*
**********************************************************************/
if ( stale_tid_ptr == NULL )
{
stale_tid_ptr = tid_ptr ;
stale_tid_time = pt();
stale_tid_count = timer_count ;
}
/* This defined out due to potential for segfault */
#ifdef WANT_TIMER_STOP_BY_ID
if ( tid_ptr )
{
struct mtc_timer ghostTimer ;
ghostTimer.value.it_value.tv_sec = 0;
ghostTimer.value.it_value.tv_nsec = 0;
ghostTimer.value.it_interval.tv_sec = 0;
ghostTimer.value.it_interval.tv_nsec = 0;
if ( timer_settime (*tid_ptr, 0, &ghostTimer.value, NULL) == -1 )
{
if ( int_safe == false )
{
elog ("ghostTimer stop (timer_settime) failed\n");
}
rc = FAIL_TIMER_STOP ;
goto _timer_stop_tid_out ;
}
timer_delete (*tid_ptr);
if ( timer_count )
timer_count-- ;
}
else if ( int_safe == false )
{
elog ("called with NULL TID (%d)\n", timer_count);
}
if ( int_safe == false )
{
tlog ("Remaining outstanding timers: %d\n", timer_count );
}
_timer_stop_tid_out:
#endif
return rc ;
}
int mtcTimer_stop_tid ( timer_t * tid_ptr )
{
return (_timer_stop_tid ( tid_ptr , false ));
}
int mtcTimer_stop_tid_int_safe ( timer_t * tid_ptr )
{
return (_timer_stop_tid ( tid_ptr , true ));
}
/*************************************************************************/
void _timer_init ( struct mtc_timer * mtcTimer_ptr , string hostname, string service )
{
if ( mtcTimer_ptr == NULL)
{
return ;
}
if ( hostname.empty() )
mtcTimer_ptr->hostname = "unset_hostname" ;
else
mtcTimer_ptr->hostname = hostname ;
if ( service.empty() )
mtcTimer_ptr->service = "unset_service" ;
else
mtcTimer_ptr->service = service ;
if (( mtcTimer_ptr->init == TIMER_INIT_SIGNATURE ) && ( mtcTimer_ptr->tid != NULL ))
{
slog ("%s '%s' service is unexpectedly re-initializated ; stopping active timer\n",
hostname.c_str(),
mtcTimer_ptr->service.c_str());
mtcTimer_reset ( mtcTimer_ptr );
}
tlog ("%s '%s' service initialized (%p)\n",
hostname.c_str(),
mtcTimer_ptr->service.c_str(),
mtcTimer_ptr->tid) ;
mtcTimer_ptr->init = TIMER_INIT_SIGNATURE ;
mtcTimer_ptr->tid = NULL ;
mtcTimer_ptr->secs = 0 ;
mtcTimer_ptr->msec = 0 ;
mtcTimer_ptr->ring = false ;
mtcTimer_ptr->active= false ;
mtcTimer_ptr->error = false ;
mtcTimer_ptr->mutex = false ;
}
/* Init / clean a user timer */
void _timer_fini ( struct mtc_timer * mtcTimer_ptr )
{
mtcTimer_reset ( mtcTimer_ptr );
mtcTimer_ptr->init = 0 ;
}
/* de-init a user timer */
void mtcTimer_fini ( struct mtc_timer & mtcTimer )
{
_timer_fini (&mtcTimer );
}
/* de-init a user timer */
void mtcTimer_fini ( struct mtc_timer* mtcTimer_ptr )
{
_timer_fini ( mtcTimer_ptr );
}
/* Init / clean a user timer */
void mtcTimer_init ( struct mtc_timer * mtcTimer_ptr )
{
_timer_init ( mtcTimer_ptr, "" , "" );
}
/* Init / clean a user timer */
void mtcTimer_init ( struct mtc_timer * mtcTimer_ptr , string hostname, string service)
{
_timer_init ( mtcTimer_ptr, hostname , service );
}
/* Init / clean a user timer */
void mtcTimer_init ( struct mtc_timer & mtcTimer )
{
_timer_init (&mtcTimer, "", "" );
}
/* Init / clean a user timer */
void mtcTimer_init ( struct mtc_timer & mtcTimer , string hostname )
{
_timer_init (&mtcTimer, hostname, "" );
}
/* Init / clean a user timer */
void mtcTimer_init ( struct mtc_timer & mtcTimer , string hostname, string service )
{
_timer_init (&mtcTimer, hostname, service );
}
/* Wait Utilities - only use during init */
static struct mtc_timer waitTimer ;
static void waitTimer_handler ( int sig, siginfo_t *si, void *uc)
{
timer_t * tid_ptr = (void**)si->si_value.sival_ptr ;
/* Avoid compiler errors/warnings for parms we must
* have but currently do nothing with */
UNUSED(sig);
UNUSED(uc);
if ( !(*tid_ptr) )
{
return ;
}
/* is base mtc timer */
else if (( *tid_ptr == waitTimer.tid ) )
{
waitTimer.ring = true ;
mtcTimer_stop ( waitTimer );
}
else
{
wlog ("Unexpected timer (%p)\n", *tid_ptr );
mtcTimer_stop_tid ( tid_ptr );
}
}
void mtcWait_msecs ( int millisecs )
{
if ( waitTimer.init != TIMER_INIT_SIGNATURE )
mtcTimer_init ( waitTimer , "localhost", "mtcWait_msecs" );
if ( millisecs > 999 )
{
wlog ("Wait request too long, rounding down to 999\n");
millisecs = 999 ;
}
mtcTimer_start_msec ( waitTimer, waitTimer_handler, millisecs );
do
{
usleep (1000);
daemon_signal_hdlr ();
} while ( waitTimer.ring == false ) ;
}
void mtcWait_secs ( int secs )
{
if ( waitTimer.init != TIMER_INIT_SIGNATURE )
mtcTimer_init ( waitTimer , "localhost", "mtcWait_secs" );
mtcTimer_start ( waitTimer, waitTimer_handler, secs );
do
{
sleep (1);
daemon_signal_hdlr ();
} while ( waitTimer.ring == false ) ;
}
void mtcTimer_mem_log ( void )
{
char str [64] ;
sprintf ( str, "Working Timers: %d\n", timer_count );
mem_log ( str );
}