signals.h File Reference

Handling signals to abort operation. More...

Go to the source code of this file.

Functions
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

Detailed Description

Handling signals to abort operation.

Definition in file signals.h.

Function Documentation

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

user_abort

volatile sig_atomic_t user_abort

extern

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().