From 7b25bda5637f6013ca7067e4482a40b0a4c73bc6 Mon Sep 17 00:00:00 2001 From: davidxu Date: Sat, 28 Jun 2003 09:55:02 +0000 Subject: 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(). --- lib/libpthread/thread/thr_sigmask.c | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) (limited to 'lib/libpthread/thread/thr_sigmask.c') diff --git a/lib/libpthread/thread/thr_sigmask.c b/lib/libpthread/thread/thr_sigmask.c index d9cb839..c8fcec8 100644 --- a/lib/libpthread/thread/thr_sigmask.c +++ b/lib/libpthread/thread/thr_sigmask.c @@ -48,33 +48,35 @@ _pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) struct pthread *curthread = _get_curthread(); int ret; + if (! _kse_isthreaded()) + _kse_setthreaded(1); + + THR_SCHED_LOCK(curthread, curthread); ret = 0; if (oset != NULL) /* Return the current mask: */ - *oset = curthread->tmbx.tm_context.uc_sigmask; + *oset = curthread->sigmask; /* Check if a new signal set was provided by the caller: */ if (set != NULL) { - THR_SCHED_LOCK(curthread, curthread); - /* Process according to what to do: */ switch (how) { /* Block signals: */ case SIG_BLOCK: /* Add signals to the existing mask: */ - SIGSETOR(curthread->tmbx.tm_context.uc_sigmask, *set); + SIGSETOR(curthread->sigmask, *set); break; /* Unblock signals: */ case SIG_UNBLOCK: /* Clear signals from the existing mask: */ - SIGSETNAND(curthread->tmbx.tm_context.uc_sigmask, *set); + SIGSETNAND(curthread->sigmask, *set); break; /* Set the signal process mask: */ case SIG_SETMASK: /* Set the new mask: */ - curthread->tmbx.tm_context.uc_sigmask = *set; + curthread->sigmask = *set; break; /* Trap invalid actions: */ @@ -84,13 +86,7 @@ _pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) ret = -1; break; } - - if (ret == 0) { - curthread->sigmask = - curthread->tmbx.tm_context.uc_sigmask; - curthread->sigmask_seqno++; - } - + SIG_CANTMASK(curthread->sigmask); THR_SCHED_UNLOCK(curthread, curthread); /* @@ -98,6 +94,7 @@ _pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) */ if (ret == 0) _thr_sig_check_pending(curthread); - } + } else + THR_SCHED_UNLOCK(curthread, curthread); return (ret); } -- cgit v1.1