hurd/sigunwind.c

   1 /* longjmp cleanup function for unwinding past signal handlers.
   2    Copyright (C) 1995-2021 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 Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the 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    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <hurd.h>
  20 #include <thread_state.h>
  21 #include <hurd/threadvar.h>
  22 #include <jmpbuf-unwind.h>
  23 #include <assert.h>
  24 #include <stdint.h>
  25
  26
  27 /* _hurd_setup_sighandler puts a link on the `active resources' chain so that
  28    _longjmp_unwind will call this function with the `struct sigcontext *'
  29    describing the context interrupted by the signal, when `longjmp' is jumping
  30    to an environment that unwinds past the interrupted frame.  */
  31
  32 void
  33 _hurdsig_longjmp_from_handler (void *data, jmp_buf env, int val)
  34 {
  35   struct sigcontext *scp = data;
  36   struct hurd_sigstate *ss = _hurd_self_sigstate ();
  37   int onstack;
  38   inline void cleanup (void)
  39     {
  40       /* Destroy the MiG reply port used by the signal handler, and restore
  41          the reply port in use by the thread when interrupted.  */
  42       mach_port_t *reply_port = &__hurd_local_reply_port;
  43       if (*reply_port)
  44         {
  45           mach_port_t port = *reply_port;
  46           /* Assigning MACH_PORT_DEAD here tells libc's mig_get_reply_port
  47              not to get another reply port, but avoids mig_dealloc_reply_port
  48              trying to deallocate it after the receive fails (which it will,
  49              because the reply port will be bogus, regardless).  */
  50           *reply_port = MACH_PORT_DEAD;
  51           __mach_port_destroy (__mach_task_self (), port);
  52         }
  53       if (scp->sc_reply_port)
  54         __mach_port_destroy (__mach_task_self (), scp->sc_reply_port);
  55     }
  56
  57   __spin_lock (&ss->lock);
  58   /* We should only ever be called from _longjmp_unwind (in jmp-unwind.c),
  59      which calls us inside a critical section.  */
  60   assert (__spin_lock_locked (&ss->critical_section_lock));
  61   /* Are we on the alternate signal stack now?  */
  62   onstack = (ss->sigaltstack.ss_flags & SS_ONSTACK);
  63   __spin_unlock (&ss->lock);
  64
  65   if (onstack && ! scp->sc_onstack)
  66     {
  67       /* We are unwinding off the signal stack.  We must use sigreturn to
  68          do it robustly.  Mutate the sigcontext so that when sigreturn
  69          resumes from that context, it will be as if `__longjmp (ENV, VAL)'
  70          were done.  */
  71
  72       struct hurd_userlink *link;
  73
  74       inline uintptr_t demangle_ptr (uintptr_t x)
  75         {
  76 # ifdef PTR_DEMANGLE
  77           PTR_DEMANGLE (x);
  78 # endif
  79           return x;
  80         }
  81
  82       /* Continue _longjmp_unwind's job of running the unwind
  83          forms for frames being unwound, since we will not
  84          return to its loop like this one, which called us.  */
  85       for (link = ss->active_resources;
  86            link && _JMPBUF_UNWINDS (env[0].__jmpbuf, link, demangle_ptr);
  87            link = link->thread.next)
  88         if (_hurd_userlink_unlink (link))
  89           {
  90             if (link->cleanup == &_hurdsig_longjmp_from_handler)
  91               {
  92                 /* We are unwinding past another signal handler invocation.
  93                    Just finish the cleanup for this (inner) one, and then
  94                    swap SCP to restore to the outer context.  */
  95                 cleanup ();
  96                 scp = link->cleanup_data;
  97               }
  98             else
  99               (*link->cleanup) (link->cleanup_data, env, val);
 100           }
 101
 102 #define sc_machine_thread_state paste(sc_,machine_thread_state)
 103 #define paste(a,b)      paste1(a,b)
 104 #define paste1(a,b)     a##b
 105
 106       /* There are no more unwind forms to be run!
 107          Now we can just have the sigreturn do the longjmp for us.  */
 108       _hurd_longjmp_thread_state
 109         ((struct machine_thread_state *) &scp->sc_machine_thread_state,
 110          env, val);
 111
 112       /* Restore to the same current signal mask.  If sigsetjmp saved the
 113          mask, longjmp has already restored it as desired; if not, we
 114          should leave it as it is.  */
 115       scp->sc_mask = ss->blocked;
 116
 117       /* sigreturn expects the link added by _hurd_setup_sighandler
 118          to still be there, but _longjmp_unwind removed it just before
 119          calling us.  Put it back now so sigreturn can find it.  */
 120       link = (void *) &scp[1];
 121       assert (! link->resource.next && ! link->resource.prevp);
 122       assert (link->thread.next == ss->active_resources);
 123       assert (link->thread.prevp == &ss->active_resources);
 124       if (link->thread.next)
 125         link->thread.next->thread.prevp = &link->thread.next;
 126       ss->active_resources = link;
 127
 128       /* We must momentarily exit the critical section so that sigreturn
 129          does not get upset with us.  But we don't want signal handlers
 130          running right now, because we are presently in the bogus state of
 131          having run all the unwind forms back to ENV's frame, but our SP is
 132          still inside those unwound frames.  */
 133       __spin_lock (&ss->lock);
 134       __spin_unlock (&ss->critical_section_lock);
 135       ss->blocked = ~(sigset_t) 0 & ~_SIG_CANT_MASK;
 136       __spin_unlock (&ss->lock);
 137
 138       /* Restore to the modified signal context that now
 139          performs `longjmp (ENV, VAL)'.  */
 140       __sigreturn (scp);
 141       assert (! "sigreturn returned!");
 142     }
 143
 144   /* We are not unwinding off the alternate signal stack.  So nothing
 145      really funny is going on here.  We can just clean up this handler
 146      frame and let _longjmp_unwind continue unwinding.  */
 147   cleanup ();
 148   ss->intr_port = scp->sc_intr_port;
 149 }