be_time_watchdog.h

Go to the documentation of this file.

/******************************************************************************
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 ******************************************************************************/
#ifndef __BE_TIME_WATCHDOG_H__
#define __BE_TIME_WATCHDOG_H__
 
#include <csetjmp>
#include <csignal>
 
#include <be_time.h>
#include <be_error_exception.h>
 
#define BEGIN_WATCHDOG_BLOCK(_watchdog, _blockname) do {                \
        if (!(_watchdog)->isEnabled())                                  \
                break;                                                  \
        (_watchdog)->clearExpired();                                    \
        (_watchdog)->clearCanSigJump();                                 \
        if (sigsetjmp(                                                  \
            BiometricEvaluation::Time::Watchdog::_sigJumpBuf, 1) != 0) \
         {                                                              \
                (_watchdog)->setExpired();                              \
                goto _blockname ## _end;                                \
        }                                                               \
        (_watchdog)->setCanSigJump();                                   \
        (_watchdog)->start();                                           \
} while (0)
 
#define END_WATCHDOG_BLOCK(_watchdog, _blockname) do {                  \
        if (!(_watchdog)->isEnabled())                                  \
                break;                                                  \
        _blockname ## _end:                                             \
        (_watchdog)->clearCanSigJump();                                 \
        (_watchdog)->stop();                                            \
} while (0);
 
#define ABORT_WATCHDOG(_watchdog) do {                                  \
        if (!(_watchdog)->isEnabled())                                  \
                break;                                                  \
        (_watchdog)->clearCanSigJump();                                 \
        (_watchdog)->stop();                                            \
} while (0);
 
namespace BiometricEvaluation {
 
        namespace Time {
 
                class Watchdog {
                public:
                        
                        static const uint8_t PROCESSTIME = 0;
                        static const uint8_t REALTIME = 1;
 
                        Watchdog(const uint8_t type);
 
                        uint64_t
                        getInterval()
                            const
                            noexcept;
 
                        void setInterval(uint64_t interval);
 
                        void start();
 
                        void stop();
 
                        bool expired();
 
                        void setCanSigJump();
 
                        void clearCanSigJump();
 
                        void setExpired();
 
                        void clearExpired();
 
                        void setEnabled(
                            const bool enabled);
 
                        bool isEnabled() const;
 
                        /*
                         * Flag indicating can jump after handling a signal,
                         * and the jump buffer used by the signal handler.
                         */
                        static bool _canSigJump;
                        static sigjmp_buf _sigJumpBuf;
 
                protected:
 
                private:
                        /*
                         * Definition of the signal handler, a class method
                         * that will handle all signals managed by this object,
                         * conditionally jumping to a jump block. This jump
                         * capability allows applications to bypass code that
                         * is "hung". Applications should use the
                         * BEGIN_WATCHDOG_BLOCK()/END_WATCHDOG_BLOCK() macro
                         * pair to take advantage of this capability.
                         */
                        static void sighandler(int signo);
 
                        bool _enabled{true};
 
                        /*
                         * Current timer interval.
                         */
                        uint64_t _interval;
 
                        /*
                         * The type of timer.
                         */
                        uint8_t _type;
 
                        /*
                         * Flag indicated that the timer expired.
                         */
                        bool _expired;
 
                        /*
                         * Utility function to map the Watchdog type of alarm
                         * to the system signal number and which system timer.
                         */
                        void internalMapWatchdogType(int *signo, int *which);
                };
                /*
                 * Declaration of the signal handler, a function with C linkage
                 * that will handle the alarm signals sent when a system timer
                 * expires.
                 */
                extern "C" {
                        void WatchdogSignalHandler(int signo, siginfo_t *info,
                            void *uap);
                }
        }
}
#endif  /* __BE_TIME_WATCHDOG_H__ */