Thread: Wrapping sigaction() in loop until != EINTR;

Hi,
In another thread brewbuck pointed out that sigaction() may return EINTR and that all such calls should be wrapped in a loop to retry until they no longer return EINTR. The code being discussed was as follows:

Code:

    sa.sa_handler = sigchld_handler; // reap all dead processes
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(1);
    }

The loop I came up with looks like this:

Code:

    sa.sa_handler = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    while (1) {
    if (sigaction(SIGCHLD, &sa, NULL) == EINTR) {
        continue;
    } else
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit (EXIT_FAILURE);
    }
    else break;
    }

I do not mean to second guess brewbuck, however, after reading several sources [1][2][3] I am officially confused.

Originally Posted by [1]

Macro: int SA_RESTART
This flag controls what happens when a signal is delivered during certain primitives (such as open, read or write), and the signal handler returns normally. There are two alternatives: the library function can resume, or it can return failure with error code EINTR.
The choice is controlled by the SA_RESTART flag for the particular kind of signal that was delivered. If the flag is set, returning from a handler resumes the library function. If the flag is clear, returning from a handler makes the function fail.

Originally Posted by [2]

BSD avoids EINTR entirely and provides a more convenient approach: to restart the interrupted primitive, instead of making it fail. If you choose this approach, you need not be concerned with EINTR.
You can choose either approach with the GNU library. If you use sigaction to establish a signal handler, you can specify how that handler should behave. If you specify the SA_RESTART flag, return from that handler will resume a primitive; otherwise, return from that handler will cause EINTR.

Originally Posted by [3]

If a signal is caught during the system calls listed below, the call may
be forced to terminate with the error EINTR, the call may return with a
data transfer shorter than requested, or the call may be restarted.
Restart of pending calls is requested by setting the SA_RESTART bit in
sa_flags. The affected system calls include open(2), read(2), write(2),
sendto(2), recvfrom(2), sendmsg(2) and recvmsg(2) on a communications
channel or a slow device (such as a terminal, but not a regular file) and
during a wait(2) or ioctl(2). However, calls that have already committed
are not restarted, but instead return a partial success (for example, a
short read count).

While having some trouble understanding the precise meaning of the above, that last sentence of [3] makes me doubt if sa.sa_flags = SA_RESTART; is a safe enough / satisfactory solution or that a loop until != EINTR is the right thing to do.
Will SA_RESTART properly guard over interupted system calls?

Thanks,
heras

[1] http://www.delorie.com/gnu/docs/glibc/libc_485.html
[2] http://www.delorie.com/gnu/docs/glibc/libc_498.html
[3] http://www.hmug.org/man/2/sigaction.php

SA_RESTART is a BSD-ism that should not be relied upon, probably not even on BSD! Linux support for it is flaky at best.

Like Salem says, understand and use the native behaviors. Wrapping syscalls in EINTR loops is required on systems which don't support syscall restarting, and harmless on systems which do. In general it is good practice.

If you find it annoying writing all these loops all the time, then don't -- write wrapper functions for the syscalls you are using which do the loops for you.

Originally Posted by heras

Code:

    while (1) {
    if (sigaction(SIGCHLD, &sa, NULL) == EINTR) {
        continue;
    } else
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit (EXIT_FAILURE);
    }
    else break;
    }

That loop isn't right, because sigaction() doesn't actually return EINTR -- it returns -1, and sets errno to EINTR. A better loop:

Code:

int ret;
while((ret = sigaction(SIGCHLD, &sa, NULL)) < 0 && errno == EINTR)
    ;
if(ret < 0)
{
    /* There was an error */
}

Of course, a bug in this kind of code might never be found, because it is highly unlikely that sigaction() will actually fail in this way. This is another reason to wrap functions instead of coding loops everywhere -- less chance of screwing it up.

I didn't realize the implementation difference, I'll stick to linux only man-pages from now on. And I'll try putting sigaction() in a wrapper function.
Thank you both for the clarification.
Cheers,
heras