#include <hurd.h>
#include <hurd/signal.h>
#include <hurd/threadvar.h>
+#include <stdlib.h>
int
-__sigreturn (const struct sigcontext *scp)
+__sigreturn (struct sigcontext *scp)
{
struct hurd_sigstate *ss;
mach_port_t *reply_port;
- if (scp == NULL)
+ if (scp == NULL || (scp->sc_mask & _SIG_CANT_MASK))
{
errno = EINVAL;
return -1;
}
- ss = _hurd_self_sigstate ();
+ ss = _hurd_self_sigstate (); /* SS->lock now locked. */
+
+ /* Restore the set of blocked signals, and the intr_port slot. */
ss->blocked = scp->sc_mask;
ss->intr_port = scp->sc_intr_port;
+
+ /* Check for pending signals that were blocked by the old set. */
+ if (ss->pending & ~ss->blocked)
+ {
+ /* There are pending signals that just became unblocked. Wake up the
+ signal thread to deliver them. But first, squirrel away SCP where
+ the signal thread will notice it if it runs another handler, and
+ arrange to have us called over again in the new reality. */
+ ss->context = scp;
+ /* Clear the intr_port slot, since we are not in fact doing
+ an interruptible RPC right now. If SS->intr_port is not null,
+ the SCP context is doing an interruptible RPC, but the signal
+ thread will examine us while we are blocked in the sig_post RPC. */
+ ss->intr_port = MACH_PORT_NULL;
+ __mutex_unlock (&ss->lock);
+ __sig_post (_hurd_msgport, 0, __mach_task_self ());
+ /* If a pending signal was handled, sig_post never returned. */
+ __mutex_lock (&ss->lock);
+ }
+
if (scp->sc_onstack)
- ss->sigaltstack.ss_flags &= ~SA_ONSTACK; /* XXX threadvars */
- __mutex_unlock (&ss->lock);
+ {
+ ss->sigaltstack.ss_flags &= ~SA_ONSTACK; /* XXX threadvars */
+ /* XXX cannot unlock until off sigstack */
+ abort ();
+ }
+ else
+ __mutex_unlock (&ss->lock);
/* Destroy the MiG reply port used by the signal handler, and restore the
reply port in use by the thread when interrupted. */
reply_port =
(mach_port_t *) __hurd_threadvar_location (_HURD_THREADVAR_MIG_REPLY);
- if (*reply_port != MACH_PORT_NULL)
+ if (*reply_port)
__mach_port_destroy (__mach_task_self (), *reply_port);
*reply_port = scp->sc_reply_port;
+ if (scp->sc_coproc_used & SC_COPROC_USE_FPU)
+ {
+ /* XXX should restore FPU state here */
+ abort ();
+ }
+
/* Load all the registers from the sigcontext. */
#define restore_gpr(n) \
asm volatile ("lw $" #n ",%0" : : "m" (scpreg->sc_gpr[n - 1]))
{
register const struct sigcontext *const scpreg asm ("$1") = scp;
-
- /* Just beyond the top of the user stack, store the user's value for $1
- (which we are using for SCPREG). We restore this register as the
- very last thing, below. */
- ((int *) scpreg->sc_gpr[29 - 1])[-1] = scpreg->sc_gpr[0];
+ register int *at asm ("$1");
/* First restore the multiplication result registers. The compiler
will use some temporary registers, so we do this before restoring
asm volatile ("mtlo %0" : : "r" (scpreg->sc_mdlo));
asm volatile ("mthi %0" : : "r" (scpreg->sc_mdhi));
+ /* In the word after the saved PC, store the saved $1 value. */
+ (&scpreg->sc_pc)[1] = scpreg->sc_gpr[0];
+
asm volatile (".set noreorder; .set noat;");
/* Restore the normal registers. */
restore_gpr (30); /* Frame pointer. */
restore_gpr (31); /* Return address. */
- /* Now jump to the saved PC. */
- asm volatile ("lw $1, %0\n" /* Load saved PC into $1. */
- "j $1\n" /* Jump to the saved PC value. */
- "lw $1, -4(sp)\n" /* Restore $1 from stack in delay slot. */
- : : "m" (scpreg->sc_pc));
+ at = &scpreg->sc_pc;
+ /* This is an emulated instruction that will find at the address in $1
+ two words: the PC value to restore, and the $1 value to restore. */
+ asm volatile (".word op_sigreturn");
asm volatile (".set reorder; .set at;");
}