1996-01-22 00:23:58 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 1995 John Birrell <jb@cimlogic.com.au>.
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
|
* are met:
|
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
|
* This product includes software developed by John Birrell.
|
|
|
|
|
* 4. Neither the name of the author nor the names of any co-contributors
|
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
|
* without specific prior written permission.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
1999-08-05 12:15:30 +00:00
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
1996-01-22 00:23:58 +00:00
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
|
*
|
1999-08-28 00:22:10 +00:00
|
|
|
* $FreeBSD$
|
1996-01-22 00:23:58 +00:00
|
|
|
*/
|
2005-09-01 15:21:23 +00:00
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/signalvar.h>
|
1996-01-22 00:23:58 +00:00
|
|
|
#include <errno.h>
|
|
|
|
|
#include <pthread.h>
|
2005-09-01 15:21:23 +00:00
|
|
|
#include <signal.h>
|
2003-04-18 05:04:16 +00:00
|
|
|
#include <string.h>
|
2005-09-01 15:21:23 +00:00
|
|
|
|
2002-09-16 08:45:36 +00:00
|
|
|
#include "thr_private.h"
|
1996-01-22 00:23:58 +00:00
|
|
|
|
2006-03-13 00:59:51 +00:00
|
|
|
LT10_COMPAT_PRIVATE(__sigsuspend);
|
|
|
|
|
LT10_COMPAT_PRIVATE(_sigsuspend);
|
|
|
|
|
LT10_COMPAT_DEFAULT(sigsuspend);
|
|
|
|
|
|
2001-04-10 04:19:21 +00:00
|
|
|
__weak_reference(__sigsuspend, sigsuspend);
|
2001-01-24 13:03:38 +00:00
|
|
|
|
2003-04-18 05:04:16 +00:00
|
|
|
int
|
|
|
|
|
_sigsuspend(const sigset_t *set)
|
|
|
|
|
{
|
|
|
|
|
struct pthread *curthread = _get_curthread();
|
Check pending signals, if there is signal will be unblocked by
sigsuspend, thread shouldn't wait, in old code, it may be
ignored.
When a signal handler is invoked in sigsuspend, thread gets
two different signal masks, one is in thread structure,
sigprocmask() can retrieve it, another is in ucontext
which is a third parameter of signal handler, the former is
the result of sigsuspend mask ORed with sigaction's sa_mask
and current signal, the later is the mask in thread structure
before sigsuspend is called. After signal handler is called,
the mask in ucontext should be copied into thread structure,
and becomes CURRENT signal mask, then sigsuspend returns to
user code.
Reviewed by: deischen
Tested by: Sean McNeil <sean@mcneil.com>
2004-06-12 07:40:01 +00:00
|
|
|
sigset_t oldmask, newmask, tempset;
|
2003-04-18 05:04:16 +00:00
|
|
|
int ret = -1;
|
o Use a daemon thread to monitor signal events in kernel, if pending
signals were changed in kernel, it will retrieve the pending set and
try to find a thread to dispatch the signal. The dispatching process
can be rolled back if the signal is no longer in kernel.
o Create two functions _thr_signal_init() and _thr_signal_deinit(),
all signal action settings are retrieved from kernel when threading
mode is turned on, after a fork(), child process will reset them to
user settings by calling _thr_signal_deinit(). when threading mode
is not turned on, all signal operations are direct past to kernel.
o When a thread generated a synchoronous signals and its context returned
from completed list, UTS will retrieve the signal from its mailbox and try
to deliver the signal to thread.
o Context signal mask is now only used when delivering signals, thread's
current signal mask is always the one in pthread structure.
o Remove have_signals field in pthread structure, replace it with
psf_valid in pthread_signal_frame. when psf_valid is true, in context
switch time, thread will backout itself from some mutex/condition
internal queues, then begin to process signals. when a thread is not
at blocked state and running, check_pending indicates there are signals
for the thread, after preempted and then resumed time, UTS will try to
deliver signals to the thread.
o At signal delivering time, not only pending signals in thread will be
scanned, process's pending signals will be scanned too.
o Change sigwait code a bit, remove field sigwait in pthread_wait_data,
replace it with oldsigmask in pthread structure, when a thread calls
sigwait(), its current signal mask is backuped to oldsigmask, and waitset
is copied to its signal mask and when the thread gets a signal in the
waitset range, its current signal mask is restored from oldsigmask,
these are done in atomic fashion.
o Two additional POSIX APIs are implemented, sigwaitinfo() and sigtimedwait().
o Signal code locking is better than previous, there is fewer race conditions.
o Temporary disable most of code in _kse_single_thread as it is not safe
after fork().
2003-06-28 09:55:02 +00:00
|
|
|
|
2003-08-18 03:58:29 +00:00
|
|
|
if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
|
2003-07-17 23:02:30 +00:00
|
|
|
return (__sys_sigsuspend(set));
|
2003-04-18 05:04:16 +00:00
|
|
|
|
|
|
|
|
/* Check if a new signal set was provided by the caller: */
|
|
|
|
|
if (set != NULL) {
|
2003-07-07 04:28:23 +00:00
|
|
|
newmask = *set;
|
2003-07-17 23:02:30 +00:00
|
|
|
SIG_CANTMASK(newmask);
|
2003-06-18 06:08:03 +00:00
|
|
|
THR_LOCK_SWITCH(curthread);
|
2003-04-18 05:04:16 +00:00
|
|
|
|
Check pending signals, if there is signal will be unblocked by
sigsuspend, thread shouldn't wait, in old code, it may be
ignored.
When a signal handler is invoked in sigsuspend, thread gets
two different signal masks, one is in thread structure,
sigprocmask() can retrieve it, another is in ucontext
which is a third parameter of signal handler, the former is
the result of sigsuspend mask ORed with sigaction's sa_mask
and current signal, the later is the mask in thread structure
before sigsuspend is called. After signal handler is called,
the mask in ucontext should be copied into thread structure,
and becomes CURRENT signal mask, then sigsuspend returns to
user code.
Reviewed by: deischen
Tested by: Sean McNeil <sean@mcneil.com>
2004-06-12 07:40:01 +00:00
|
|
|
/* Save current sigmask: */
|
|
|
|
|
oldmask = curthread->sigmask;
|
|
|
|
|
curthread->oldsigmask = &oldmask;
|
2003-07-07 04:28:23 +00:00
|
|
|
|
2003-04-18 05:04:16 +00:00
|
|
|
/* Change the caller's mask: */
|
Check pending signals, if there is signal will be unblocked by
sigsuspend, thread shouldn't wait, in old code, it may be
ignored.
When a signal handler is invoked in sigsuspend, thread gets
two different signal masks, one is in thread structure,
sigprocmask() can retrieve it, another is in ucontext
which is a third parameter of signal handler, the former is
the result of sigsuspend mask ORed with sigaction's sa_mask
and current signal, the later is the mask in thread structure
before sigsuspend is called. After signal handler is called,
the mask in ucontext should be copied into thread structure,
and becomes CURRENT signal mask, then sigsuspend returns to
user code.
Reviewed by: deischen
Tested by: Sean McNeil <sean@mcneil.com>
2004-06-12 07:40:01 +00:00
|
|
|
curthread->sigmask = newmask;
|
|
|
|
|
tempset = curthread->sigpend;
|
|
|
|
|
SIGSETNAND(tempset, newmask);
|
|
|
|
|
if (SIGISEMPTY(tempset)) {
|
|
|
|
|
THR_SET_STATE(curthread, PS_SIGSUSPEND);
|
|
|
|
|
/* Wait for a signal: */
|
|
|
|
|
_thr_sched_switch_unlocked(curthread);
|
|
|
|
|
} else {
|
2004-12-18 18:07:37 +00:00
|
|
|
curthread->check_pending = 1;
|
Check pending signals, if there is signal will be unblocked by
sigsuspend, thread shouldn't wait, in old code, it may be
ignored.
When a signal handler is invoked in sigsuspend, thread gets
two different signal masks, one is in thread structure,
sigprocmask() can retrieve it, another is in ucontext
which is a third parameter of signal handler, the former is
the result of sigsuspend mask ORed with sigaction's sa_mask
and current signal, the later is the mask in thread structure
before sigsuspend is called. After signal handler is called,
the mask in ucontext should be copied into thread structure,
and becomes CURRENT signal mask, then sigsuspend returns to
user code.
Reviewed by: deischen
Tested by: Sean McNeil <sean@mcneil.com>
2004-06-12 07:40:01 +00:00
|
|
|
THR_UNLOCK_SWITCH(curthread);
|
|
|
|
|
/* check pending signal I can handle: */
|
|
|
|
|
_thr_sig_check_pending(curthread);
|
|
|
|
|
}
|
2004-12-19 23:23:43 +00:00
|
|
|
if ((curthread->cancelflags & THR_CANCELLING) != 0)
|
|
|
|
|
curthread->oldsigmask = NULL;
|
|
|
|
|
else {
|
|
|
|
|
THR_ASSERT(curthread->oldsigmask == NULL,
|
|
|
|
|
"oldsigmask is not cleared");
|
|
|
|
|
}
|
|
|
|
|
|
2003-04-18 05:04:16 +00:00
|
|
|
/* Always return an interrupted error: */
|
|
|
|
|
errno = EINTR;
|
|
|
|
|
} else {
|
|
|
|
|
/* Return an invalid argument error: */
|
|
|
|
|
errno = EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the completion status: */
|
|
|
|
|
return (ret);
|
|
|
|
|
}
|
|
|
|
|
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
int
|
2001-01-24 13:03:38 +00:00
|
|
|
__sigsuspend(const sigset_t * set)
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
{
|
2003-04-18 05:04:16 +00:00
|
|
|
struct pthread *curthread = _get_curthread();
|
|
|
|
|
int ret;
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
|
2003-12-09 02:20:56 +00:00
|
|
|
_thr_cancel_enter(curthread);
|
2003-04-18 05:04:16 +00:00
|
|
|
ret = _sigsuspend(set);
|
2003-12-09 02:20:56 +00:00
|
|
|
_thr_cancel_leave(curthread, 1);
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
|
2003-04-18 05:04:16 +00:00
|
|
|
return (ret);
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
}
|
