Watchdog на основе таймеров POSIX

#include "../include/error.h"
#include "../include/watchdog.h"
 
// (с) http://man7.org/linux/man-pages/man2/timer_create.2.html
#define CLOCKID CLOCK_REALTIME
#define SIG SIGRTMIN + 10
 
IWatcher* callback = nullptr;
 
typedef void (*TSigFunc1)(int, siginfo_t *, void *);
typedef void (*TSigFunc2)(int);
TSigFunc1 prev_handler1 = nullptr;
TSigFunc2 prev_handler2 = nullptr;
pid_t current_pid = getpid();
 
void IWatcher::reset()
{
    //
}
 
static void signal_handler(int _sig, siginfo_t * _si, void * _uc)
{
    bool result = false;
    if ((_sig == SIG) && (_si))
    {
        if ((callback) && (_si->si_pid == current_pid))
        {
            //errspace::show_errmsg("caught valid signal");
            //(*callback)(_si);
            result = true;
        }
    }
    if (!result)
    {
        //errspace::show_errmsg("caught invalid signal");
    }
    //if (prev_handler1) prev_handler1(_sig, _si, _uc);
    //if (prev_handler2) prev_handler2(_sig);
    //signal(_sig, SIG_IGN);
}
 
timer_t timerid;
 
bool start_wd(std::size_t _msecs, IWatcher* _cback)
{
   static constexpr auto billion = 1'000'000'000;
   static constexpr auto million = 1'000'000;
   callback = _cback;
   bool result = false;
   struct sigevent sev;
   struct itimerspec its;
   long long freq_nanosecs;
   sigset_t mask;
   struct sigaction sa;
   struct sigaction old_sa;
   // Establish handler for timer signal
   sa.sa_flags = SA_SIGINFO;
   sa.sa_sigaction = signal_handler;
   sigemptyset(&sa.sa_mask);
   if (sigaction(SIG, &sa, &old_sa) == -1)
   {
       errspace::show_errmsg("Failed to setup watchdog: Establish handler");
       return result;
   }
   prev_handler1 =  old_sa.sa_sigaction;
   prev_handler2 =  old_sa.sa_handler;
   // Block timer signal temporarily
   sigemptyset(&mask);
   sigaddset(&mask, SIG);
   if (sigprocmask(SIG_SETMASK, &mask, NULL) == -1)
   {
       errspace::show_errmsg("Failed to setup watchdog: Blocking signal");
       return result;
   }
 
   // Create the timer
   sev.sigev_notify = SIGEV_SIGNAL;
   sev.sigev_signo = SIG;
   sev.sigev_value.sival_ptr = &timerid;
   if (timer_create(CLOCKID, &sev, &timerid) == -1)
   {
       errspace::show_errmsg("Failed to setup watchdog: create timer");
       return result;
   }
 
   // Start the timer
   freq_nanosecs = million*_msecs;
   its.it_value.tv_sec = freq_nanosecs / billion;
   its.it_value.tv_nsec = freq_nanosecs % billion;
   its.it_interval.tv_sec = its.it_value.tv_sec;
   its.it_interval.tv_nsec = its.it_value.tv_nsec;
 
   if (timer_settime(timerid, 0, &its, NULL) == -1)
   {
       errspace::show_errmsg("Failed to setup watchdog: set time");
       return result;
   }
   // ????
   // std::this_thread::sleep_for(std::chrono::milliseconds(_msecs*2));
   /* Sleep for a while; meanwhile, the timer may expire
      multiple times */
 
   //printf("Sleeping for %d seconds\n", atoi(argv[1]));
   //sleep(atoi(argv[1]));
 
   // Unlock the timer signal, so that timer notification can be delivered
   if (sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1)
   {
       errspace::show_errmsg("Failed to setup watchdog: Unblocking signal");
       return result;
   }
    result = true;
    return result;
}
 
void stop_wd()
{
    sigset_t mask;
    struct sigaction action;
 
    // Block timer signal temporarily
    sigemptyset(&mask);
    sigaddset(&mask, SIG);
    if (sigprocmask(SIG_SETMASK, &mask, NULL) == -1)
    {
        errspace::show_errmsg("Failed to reset watchdog: Blocking signal");
        return;
    }
    timer_delete(timerid);
    action.sa_handler = SIG_DFL;
    action.sa_flags   = SA_RESETHAND;
 
    if (sigaction(SIGINT, &action, NULL) == -1)
    {
        errspace::show_errmsg("Failed to reset watchdog: reset handler");
        return;
    }
 
    // Unlock the timer signal, so that timer notification
    //   can be delivered
    if (sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1)
    {
        errspace::show_errmsg("Failed to reset watchdog: Unblocking signal");
        return;
    }
}

