aboutsummaryrefslogtreecommitdiff
path: root/hurd
diff options
context:
space:
mode:
authorRoland McGrath <roland@gnu.org>1996-01-02 08:57:42 +0000
committerRoland McGrath <roland@gnu.org>1996-01-02 08:57:42 +0000
commit71733723fb421bd54467d1a27096463ed1dcc2ed (patch)
treef304556d491722c797d876911834dc4afbfa2740 /hurd
parentfc4026d8e43407ba2739e493878d1ce259500059 (diff)
downloadglibc-71733723fb421bd54467d1a27096463ed1dcc2ed.zip
glibc-71733723fb421bd54467d1a27096463ed1dcc2ed.tar.gz
glibc-71733723fb421bd54467d1a27096463ed1dcc2ed.tar.bz2
* 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.
Diffstat (limited to 'hurd')
-rw-r--r--hurd/hurd/signal.h49
-rw-r--r--hurd/hurd/sigpreempt.h90
-rw-r--r--hurd/preempt-sig.c83
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");
}