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, 4 insertions, 39 deletions

diff --git a/lib/libpthread/thread/thr_init.c b/lib/libpthread/thread/thr_init.c
index 227bdf3..202db62 100644
--- a/lib/libpthread/thread/thr_init.c
+++ b/lib/libpthread/thread/thr_init.c
@@ -39,6 +39,7 @@
 #include "namespace.h"
 #include <sys/param.h>
 #include <sys/types.h>
+#include <sys/signalvar.h>
 #include <machine/reg.h>
 
 #include <sys/ioctl.h>
@@ -304,7 +305,7 @@ _libpthread_init(struct pthread *curthread)
 	_thr_initial->kse->k_curthread = _thr_initial;
 	_thr_initial->kse->k_flags |= KF_INITIALIZED;
 	_kse_initial->k_curthread = _thr_initial;
-	
+
 	_thr_rtld_init();
 }
 
@@ -365,14 +366,13 @@ init_main_thread(struct pthread *thread)
 	thread->name = strdup("initial thread");
 
 	/* Initialize the thread for signals: */
-	sigemptyset(&thread->sigmask);
+	SIGEMPTYSET(thread->sigmask);
 
 	/*
 	 * Set up the thread mailbox.  The threads saved context
 	 * is also in the mailbox.
 	 */
 	thread->tmbx.tm_udata = thread;
-	thread->tmbx.tm_context.uc_sigmask = thread->sigmask;
 	thread->tmbx.tm_context.uc_stack.ss_size = thread->attr.stacksize_attr;
 	thread->tmbx.tm_context.uc_stack.ss_sp = thread->attr.stackaddr_attr;
 
@@ -407,10 +407,8 @@ static void
 init_private(void)
 {
 	struct clockinfo clockinfo;
-	struct sigaction act;
 	size_t len;
 	int mib[2];
-	int i;
 
 	/*
 	 * Avoid reinitializing some things if they don't need to be,
@@ -448,36 +446,6 @@ init_private(void)
 
 		_thr_page_size = getpagesize();
 		_thr_guard_default = _thr_page_size;
-
-		/* Enter a loop to get the existing signal status: */
-		for (i = 1; i < NSIG; i++) {
-			/* Check for signals which cannot be trapped: */
-			if (i == SIGKILL || i == SIGSTOP) {
-			}
-
-			/* Get the signal handler details: */
-			else if (__sys_sigaction(i, NULL,
-			    &_thread_sigact[i - 1]) != 0) {
-				/*
-				 * Abort this process if signal
-				 * initialisation fails:
-				 */
-				PANIC("Cannot read signal handler info");
-			}
-		}
-		/*
-		 * Install the signal handler for SIGINFO.  It isn't
-		 * really needed, but it is nice to have for debugging
-		 * purposes.
-		 */
-		if (__sys_sigaction(SIGINFO, &act, NULL) != 0) {
-			/*
-			 * Abort this process if signal initialisation fails:
-			 */
-			PANIC("Cannot initialize signal handler");
-		}
-		_thread_sigact[SIGINFO - 1].sa_flags = SA_SIGINFO | SA_RESTART;
-
 		init_once = 1;	/* Don't do this again. */
 	} else {
 		/*
@@ -495,8 +463,6 @@ init_private(void)
 	TAILQ_INIT(&_thread_list);
 	TAILQ_INIT(&_thread_gc_list);
 
-	/* Enter a loop to get the existing signal status: */
-
 	/* Initialize the SIG_DFL dummy handler count. */
 	bzero(_thread_dfl_count, sizeof(_thread_dfl_count));
 
@@ -520,8 +486,7 @@ init_private(void)
 	_thr_spinlock_init();
 
 	/* Clear pending signals and get the process signal mask. */
-	sigemptyset(&_thr_proc_sigpending);
-	__sys_sigprocmask(SIG_SETMASK, NULL, &_thr_proc_sigmask);
+	SIGEMPTYSET(_thr_proc_sigpending);
 
 	/*
 	 * _thread_list_lock and _kse_count are initialized