Question

I have a thread in an application that has a loop like this:

...
while (1)
{
    checkDatabase();
    checkChildren();

    sleep(3);
}
...

checkDatabase() is self-explanatory; checkChildren() simply calls waitpid(-1, &status, WNOHANG) to deal with child processes that have either exited or received a signal.

The application works fairly well, but it has default signal handling. The problem is that this parent process has a number of threads (don’t worry about child processes for now) and I don’t have any experience with synchronous signals, let alone in a POSIX threads application. I have used signal() before but apparently it’s non-portable and it doesn’t do what I need anyway. I have no experience at all with sigaction methods, and I can’t find good documentation on how to fill in the structs and so on.

What I need to do is to synchronously catch terminating signals like SIGINT, SIGTERM and SIGQUIT in the above loop (and I need to ignore SIGPIPE altogether so that I can catch the EPIPE error from IO methods), so it would look like this:

...
while (1)
{
    checkDatabase();
    checkChildren();
    checkForSignals();

    sleep(3);
}
...

All other threads should not have anything to do with the signal; only the thread that executes this loop should be aware of it. And, obviously, it needs to be a non-blocking check so the loop doesn’t block during its first iteration. The method called if a signal is found will sort out the other threads and destroy mutexes, and all that.

Could anyone please give me a heads-up? Many thanks.

Answer 1

(Following the question’s comments, and for completeness, this solution tries to avoid signal handlers.)

It is possible to block signals from being raised through sigprocmask() (or, rather, pthread_sigmask() since you’re using threads). From there on, the signals that were raised but blocked are available through sigpending().

Therefore, you could do something like (error checking omitted for brevity):

sigset_t blocked;
sigemptyset(&blocked);
sigaddset(&blocked, SIGINT);
sigaddset(&blocked, SIGTERM);
sigaddset(&blocked, SIGQUIT);
pthread_sigmask(SIG_BLOCK, &blocked, NULL); // Block SIGINT, SIGTERM and SIGQUIT.
signal(SIGPIPE, SIG_IGN);                   // Ignore SIGPIPE.

Then, later:

void checkForSignals(void)
{
    sigset_t pending;
    sigpending(&pending);
    if (sigismember(&pending, SIGINT)) {
        // Handle SIGINT...
    }
    if (sigismember(&pending, SIGTERM)) {
        // Handle SIGTERM...
    }
    if (sigismember(&pending, SIGQUIT)) {
        // Handle SIGQUIT...
    }
}

Since sigpending() does not block, this seems to match your requirements.