signals.c File Reference

Handling signals to abort operation. More...

#include "private.h"

Go to the source code of this file.

Functions
static void	signal_handler (int sig)
void	signals_init (void)
void	signals_block (void)
void	signals_unblock (void)
	Unblock the signals blocked by signals_block(). More...
void	signals_exit (void)

Variables
volatile sig_atomic_t	user_abort = false
static volatile sig_atomic_t	exit_signal = 0
static sigset_t	hooked_signals
static bool	signals_are_initialized = false
static size_t	signals_block_count = 0
	signals_block() and signals_unblock() can be called recursively. More...

Detailed Description

Handling signals to abort operation.

Definition in file signals.c.

Function Documentation

signal_handler()

static void signal_handler ( int  sig )

static

Definition at line 40 of file signals.c.

{
    exit_signal = sig;
    user_abort = true;
 
#ifndef TUKLIB_DOSLIKE
    io_write_to_user_abort_pipe();
#endif
 
    return;
}

References exit_signal, io_write_to_user_abort_pipe(), and user_abort.

Referenced by signals_init().

signals_block()

void signals_block

(

void

)

Block the signals which don't have SA_RESTART and which would just set user_abort to true. This is handy when we don't want to handle EINTR and don't want SA_RESTART either.

Definition at line 120 of file signals.c.

{
    if (signals_are_initialized) {
        if (signals_block_count++ == 0) {
            const int saved_errno = errno;
            mythread_sigmask(SIG_BLOCK, &hooked_signals, NULL);
            errno = saved_errno;
        }
    }
 
    return;
}

References hooked_signals, mythread_sigmask(), NULL, signals_are_initialized, and signals_block_count.

Referenced by io_close(), io_open_dest(), io_open_src(), io_open_src_real(), message_progress_update(), print_filename(), progress_flush(), and vmessage().

signals_exit()

void signals_exit

(

void

)

If user has sent us a signal earlier to terminate the process, re-raise that signal to actually terminate the process.

Definition at line 153 of file signals.c.

{
    const int sig = (int)exit_signal;
 
    if (sig != 0) {
#if defined(TUKLIB_DOSLIKE) || defined(__VMS)
        // Don't raise(), set only exit status. This avoids
        // printing unwanted message about SIGINT when the user
        // presses C-c.
        set_exit_status(E_ERROR);
#else
        struct sigaction sa;
        sa.sa_handler = SIG_DFL;
        sigfillset(&sa.sa_mask);
        sa.sa_flags = 0;
        sigaction(sig, &sa, NULL);
        raise(sig);
#endif
    }
 
    return;
}

References E_ERROR, exit_signal, int, NULL, and set_exit_status().

Referenced by main().

signals_init()

void signals_init

(

void

)

Initialize the signal handler, which will set user_abort to true when user e.g. presses C-c.

Definition at line 54 of file signals.c.

{
    // List of signals for which we establish the signal handler.
    static const int sigs[] = {
        SIGINT,
        SIGTERM,
#ifdef SIGHUP
        SIGHUP,
#endif
#ifdef SIGPIPE
        SIGPIPE,
#endif
#ifdef SIGXCPU
        SIGXCPU,
#endif
#ifdef SIGXFSZ
        SIGXFSZ,
#endif
    };
 
    // Mask of the signals for which we have established a signal handler.
    sigemptyset(&hooked_signals);
    for (size_t i = 0; i < ARRAY_SIZE(sigs); ++i)
        sigaddset(&hooked_signals, sigs[i]);
 
#ifdef SIGALRM
    // Add also the signals from message.c to hooked_signals.
    for (size_t i = 0; message_progress_sigs[i] != 0; ++i)
        sigaddset(&hooked_signals, message_progress_sigs[i]);
#endif
 
    // Using "my_sa" because "sa" may conflict with a sockaddr variable
    // from system headers on Solaris.
    struct sigaction my_sa;
 
    // All the signals that we handle we also blocked while the signal
    // handler runs.
    my_sa.sa_mask = hooked_signals;
 
    // Don't set SA_RESTART, because we want EINTR so that we can check
    // for user_abort and cleanup before exiting. We block the signals
    // for which we have established a handler when we don't want EINTR.
    my_sa.sa_flags = 0;
    my_sa.sa_handler = &signal_handler;
 
    for (size_t i = 0; i < ARRAY_SIZE(sigs); ++i) {
        // If the parent process has left some signals ignored,
        // we don't unignore them.
        struct sigaction old;
        if (sigaction(sigs[i], NULL, &old) == 0
                && old.sa_handler == SIG_IGN)
            continue;
 
        // Establish the signal handler.
        if (sigaction(sigs[i], &my_sa, NULL))
            message_signal_handler();
    }
 
    signals_are_initialized = true;
 
    return;
}

References ARRAY_SIZE, hooked_signals, i, message_progress_sigs, message_signal_handler(), NULL, SIGHUP, signal_handler(), and signals_are_initialized.

Referenced by main().

signals_unblock()

void signals_unblock

(

void

)

Unblock the signals blocked by signals_block().

Definition at line 135 of file signals.c.

{
    if (signals_are_initialized) {
        assert(signals_block_count > 0);
 
        if (--signals_block_count == 0) {
            const int saved_errno = errno;
            mythread_sigmask(SIG_UNBLOCK, &hooked_signals, NULL);
            errno = saved_errno;
        }
    }
 
    return;
}

References assert(), hooked_signals, mythread_sigmask(), NULL, signals_are_initialized, and signals_block_count.

Referenced by io_close(), io_open_dest(), io_open_src(), io_open_src_real(), message_progress_update(), print_filename(), progress_flush(), and vmessage().

Variable Documentation

exit_signal

volatile sig_atomic_t exit_signal = 0

static

If we were interrupted by a signal, we store the signal number so that we can raise that signal to kill the program when all cleanups have been done.

Definition at line 24 of file signals.c.

Referenced by signal_handler(), and signals_exit().

hooked_signals

sigset_t hooked_signals

static

Mask of signals for which we have established a signal handler to set user_abort to true.

Definition at line 28 of file signals.c.

Referenced by signals_block(), signals_init(), and signals_unblock().

signals_are_initialized

bool signals_are_initialized = false

static

True once signals_init() has finished. This is used to skip blocking signals (with uninitialized hooked_signals) if signals_block() and signals_unblock() are called before signals_init() has been called.

Definition at line 33 of file signals.c.

Referenced by signals_block(), signals_init(), and signals_unblock().

signals_block_count

size_t signals_block_count = 0

static

signals_block() and signals_unblock() can be called recursively.

Definition at line 36 of file signals.c.

Referenced by signals_block(), and signals_unblock().

user_abort

volatile sig_atomic_t user_abort = false

If this is true, we will clean up the possibly incomplete output file, return to main() as soon as practical. That is, the code needs to poll this variable in various places.

Definition at line 16 of file signals.c.

Referenced by coder_normal(), coder_passthru(), coder_run(), io_read(), io_wait(), io_write_buf(), main(), read_name(), and signal_handler().