#define is_read_lockable(fd, offset, whence, len) \
                        !lock_test(fd, F_RDLCK, offset, whence, len)

See the Comments to Readers at the end of this file for more details on this correction and the following corrections to pages 103-105.

    Signal_rt(SIGRTMAX, sig_rt, &newset);
    Signal_rt(SIGRTMAX - 1, sig_rt, &newset);
    Signal_rt(SIGRTMAX - 2, sig_rt, &newset);

    received signal #46, code = -1, ival = 0
    received signal #46, code = -1, ival = 1
    received signal #46, code = -1, ival = 2
    received signal #47, code = -1, ival = 0
    received signal #47, code = -1, ival = 1
    received signal #47, code = -1, ival = 2
    received signal #48, code = -1, ival = 0
    received signal #48, code = -1, ival = 1
    received signal #48, code = -1, ival = 2

The nine signals are queued and then delivered in the order that we expect: the lowest-numbered-signal first, and for a given signal, the three occurrences are delivered in FIFO order.

     The Solaris 2.6 implementation appears to have a bug.

    signal_rt(int signo, Sigfunc_rt *func, sigset_t *mask)

    act.sa_mask = *mask;    /* signals to block */

The correction is to specify a third argument to our signal_rt function (Figure 5.18) that specifies the set of signals to be blocked while the signal handler is executing. In Figure 5.17 this argument is now specified as &newset, which contains all three of the realtime signals that the test program is generating. The underlying problem is that while the signal numbers of the realtime signals (33 through 48 for Digital Unix) specify their priority with regard to delivery when more than one of the realtime signals is pending (in our example, nine signals with numbers 46, 47, and 48 are all pending when all three signal numbers are unblocked, so the lowest numbered signal is delivered first), what determines whether another signal can then be delivered while that signal handling function is executing is the sa_mask of that signal handling function. Therefore, whenever we are dealing with more than one realtime signal, we must specify an sa_mask value for each of the realtime signal's signal handling function, and that mask should block all remaining realtime signals with a higher number (that is, with a lower priority). The rules of Posix (p. 75 of [IEEE 1996]) guarantee that when multiple realtime signals are pending the lowest numbered is delivered first, but it is our responsibility to then guarantee that a lower priority realtime signal does not interrupt our signal handling function; we do that by specifying an sa_mask value for the signal handling function.

Since we are now blocking all three of the realtime signals in this example from the signal handling function, calling printf as a simple diagnostic tool is probably OK. But a better technique of printing the order in which the signals are delivered is to change Figure 5.17 as follows: First, allocate two globals:

    static volatile siginfo_t  arrival[10];
    static volatile int        nsig;

    static void
    sig_rt(int signo, siginfo_t *info, void *context)
    {
	arrival[nsig++] = *info; /* save info for child to print */
    }

    sleep(3);     /* let all queued signals be delivered */
    for (i = 0; i < nsig; i++) {
        printf("received signal #%d, code = %d, ival = %d\n",
               arrival[i].si_signo, arrival[i].si_code,
               arrival[i].si_value.sival_int);
    }
    exit(0);

    sigset_t  mask;
    int       s;

        /* compute mask of all lower-priority signals */
    Sigemptyset(&mask);
    for (s = signo + 1; s <= SIGRTMAX; s++)
        Sigaddset(&mask, s);
    act.sa_mask = mask;    /* block all lower-priority signals */