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, 10 insertions, 3 deletions

diff --git a/lib/libkse/thread/thr_sigaction.c b/lib/libkse/thread/thr_sigaction.c
index 7ede6d2..2bef7f2 100644
--- a/lib/libkse/thread/thr_sigaction.c
+++ b/lib/libkse/thread/thr_sigaction.c
@@ -43,16 +43,21 @@ _sigaction(int sig, const struct sigaction * act, struct sigaction * oact)
 {
 	int ret = 0;
 	struct sigaction gact;
+	struct pthread *curthread;
+	kse_critical_t crit;	
 
 	/* Check if the signal number is out of range: */
-	if (sig < 1 || sig > NSIG) {
+	if (sig < 1 || sig > _SIG_MAXSIG) {
 		/* Return an invalid argument: */
 		errno = EINVAL;
 		ret = -1;
 	} else {
-		if (_thr_initial == NULL)
-			_libpthread_init(NULL);
+		if (!_kse_isthreaded())
+			return __sys_sigaction(sig, act, oact);
 
+		crit = _kse_critical_enter();
+		curthread = _get_curthread();
+		KSE_LOCK_ACQUIRE(curthread->kse, &_thread_signal_lock);
 		/*
 		 * Check if the existing signal action structure contents are
 		 * to be returned: 
@@ -99,6 +104,8 @@ _sigaction(int sig, const struct sigaction * act, struct sigaction * oact)
 		    	if (__sys_sigaction(sig, &gact, NULL) != 0)
 				ret = -1;
 		}
+		KSE_LOCK_RELEASE(curthread->kse, &_thread_signal_lock);
+		_kse_critical_leave(crit);
 	}
 
 	/* Return the completion status: */