* hurd/hurd/signal.h (struct hurd_sigstate): New member `preempters'.cvs/libc-960102

	(hurd_preempt_signals, hurd_unpreempt_signals): Decls removed.
	* hurd/hurd/sigpreempt.h: New file.
	* hurd/preempt-sig.c: Rewritten with new interface.
	* sysdeps/mach/hurd/jmp-unwind.c (_longjmp_unwind): Remove local signal
	preempters being unwound past.

	* db: New directory, 4.4 BSD db package incorporated from BSD db-1.85
	release.

	* sysdeps/unix/sysv/linux/sys/param.h: Several new macros for BSD
	compatibility.

3 files changed, 141 insertions, 81 deletions

diff --git a/hurd/hurd/signal.h b/hurd/hurd/signal.h
index b494f49..1973bcd 100644
--- a/hurd/hurd/signal.h
+++ b/hurd/hurd/signal.h
@@ -1,5 +1,5 @@
 /* Implementing POSIX.1 signals under the Hurd.
-Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
 This file is part of the GNU C Library.
 
 The GNU C Library is free software; you can redistribute it and/or
@@ -40,6 +40,7 @@ Cambridge, MA 02139, USA.  */
 #include <cthreads.h>		/* For `struct mutex'.  */
 #include <spin-lock.h>
 #include <hurd/threadvar.h>	/* We cache sigstate in a threadvar.  */
+struct hurd_signal_preempter;	/* <hurd/sigpreempt.h> */
 
 
 /* Per-thread signal state.  */
@@ -57,6 +58,13 @@ struct hurd_sigstate
     sigset_t pending;		/* Pending signals, possibly blocked.  */
     struct sigaction actions[NSIG];
     struct sigaltstack sigaltstack;
