2008-03-01 Neal H. Walfield <neal@gnu.org>

	Add signal implementation.
	* Makefile.am (SYSDEP_PATH): Add $(srcdir)/signal.
	(libpthread_a_SOURCES): Add pt-mutex-transfer-np.c, kill.c,
	killpg.c, pt-kill-siginfo-np.c, raise.c, sigaction.c, sigaddset.c,
	sigaltstack.c, sigdelset.c, sigemptyset.c, sigfillset.c,
	sig-internal.c, sig-internal.h, siginterrupt.c, sigismember.c,
	signal.c, signal-dispatch.c, signal.h, sigpending.c,
	sigprocmask.c, sigsuspend.c, sigtimedwait.c, sigwait.c,
	sigwaiter.c, sigwaitinfo.c, signal-dispatch-lowlevel.c, and
	sigprocmask.c.
	* headers.m4: Link libpthread/signal/signal.h into ../include.
	* sysdeps/generic/pt-mutex-transfer-np.c: New file.
        * signal/README: New file.
        * signal/TODO: Likewise.
        * signal/kill.c: Likewise.
        * signal/pt-kill-siginfo-np.c: Likewise.
        * signal/sig-internal.c: Likewise.
        * signal/sig-internal.h: Likewise.
        * signal/sigaction.c: Likewise.
        * signal/sigaltstack.c: Likewise.
        * signal/signal-dispatch.c: Likewise.
        * signal/signal.h: Likewise.
        * signal/sigpending.c: Likewise.
        * signal/sigsuspend.c: Likewise.
        * signal/sigtimedwait.c: Likewise.
        * signal/sigwaiter.c: Likewise.
        * signal/sigwaitinfo.c: Likewise.
	* sysdeps/l4/hurd/sig-sysdep.h: Likewise.
	* sysdeps/l4/hurd/sigprocmask.c: Likewise.
	* sysdeps/generic/killpg.c: Likewise.
	* sysdeps/generic/pt-kill.c: Likewise.
	* sysdeps/generic/raise.c: Likewise.
	* sysdeps/generic/sigaddset.c: Likewise.
	* sysdeps/generic/sigdelset.c: Likewise.
	* sysdeps/generic/sigemptyset.c: Likewise.
	* sysdeps/generic/sigfillset.c: Likewise.
	* sysdeps/generic/siginterrupt.c: Likewise.
	* sysdeps/generic/sigismember.c: Likewise.
	* sysdeps/generic/signal.c: Likewise.
	* sysdeps/generic/sigwait.c: Likewise.
	* sysdeps/l4/hurd/ia32/signal-dispatch-lowlevel.c: Likewise.
	* sysdeps/l4/hurd/pt-sysdep.c (sigprocmask): Remove function.
	* sysdeps/l4/hurd/pt-sigstate.c (__pthread_sigstate): Implement
	it.
	* sysdeps/l4/hurd/pt-sigstate-init.c: Include <sig-internal.h>.
	(__pthread_sigstate_init): Initialize THREAD->SS.
	* sysdeps/l4/hurd/pt-kill.c: Remove file.
	* pthread/pt-internal.h: Include <sig-internal.h>.
	(PTHREAD_SIGNAL_MEMBERS) [! PTHREAD_SIGNAL_MEMBERS]: Define.
	(struct __pthread): Add PTHREAD_SIGNAL_MEMBERS.
	* pthread/pt-self.c (pthread_self): Assert that SELF is not NULL.

1 files changed, 117 insertions, 0 deletions

