Next: Threads and Fork, Previous: Thread-Specific Data, Up: POSIX Threads
pthread_sigmask
changes the signal mask for the calling thread as described by the how and newmask arguments. If oldmask is notNULL
, the previous signal mask is stored in the location pointed to by oldmask.The meaning of the how and newmask arguments is the same as for
sigprocmask
. If how isSIG_SETMASK
, the signal mask is set to newmask. If how isSIG_BLOCK
, the signals specified to newmask are added to the current signal mask. If how isSIG_UNBLOCK
, the signals specified to newmask are removed from the current signal mask.Recall that signal masks are set on a per-thread basis, but signal actions and signal handlers, as set with
sigaction
, are shared between all threads.The
pthread_sigmask
function returns 0 on success, and one of the following error codes on error:
EINVAL
- how is not one of
SIG_SETMASK
,SIG_BLOCK
, orSIG_UNBLOCK
EFAULT
- newmask or oldmask point to invalid addresses
pthread_kill
sends signal number signo to the thread thread. The signal is delivered and handled as described in Signal Handling.
pthread_kill
returns 0 on success, one of the following error codes on error:
EINVAL
- signo is not a valid signal number
ESRCH
- The thread thread does not exist (e.g. it has already terminated)
sigwait
suspends the calling thread until one of the signals in set is delivered to the calling thread. It then stores the number of the signal received in the location pointed to by sig and returns. The signals in set must be blocked and not ignored on entrance tosigwait
. If the delivered signal has a signal handler function attached, that function is not called.
sigwait
is a cancellation point. It always returns 0.
For sigwait
to work reliably, the signals being waited for must be
blocked in all threads, not only in the calling thread, since
otherwise the POSIX semantics for signal delivery do not guarantee
that it's the thread doing the sigwait
that will receive the signal.
The best way to achieve this is block those signals before any threads
are created, and never unblock them in the program other than by
calling sigwait
.
Signal handling in LinuxThreads departs significantly from the POSIX standard. According to the standard, “asynchronous” (external) signals are addressed to the whole process (the collection of all threads), which then delivers them to one particular thread. The thread that actually receives the signal is any thread that does not currently block the signal.
In LinuxThreads, each thread is actually a kernel process with its own
PID, so external signals are always directed to one particular thread.
If, for instance, another thread is blocked in sigwait
on that
signal, it will not be restarted.
The LinuxThreads implementation of sigwait
installs dummy signal
handlers for the signals in set for the duration of the
wait. Since signal handlers are shared between all threads, other
threads must not attach their own signal handlers to these signals, or
alternatively they should all block these signals (which is recommended
anyway).