From 92ae11d4564e4df19bffc862da14a5ba261fb390 Mon Sep 17 00:00:00 2001 From: Roland McGrath Date: Mon, 22 Aug 1994 09:06:46 +0000 Subject: [PATCH] (__sigreturn): Arg is not const. After restoring SCP->sc_mask, check for pending signals (newly unblocked); if any, set SS->context to SCP, clear SS->intr_port, and send sig_post to the signal thread to deliver the pending signals. Don't write $1 value into the user stack. Instead, write it into the word just past SCP->sc_pc; then point $1 at SCP->sc_pc and use `op_sigreturn' pseudo-instruction to restore the PC and $1 from that. --- sysdeps/mach/hurd/mips/sigreturn.c | 64 ++++++++++++++++++++++++++++---------- 1 file changed, 48 insertions(+), 16 deletions(-) diff --git a/sysdeps/mach/hurd/mips/sigreturn.c b/sysdeps/mach/hurd/mips/sigreturn.c index 8082aca..f02e799 100644 --- a/sysdeps/mach/hurd/mips/sigreturn.c +++ b/sysdeps/mach/hurd/mips/sigreturn.c @@ -19,45 +19,75 @@ Cambridge, MA 02139, USA. */ #include #include #include +#include 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 @@ -65,6 +95,9 @@ __sigreturn (const struct sigcontext *scp) 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. */ @@ -98,11 +131,10 @@ __sigreturn (const struct sigcontext *scp) 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;"); } -- 2.7.4