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().

1 files changed, 11 insertions, 14 deletions

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);
 }