LoggerSignals.c

/*
 *  Copyright (C) 2023 Swansea University
 *
 *  This file is part of the SELKIELogger suite of tools.
 *
 *  SELKIELogger is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the Free
 *  Software Foundation, either version 3 of the License, or (at your option)
 *  any later version.
 *
 *  SELKIELogger is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 *  more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this SELKIELogger product.
 *  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include <pthread.h>
 
#include "Logger.h"
 
#include "LoggerSignals.h"
 
atomic_bool shutdownFlag = false;
 
atomic_bool rotateNow = false;
 
atomic_bool pauseLog = false;
 
void signalShutdown(int signnum __attribute__((unused))) {
    shutdownFlag = true;
}
 
void signalRotate(int signnum __attribute__((unused))) {
    rotateNow = true;
}
 
void signalPause(int signnum __attribute__((unused))) {
    pauseLog = true;
}
 
void signalUnpause(int signnum __attribute__((unused))) {
    pauseLog = false;
}
 
void signalHandlersInstall() {
    sigset_t *hMask = signalHandlerMask();
 
    /*
     * While handling pause, unpause and rotate signals, we still want to
     * pay attention to shutdown requests. As it doesn't matter if multiple
     * shutdown signals are received, we just clear the mask for SIGINT and
     * SIGQUIT.
     */
    sigdelset(hMask, SIGINT);
    sigdelset(hMask, SIGQUIT);
 
    const struct sigaction saShutdown = {
        .sa_handler = signalShutdown, .sa_mask = *hMask, .sa_flags = SA_RESTART};
    const struct sigaction saRotate = {
        .sa_handler = signalRotate, .sa_mask = *hMask, .sa_flags = SA_RESTART};
    const struct sigaction saPause = {
        .sa_handler = signalPause, .sa_mask = *hMask, .sa_flags = SA_RESTART};
    const struct sigaction saUnpause = {
        .sa_handler = signalUnpause, .sa_mask = *hMask, .sa_flags = SA_RESTART};
 
    // As well as the "standard" signals, we use SIGRTMIN+n to make each handler
    // available directly
 
    // Shutdown signalled on SIGINT and SIGQUIT (standard) and SIGRTMIN+1
    sigaction(SIGINT, &saShutdown, NULL);
    sigaction(SIGQUIT, &saShutdown, NULL);
    sigaction(SIGRTMIN + 1, &saShutdown, NULL);
 
    // Log rotate on common signals (SIGUSR1, SIGHUP) and SIGRTMIN+2
    sigaction(SIGUSR1, &saRotate, NULL);
    sigaction(SIGHUP, &saRotate, NULL);
    sigaction(SIGRTMIN + 2, &saRotate, NULL);
 
    /*
     * There isn't really a standard pause/resume signals except SIGSTOP/CONT which
     * the system handles (and is somewhat more forceful). We use SIGRTMIN+3 and +4
     * for pause and unpause respectively
     */
    sigaction(SIGRTMIN + 3, &saPause, NULL);
    sigaction(SIGRTMIN + 4, &saUnpause, NULL);
 
    free(hMask);
}
 
sigset_t *signalHandlerMask() {
    sigset_t *blocking = calloc(1, sizeof(sigset_t));
 
    sigemptyset(blocking);
    sigaddset(blocking, SIGINT);
    sigaddset(blocking, SIGQUIT);
    sigaddset(blocking, SIGUSR1);
    sigaddset(blocking, SIGHUP);
    sigaddset(blocking, SIGRTMIN + 1);
    sigaddset(blocking, SIGRTMIN + 2);
    sigaddset(blocking, SIGRTMIN + 3);
    sigaddset(blocking, SIGRTMIN + 4);
    return blocking;
}
 
void signalHandlersBlock() {
    sigset_t *hMask = signalHandlerMask();
    pthread_sigmask(SIG_BLOCK, hMask, NULL);
    free(hMask);
}
 
void signalHandlersUnblock() {
    sigset_t *hMask = signalHandlerMask();
    pthread_sigmask(SIG_UNBLOCK, hMask, NULL);
    free(hMask);
}