GNU Info
(libc.info)Threads and Signal Handling
Threads and Signal Handling
===========================
- Function: int pthread_sigmask (int HOW, const sigset_t *NEWMASK,
sigset_t *OLDMASK)
`pthread_sigmask' changes the signal mask for the calling thread as
described by the HOW and NEWMASK arguments. If OLDMASK is not
`NULL', 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 is `SIG_SETMASK', the signal mask is set to
NEWMASK. If HOW is `SIG_BLOCK', the signals specified to NEWMASK
are added to the current signal mask. If HOW is `SIG_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', or `SIG_UNBLOCK'
`EFAULT'
NEWMASK or OLDMASK point to invalid addresses
- Function: int pthread_kill (pthread_t THREAD, int SIGNO)
`pthread_kill' sends signal number SIGNO to the thread THREAD.
The signal is delivered and handled as described in Note: 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)
- Function: int sigwait (const sigset_t *SET, int *SIG)
`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 to `sigwait'. 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).
automatically generated by info2www version 1.2.2.9