+
+    /* Chain of thread-local signal preempters; see <hurd/sigpreempt.h>.
+       Each element of this chain is in local stack storage, and the chain
+       parallels the stack: the head of this chain is in the innermost
+       stack frame, and each next element in an outermore frame.  */
+    struct hurd_signal_preempter *preempters;
+
     struct
       {
 	/* For each signal that may be pending, the
@@ -330,45 +338,6 @@ extern mach_msg_timeout_t _hurd_interrupted_rpc_timeout;
 	       __err == MIG_SERVER_DIED);				      \
     __err;								      \
 })
-
-/* Some other parts of the library need to preempt signals, to detect
-   errors that should not result in a POSIX signal.  For example, when
-   some mapped region of memory is used, an extraneous SIGSEGV might be
-   generated when the mapping server returns an error for a page fault.  */
-
-struct hurd_signal_preempt
-  {
-    /* Function to examine a thread receiving a given signal.  The handler
-       is called even for blocked signals.  This function is run in the
-       signal thread, with THREAD's sigstate locked; it should be as simple
-       and robust as possible.  THREAD is the thread which is about to
-       receive the signal.  SIGNO and SIGCODE would be passed to the normal
-       handler.
-
-       If the return value is SIG_DFL, normal signal processing continues.
-       If it is SIG_IGN, the signal is ignored.
-       Any other value is used in place of the normal handler.  */
-    sighandler_t (*handler) (thread_t thread,
-			     int signo, long int sigcode, int sigerror);
-    long int first, last;	/* Range of sigcodes this handler wants.  */
-    struct hurd_signal_preempt *next; /* Next handler on the chain. */
-  };
-
-extern struct hurd_signal_preempt *_hurd_signal_preempt[NSIG];
-extern struct mutex _hurd_signal_preempt_lock;
-
-/* Install a signal preempter for the given signal and range.
-   The caller is responsible for the storage for PREEMPTER.  */
-extern int hurd_preempt_signals (struct hurd_signal_preempt *preempter,
-				 int signo, int first_code, int last_code,
-				 sighandler_t (*handler) (thread_t,
-							  int, long int, int));
-
-/* Remove the signal preempter previously installed by calling
-   `hurd_preempt_signals' with PREEMPTER and SIGNO.  */
-extern int hurd_unpreempt_signals (struct hurd_signal_preempt *preempter,
-				   int signo);
-
 
 
 #endif	/* hurd/signal.h */
diff --git a/hurd/hurd/sigpreempt.h b/hurd/hurd/sigpreempt.h
new file mode 100644
index 0000000..eed67b2
--- /dev/null
+++ b/hurd/hurd/sigpreempt.h
@@ -0,0 +1,90 @@
+/* Preemption of Hurd signals before POSIX.1 semantics take over.
+Copyright (C) 1996 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library 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
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef	_HURD_SIGPREEMPT_H
+
+#define	_HURD_SIGPREEMPT_H	1
+#include <errno.h>
+#include <signal.h>		/* For sigset_t, sighandler_t, SIG_ERR.  */
+struct hurd_sigstate;		/* <hurd/signal.h> */
+
+struct hurd_signal_preempter
+  {
+    /* These members select which signals this structure will apply to.
+       The rest of the structure is only consulted if these match.  */
+    sigset_t signals;		/* Signals preempted.  */
+    unsigned long int first, last; /* Range of sigcode values preempted.  */
+
+    /* This function will be called (with SS->lock held) to decide what to
+       do with the signal described.  It may modify the codes of the signal
+       passed.  If the return value is SIG_ERR, the next matching preempter
+       is tried, or the normal handling is done for the signal (which may
+       have been changed by the preempter function).  Otherwise, the signal
+       is processed as if the return value were its handler setting.  */
+    sighandler_t (*preempter) (struct hurd_signal_preempter *preempter,
+			       struct hurd_sigstate *ss,
+			       int *signo, long int *sigcode, int *sigerror);
+    /* If PREEMPTER is null, act as if it returned HANDLER.  */
+    sighandler_t handler;
+
+    struct hurd_signal_preempter *next;	/* List structure.  */
+  };
+
+#define HURD_PREEMPT_SIGNAL_P(preempter, signo, sigcode) \
+  (((preempter)->signals & sigmask (signo)) && \
+   (sigcode) >= (preempter)->first && (sigcode) <= (preempter)->last)
+
+
+/* Signal preempters applying to all threads; locked by _hurd_siglock.  */
+extern struct hurd_signal_preempter *_hurdsig_preempters;
+extern sigset_t _hurdsig_preempted_set;
+
+
+/* The caller must initialize all members of *PREEMPTER except `next'.
+   The preempter is registered on the global list.  */
+void hurd_preempt_signals (struct hurd_signal_preempter *preempter);
+
+/* Remove a preempter registered with hurd_preempt_signals.  */
+void hurd_unpreempt_signals (struct hurd_signal_preempter *preempter);
+
+
+/* Call *OPERATE and return its value.  If a signal in SIGSET with a sigcode
+   in the range [FIRST,LAST] arrives during the call, catch it.  If HANDLER
+   is a function, it handles the signal in the normal way (i.e. it should
+   longjmp unless it can restart the insn on return).  If it is SIG_ERR,
+   hurd_catch_signal returns the sc_error value from the signal (or
+   EGRATUITOUS if that is zero).
+
+   The preempter structure is passed to *OPERATE, which may modify its
+   sigcode range or functions at any time during which it is guaranteed no
+   signal in SIGSET will arrive.  */
+
+error_t hurd_catch_signal (sigset_t sigset,
+			   unsigned long int first, unsigned long int last,
+			   error_t (*operate) (struct hurd_signal_preempter *),
+			   sighandler_t handler);
+
+
+/* Convenience functions using `hurd_catch_signal'.  */
+
+error_t hurd_safe_memmove (void *dest, const void *src, size_t nbytes);
+error_t hurd_safe_memset (void *dest, int byte, size_t nbytes);
+
+
+#endif	/* hurd/sigpreempt.h */
diff --git a/hurd/preempt-sig.c b/hurd/preempt-sig.c
index 194b49d..6596089 100644
--- a/hurd/preempt-sig.c
+++ b/hurd/preempt-sig.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 1994 Free Software Foundation, Inc.
+/* Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
 This file is part of the GNU C Library.
 
 The GNU C Library is free software; you can redistribute it and/or
@@ -16,52 +16,53 @@ License along with the GNU C Library; see the file COPYING.LIB.  If
 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
 Cambridge, MA 02139, USA.  */
 
+#include <hurd/sigpreempt.h>
 #include <hurd/signal.h>
+#include <assert.h>
 
-/* Initialize PREEMPTER with the information given and stick it in the
-   chain of preempters for SIGNO.  */
-
-int
-hurd_preempt_signals (struct hurd_signal_preempt *preempter,
-		      int signo, int first_code, int last_code,
-		      sighandler_t (*handler) (thread_t, int, long int, int))
+void
+hurd_preempt_signals (struct hurd_signal_preempter *preempter)
 {
-  if (signo <= 0 || signo >= NSIG)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-  preempter->first = first_code;
-  preempter->last = last_code;
-  preempter->handler = handler;
-  __mutex_lock (&_hurd_signal_preempt_lock);
-  preempter->next = _hurd_signal_preempt[signo];
-  _hurd_signal_preempt[signo] = preempter;
-  __mutex_unlock (&_hurd_signal_preempt_lock);
-  return 0;
+  __mutex_lock (&_hurd_siglock);
+  preempter->next = _hurdsig_preempters;
+  _hurdsig_preempters = preempter;
+  _hurdsig_preempted_set |= preempter->signals;
+  __mutex_unlock (&_hurd_siglock);
 }
 
-/* Remove PREEMPTER from the chain for SIGNO.  */
-
-int
-hurd_unpreempt_signals (struct hurd_signal_preempt *preempter, int signo)
+void
+hurd_unpreempt_signals (struct hurd_signal_preempter *preempter)
 {
-  struct hurd_signal_preempt *p, *lastp;
-  if (signo <= 0 || signo >= NSIG)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-  __mutex_lock (&_hurd_signal_preempt_lock);
-  for (p = _hurd_signal_preempt[signo], lastp = NULL;
-       p != NULL; lastp = p, p = p->next)
-    if (p == preempter)
+  struct hurd_signal_preempter **p;
+  sigset_t preempted = 0;
+
+  __mutex_lock (&_hurd_siglock);
+
+  p = &_hurdsig_preempters;
+  while (*p)
+    if (*p == preempter)
       {
-	(lastp == NULL ? _hurd_signal_preempt[signo] : lastp->next) = p->next;
-	__mutex_unlock (&_hurd_signal_preempt_lock);
-	return 0;
+	/* Found it; take it off the chain.  */
+	*p = (*p)->next;
+	if ((preempter->signals & preempted) != preempter->signals)
+	  {
+	    /* This might have been the only preempter for some
+	       of those signals, so we must collect the full mask
+	       from the others.  */
+	    struct hurd_signal_preempter *pp;
+	    for (pp = *p; pp; pp = pp->next)
+	      preempted |= pp->signals;
+	    _hurdsig_preempted_set = preempted;
+	  }
+	__mutex_unlock (&_hurd_siglock);
+	return;
       }
-  __mutex_unlock (&_hurd_signal_preempt_lock);
-  errno = ENOENT;
-  return -1;
+    else
+      {
+	preempted |= (*p)->signals;
+	p = &(*p)->next;
+      }
+
+  __mutex_unlock (&_hurd_siglock); /* Avoid deadlock during death rattle.  */
+  assert (! "removing absent preempter");
 }