diff --git a/signal/signal-dispatch.c b/signal/signal-dispatch.c
new file mode 100644
index 0000000..40440b7
--- /dev/null
+++ b/signal/signal-dispatch.c
@@ -0,0 +1,117 @@
+/* signal-dispatch.c - Signal dispatcher.
+   Copyright (C) 2008 Free Software Foundation, Inc.
+   Written by Neal H. Walfield <neal@gnu.org>.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public License
+   as published by the Free Software Foundation; either version 3 of
+   the License, or (at your option) any later version.
+
+   The GNU Hurd is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this program.  If not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include "sig-internal.h"
+
+/* This is the signal handler entry point.  A thread is forced into
+   this state when it receives a signal.  We need to save the thread's
+   state and then invoke the high-level signal dispatcher.  SS->LOCK
+   is locked by the caller.  */
+void
+signal_dispatch (struct signal_state *ss, siginfo_t *si)
+{
+  SIGNAL_DISPATCH_ENTRY;
+
+  int signo = si->si_signo;
+
+  assert (signo > 0 && signo < NSIG);
+  assert (pthread_mutex_trylock (&ss->lock) == EBUSY);
+
+  do
+    {
+      if ((sigmask (signo) & STOPSIGS))
+	/* Stop signals clear a pending SIGCONT even if they
+	   are handled or ignored (but not if preempted).  */
+	{
+	  sigdelset (&ss->pending, SIGCONT);
+	  sigdelset (&process_pending, SIGCONT);
+	}
+      else if ((signo == SIGCONT))
+	/* Even if handled or ignored (but not preempted), SIGCONT
+	   clears stop signals and resumes the process.  */
+	{
+	  ss->pending &= ~STOPSIGS;
+	  process_pending &= ~STOPSIGS;
+	}
+
+      void (*handler)(int, siginfo_t *, void *)
+	= ss->actions[signo - 1].sa_sigaction;
+
+      /* Reset to SIG_DFL if requested.  SIGILL and SIGTRAP cannot
+	 be automatically reset when delivered; the system silently
+	 enforces this restriction (sigaction).  */
+      if (ss->actions[signo - 1].sa_flags & SA_RESETHAND
+	  && signo != SIGILL && signo != SIGTRAP)
+	ss->actions[signo - 1].sa_handler = SIG_DFL;
+
+      sigset_t orig_blocked = ss->blocked;
+      /* Block requested signals while running the handler.  */
+      ss->blocked |= ss->actions[signo - 1].sa_mask;
+
+      /* Block SIGNO unless we're asked not to.  */
+      if (! (ss->actions[signo - 1].sa_flags & (SA_RESETHAND | SA_NODEFER)))
+	sigaddset (&ss->blocked, signo);
+
+      sigdelset (&ss->pending, signo);
+      pthread_mutex_unlock (&ss->lock);
+
+      pthread_mutex_lock (&sig_lock);
+      sigdelset (&process_pending, signo);
+      pthread_mutex_unlock (&sig_lock);
+
+      if (handler == (void *) SIG_DFL)
+	{
+	  enum sig_action action = default_action (signo);
+
+	  if (action == sig_terminate || action == sig_core)
+	    _exit (128 + signo);
+
+	  if (action == sig_stop)
+	    /* XXX: Implement me.  */
+	    panic ("Stopping process unimplemented.");
+
+	  if (action == sig_cont)
+	    /* XXX: Implement me.  */;
+	    panic ("Continuing process unimplemented.");
+	}
+      else if (handler == (void *) SIG_IGN)
+	;
+      else
+	handler (signo, si, NULL);
+
+      pthread_mutex_lock (&ss->lock);
+
+      /* "When a thread's signal mask is changed in a signal-catching
+	 function that is installed by sigaction(), the restoration of
+	 the signal mask on return from the signal-catching function
+	 overrides that change (see sigaction())" (sigprocmask).  */
+      ss->blocked = orig_blocked;
+
+      sigset_t pending = ~ss->blocked & ss->pending;
+      if (! pending)
+	pending = ~ss->blocked & process_pending;
+      signo = l4_lsb64 (pending);
+    }
+  while (signo);
+
+  pthread_mutex_unlock (&ss->lock);
+
+  SIGNAL_DISPATCH_EXIT;
+}