hurd/catch-signal.c

   1 /* Convenience function to catch expected signals during an operation.
   2 Copyright (C) 1996 Free Software Foundation, Inc.
   3 This file is part of the GNU C Library.
   4
   5 The GNU C Library is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Library General Public License as
   7 published by the Free Software Foundation; either version 2 of the
   8 License, or (at your option) any later version.
   9
  10 The GNU C Library is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 Library General Public License for more details.
  14
  15 You should have received a copy of the GNU Library General Public
  16 License along with the GNU C Library; see the file COPYING.LIB.  If
  17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  18 Cambridge, MA 02139, USA.  */
  19
  20 #include <hurd/signal.h>
  21 #include <hurd/sigpreempt.h>
  22 #include <string.h>
  23 #include <assert.h>
  24
  25 error_t
  26 hurd_catch_signal (sigset_t sigset,
  27                    unsigned long int first, unsigned long int last,
  28                    error_t (*operate) (struct hurd_signal_preempter *),
  29                    sighandler_t handler)
  30 {
  31   jmp_buf buf;
  32   void throw (int signo, long int sigcode, struct sigcontext *scp)
  33     { longjmp (buf, scp->sc_error ?: EGRATUITOUS); }
  34
  35   struct hurd_signal_preempter preempter =
  36     {
  37       sigset, first, last,
  38       NULL, handler == SIG_ERR ? (sighandler_t) &throw : handler,
  39     };
  40
  41   struct hurd_sigstate *const ss = _hurd_self_sigstate ();
  42   error_t error;
  43
  44   if (handler == SIG_ERR)
  45     /* Not our handler; don't bother saving state.  */
  46     error = 0;
  47   else
  48     /* This returns again with nonzero value when we preempt a signal.  */
  49     error = setjmp (buf);
  50
  51   if (error == 0)
  52     {
  53       /* Install a signal preempter for the thread.  */
  54       __spin_lock (&ss->lock);
  55       preempter.next = ss->preempters;
  56       ss->preempters = &preempter;
  57       __spin_unlock (&ss->lock);
  58
  59       /* Try the operation that might crash.  */
  60       (*operate) (&preempter);
  61     }
  62
  63   /* Either FUNCTION completed happily and ERROR is still zero, or it hit
  64      an expected signal and `throw' made setjmp return the signal error
  65      code in ERROR.  Now we can remove the preempter and return.  */
  66
  67   __spin_lock (&ss->lock);
  68   assert (ss->preempters == &preempter);
  69   ss->preempters = preempter.next;
  70   __spin_unlock (&ss->lock);
  71
  72   return error;
  73 }
  74
  75
  76 error_t
  77 hurd_safe_memset (void *dest, int byte, size_t nbytes)
  78 {
  79   error_t operate (struct hurd_signal_preempter *preempter)
  80     {
  81       memset (dest, byte, nbytes);
  82       return 0;
  83     }
  84   return hurd_catch_signal (sigmask (SIGBUS) | sigmask (SIGSEGV),
  85                             (vm_address_t) dest, (vm_address_t) dest + nbytes,
  86                             &operate, SIG_ERR);
  87 }