diff options
Diffstat (limited to 'hurd')
| -rw-r--r-- | hurd/hurd/signal.h | 49 | ||||
| -rw-r--r-- | hurd/hurd/sigpreempt.h | 90 | ||||
| -rw-r--r-- | hurd/preempt-sig.c | 83 |
3 files changed, 141 insertions, 81 deletions
diff --git a/hurd/hurd/signal.h b/hurd/hurd/signal.h index b494f4922e..1973bcdb3c 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 0000000000..eed67b2e94 --- /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 194b49dbe9..6596089f1b 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"); } |