#include <iostream>
#include "../include/common.h"
#include "../include/error.h"
#include "../include/watchdog.h"
#include "../include/mng_thread.h"
 
class Watcher : public IWatcher
{
public:
    template<typename ...Args>
    Watcher(Args... _args)
    {
        auto tpack = std::make_tuple(_args...);
    }
protected:
    virtual void operator ()(siginfo_t *si)
    {
        //printf("Caught signal %d\n", sig);
        //print_siginfo(si);
        //#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
        //                           } while (0)
        errspace::show_errmsg("watchdog timeout");
        timer_t tidp;
        int _or;
 
        tidp = si->si_value.sival_ptr;
 
        //printf("    sival_ptr = %p; ", si->si_value.sival_ptr);
        //printf("    *sival_ptr = 0x%lx\n", (long) tidp);
 
        _or = timer_getoverrun(tidp);
        //if (_or == -1)
        //    errExit("timer_getoverrun");
        //else
         //   printf("    overrun count = %d\n", _or);
    }
};
 
int main(int argc, char *argv[])
{
    static Watcher w{};
    IWatcher* iw = &w;
 
    const char * FUNCTION = __FUNCTION__;
    try
    {
        using std::cout;
        using std::cin;
        using std::endl;
        cout << "Server is started" << endl;
        std::string str_command;
        while(1)
        {
            LOG << "enter command:";
            if (std::getline(cin, str_command))
            {
                LOG << "command:" << str_command << " was got";
                if (str_command == "q") break;
                if (str_command == "e") throw 0;
                if (str_command == "s")
                {
                    start_wd(1000, iw );
                }
                if (str_command == "p") stop_wd();
            }
            str_command = "";
        }
    }
    catch (...)
    {
        errspace::show_errmsg(FUNCTION);
    }
    return EXIT_SUCCESS;
}
#endif

MSG msg = { };
while (GetMessage(&msg, NULL, 0, 0))
{
    TranslateMessage(&msg);
    DispatchMessage(&msg);
}

if (timer_delete(m_timerid) == m_error_code);
{
            errspace::show_errmsg("Failed to reset watchdog: delete timer");
}

    void stop_wd()
    {
        if (!is_started) return;
    #ifdef MULTITHREAD
        if (!(main_thread_test.get() == std::this_thread::get_id()))
        {
            assert("stop_wd is called not in main thread");
        }
    #endif
        bool result = false;
    #ifdef POSIX_TIMER
        sigset_t mask;
        struct sigaction action;
        struct itimerspec its;
        // Stop the timer
        its.it_value.tv_sec = 0;
        its.it_value.tv_nsec = 0;
        its.it_interval.tv_sec = 0;
        its.it_interval.tv_nsec = 0;
        // error
        if (timer_delete(m_timerid) == m_error_code);
        {
            errspace::show_errmsg("Failed to reset watchdog: delete timer");
        }
        // Block timer signal temporarily
 
        sigemptyset(&mask);
        sigaddset(&mask, SIG);
        if (sigprocmask(SIG_SETMASK, &mask, nullptr) == m_error_code)
        {
            errspace::show_errmsg("Failed to reset watchdog: Blocking signal");
            return;
        }
 
 
        if (timer_settime(m_timerid, 0, &its, nullptr) == m_error_code)
        {
            errspace::show_errmsg("Failed to setup watchdog: set time");
            return;
        }
 
        //if (timer_delete(timerid) == error_code);
        {
            //errspace::show_errmsg("Failed to reset watchdog: delete timer");
            //return;
        }
 
        action.sa_handler = SIG_DFL;
        action.sa_sigaction = nullptr;//SIG_DFL;
        action.sa_flags   = SA_RESETHAND;
 
        if (sigaction(SIG, &action, nullptr) == m_error_code)
        {
            errspace::show_errmsg("Failed to reset watchdog: reset handler");
            return;
        }
 
        // Unlock the timer signal, so that timer notification
        // can be delivered
 
        if (sigprocmask(SIG_UNBLOCK, &mask, nullptr) == m_error_code)
        {
            errspace::show_errmsg("Failed to reset watchdog: Unblocking signal");
            return;
        }
        //raise(SIG);
    #else
 
    #endif
        is_started = false;
    }

        if (timer_delete(m_timerid) == m_error_code);
        {
            errspace::show_errmsg("Failed to reset watchdog: delete timer");
        }