Include "thread_state.h" instead of <mach/thread_status.h>.
(struct mach_msg_trap_args): New type.
(trampoline): Function removed.
(_hurd_setup_sighandler): Take struct hurd_sigstate * arg instead of FLAGS
and SIGALTSTACK args; take new flag arg RPC_WAIT; use struct
machine_thread_all_state * for STATE arg.
New declared labels `trampoline', `rpc_wait_trampoline' mark asm code at
end of function (after return).
Add another struct sigcontext * to STACKFRAME after the first one, for the
arg to __sigreturn.
If SS->context is set, fill registers in SCP from that instead of STATE,
and reset SS->INTR_PORT from it.
If RPC_WAIT is set, set up to use rpc_wait_trampoline and frob args to
mach_msg_trap syscall in progress so that it will retry the receive
operation (but not resend!).
{rpc_wait_trampoline, trampoline}: New trampoline code.
(_hurd_rcv_interrupted_p): New function.
This commit is contained in:
Roland McGrath
parent
817a880cc1
commit
62833ce689
|
|
@ -18,67 +18,240 @@ not, write to the Free Software Foundation, Inc., 675 Mass Ave,
|
||||||
Cambridge, MA 02139, USA. */
|
Cambridge, MA 02139, USA. */
|
||||||
|
|
||||||
#include <hurd/signal.h>
|
#include <hurd/signal.h>
|
||||||
#include <mach/thread_status.h>
|
#include "thread_state.h"
|
||||||
|
|
||||||
|
|
||||||
|
struct mach_msg_trap_args
|
||||||
|
{
|
||||||
|
/* This is the order of arguments to mach_msg_trap. */
|
||||||
|
mach_msg_header_t *msg;
|
||||||
|
mach_msg_option_t option;
|
||||||
|
mach_msg_size_t send_size;
|
||||||
|
mach_msg_size_t rcv_size;
|
||||||
|
mach_port_t rcv_name;
|
||||||
|
mach_msg_timeout_t timeout;
|
||||||
|
mach_port_t notify;
|
||||||
|
};
|
||||||
|
|
||||||
static void
|
|
||||||
trampoline (void (*handler) (int signo, int sigcode, struct sigcontext *scp),
|
|
||||||
int signo, int sigcode, struct sigcontext *scp)
|
|
||||||
{
|
|
||||||
(*handler) (signo, sigcode, scp);
|
|
||||||
(void) __sigreturn (scp); /* Does not return. */
|
|
||||||
while (1)
|
|
||||||
LOSE; /* Firewall. */
|
|
||||||
}
|
|
||||||
|
|
||||||
struct sigcontext *
|
struct sigcontext *
|
||||||
_hurd_setup_sighandler (int flags,
|
_hurd_setup_sighandler (struct hurd_sigstate *ss, __sighandler_t handler,
|
||||||
__sighandler_t handler,
|
|
||||||
struct sigaltstack *sigaltstack,
|
|
||||||
int signo, int sigcode,
|
int signo, int sigcode,
|
||||||
void *state)
|
int rpc_wait,
|
||||||
|
struct machine_thread_all_state *state)
|
||||||
{
|
{
|
||||||
struct mips_thread_state *ts;
|
|
||||||
|
__label__ trampoline, rpc_wait_trampoline;
|
||||||
void *sigsp;
|
void *sigsp;
|
||||||
struct sigcontext *scp;
|
struct sigcontext *scp;
|
||||||
|
|
||||||
ts = state;
|
if (ss->context)
|
||||||
|
|
||||||
if ((flags & SA_ONSTACK) &&
|
|
||||||
!(sigaltstack->ss_flags & (SA_DISABLE|SA_ONSTACK)))
|
|
||||||
{
|
{
|
||||||
sigsp = sigaltstack->ss_sp + sigaltstack->ss_size;
|
/* We have a previous sigcontext that sigreturn was about
|
||||||
sigaltstack->ss_flags |= SA_ONSTACK;
|
to restore when another signal arrived. We will just base
|
||||||
|
our setup on that. */
|
||||||
|
if (! setjmp (_hurd_sigthread_fault_env))
|
||||||
|
{
|
||||||
|
memcpy (&state->basic, &ss->context->sc_mips_thread_state,
|
||||||
|
sizeof (state->basic));
|
||||||
|
memcpy (&state->exc, &ss->context->sc_mips_exc_state,
|
||||||
|
sizeof (state->exc));
|
||||||
|
state->set = (1 << MIPS_THREAD_STATE) | (1 << MIPS_EXC_STATE);
|
||||||
|
if (state->exc.coproc_state & SC_COPROC_USE_FPU)
|
||||||
|
{
|
||||||
|
memcpy (&state->fpu, &ss->context->sc_mips_loat_state,
|
||||||
|
sizeof (state->fpu));
|
||||||
|
state->set |= (1 << MIPS_FLOAT_STATE);
|
||||||
|
}
|
||||||
|
assert (! rpc_wait);
|
||||||
|
/* The intr_port slot was cleared before sigreturn sent us the
|
||||||
|
sig_post that made us notice this pending signal, so
|
||||||
|
_hurd_internal_post_signal wouldn't do interrupt_operation.
|
||||||
|
After we return, our caller will set SCP->sc_intr_port (in the
|
||||||
|
new context) from SS->intr_port and clear SS->intr_port. Now
|
||||||
|
that we are restoring this old context recorded by sigreturn,
|
||||||
|
we want to restore its intr_port too; so store it in
|
||||||
|
SS->intr_port now, so it will end up in SCP->sc_intr_port
|
||||||
|
later. */
|
||||||
|
ss->intr_port = ss->context->sc_intr_port;
|
||||||
|
}
|
||||||
|
/* If the sigreturn context was bogus, just ignore it. */
|
||||||
|
ss->context = NULL;
|
||||||
|
}
|
||||||
|
else if (! machine_get_basic_state (ss->thread, state))
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
if ((ss->actions[signo].sa_flags & SA_ONSTACK) &&
|
||||||
|
!(ss->sigaltstack.ss_flags & (SA_DISABLE|SA_ONSTACK)))
|
||||||
|
{
|
||||||
|
sigsp = ss->sigaltstack.ss_sp + ss->sigaltstack.ss_size;
|
||||||
|
ss->sigaltstack.ss_flags |= SA_ONSTACK;
|
||||||
/* XXX need to set up base of new stack for
|
/* XXX need to set up base of new stack for
|
||||||
per-thread variables, cthreads. */
|
per-thread variables, cthreads. */
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
sigsp = (char *) ts->r29;
|
sigsp = (char *) state->basic.r29;
|
||||||
|
|
||||||
/* Set up the sigcontext structure on the stack. This is all the stack
|
/* Set up the sigcontext structure on the stack. This is all the stack
|
||||||
needs, since the args are passed in registers (below). */
|
needs, since the args are passed in registers (below). */
|
||||||
sigsp -= sizeof (*scp);
|
sigsp -= sizeof (*scp);
|
||||||
scp = sigsp;
|
scp = sigsp;
|
||||||
|
|
||||||
/* Set up the sigcontext from the current state of the thread. */
|
if (! setjmp (_hurd_sigthread_fault_env))
|
||||||
|
{
|
||||||
|
/* Set up the sigcontext from the current state of the thread. */
|
||||||
|
|
||||||
scp->sc_onstack = sigaltstack->ss_flags & SA_ONSTACK ? 1 : 0;
|
scp->sc_onstack = ss->sigaltstack.ss_flags & SA_ONSTACK ? 1 : 0;
|
||||||
|
|
||||||
/* struct sigcontext is laid out so that starting at sc_gpr
|
/* struct sigcontext is laid out so that starting at sc_gpr
|
||||||
mimics a struct mips_thread_state. */
|
mimics a struct mips_thread_state. */
|
||||||
memcpy (scp->sc_gpr, &ts, sizeof ts);
|
memcpy (&scp->sc_mips_thread_state,
|
||||||
|
&state->basic, sizeof (state->basic));
|
||||||
|
|
||||||
/* Modify the thread state to call `trampoline' on the new stack. */
|
/* struct sigcontext is laid out so that starting at sc_cause
|
||||||
|
mimics a struct mips_exc_state. */
|
||||||
|
if (! machine_get_state (ss->thread, state, MIPS_EXC_STATE,
|
||||||
|
&state->exc, &scp->sc_cause,
|
||||||
|
sizeof (state->exc)))
|
||||||
|
return NULL;
|
||||||
|
if ((scp->sc_coproc_used & SC_COPROC_USE_FPU) &&
|
||||||
|
/* struct sigcontext is laid out so that starting at sc_fpr
|
||||||
|
mimics a struct mips_float_state. This state
|
||||||
|
is only meaningful if the coprocessor was used. */
|
||||||
|
! machine_get_state (ss->thread, state, MIPS_FLOAT_STATE,
|
||||||
|
&state->fpu,
|
||||||
|
&scp->sc_mips_float_state, sizeof (state->fpu)))
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
/* We got a fault trying to write the stack frame.
|
||||||
|
We cannot set up the signal handler.
|
||||||
|
Returning NULL tells our caller, who will nuke us with a SIGILL. */
|
||||||
|
return NULL;
|
||||||
|
|
||||||
/* These registers are used for passing the first four arguments to a
|
/* Modify the thread state to call the trampoline code on the new stack. */
|
||||||
function (the rest go on the stack). Fortunately `trampoline' takes
|
if (rpc_wait)
|
||||||
just four arguments, so they all fit in registers. */
|
{
|
||||||
ts->r4 = (int) handler;
|
/* The signalee thread was blocked in a mach_msg_trap system call,
|
||||||
ts->r5 = signo;
|
still waiting for a reply. We will have it run the special
|
||||||
ts->r6 = sigcode;
|
trampoline code which retries the message receive before running
|
||||||
ts->r7 = (int) scp;
|
the signal handler.
|
||||||
|
|
||||||
|
To do this we change the OPTION argument in its registers to
|
||||||
|
enable only message reception, since the request message has
|
||||||
|
already been sent. */
|
||||||
|
|
||||||
ts->r29 = (int) sigsp; /* r29 is the stack pointer register. */
|
/* The system call arguments are stored in consecutive registers
|
||||||
ts->pc = (int) &trampoline;
|
starting with a0 ($4). */
|
||||||
|
struct mach_msg_trap_args *args = (void *) &state->basic.r4;
|
||||||
|
|
||||||
|
assert (args->option & MACH_RCV_MSG);
|
||||||
|
/* Disable the message-send, since it has already completed. The
|
||||||
|
calls we retry need only wait to receive the reply message. */
|
||||||
|
args->option &= ~MACH_SEND_MSG;
|
||||||
|
|
||||||
|
state->basic.pc = (int) &&rpc_wait_trampoline;
|
||||||
|
state->basic.r29 = (int) sigsp; /* $29 is the stack pointer register. */
|
||||||
|
/* After doing the message receive, the trampoline code will need to
|
||||||
|
update the v0 ($2) value to be restored by sigreturn. To simplify
|
||||||
|
the assembly code, we pass the address of its slot in SCP to the
|
||||||
|
trampoline code in v1 ($3). */
|
||||||
|
state->basic.r3 = (int) &scp->sc_gpr[1];
|
||||||
|
/* We must preserve the mach_msg_trap args in a0..t2 ($4..$10).
|
||||||
|
Pass the handler args to the trampoline code in s1..s3 ($17..$19). */
|
||||||
|
state->basic.r17 = signo;
|
||||||
|
state->basic.r18 = sigcode;
|
||||||
|
state->basic.r19 = (int) scp;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
state->basic.pc = (int) &&trampoline;
|
||||||
|
state->basic.r29 = (int) sigsp;
|
||||||
|
state->basic.r4 = signo;
|
||||||
|
state->basic.r5 = sigcode;
|
||||||
|
state->basic.r6 = (int) scp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* We pass the handler function to the trampoline code in at ($1). */
|
||||||
|
state->basic.r1 = (int) handler;
|
||||||
|
/* In the callee-saved register s0 ($16), we save the SCP value to pass
|
||||||
|
to __sigreturn after the handler returns. */
|
||||||
|
state->basic.r16 = (int) scp;
|
||||||
|
|
||||||
return scp;
|
return scp;
|
||||||
|
|
||||||
|
/* The trampoline code follows. This is not actually executed as part of
|
||||||
|
this function, it is just convenient to write it that way. */
|
||||||
|
|
||||||
|
rpc_wait_trampoline:
|
||||||
|
/* This is the entry point when we have an RPC reply message to receive
|
||||||
|
before running the handler. The MACH_MSG_SEND bit has already been
|
||||||
|
cleared in the OPTION argument in our registers. For our convenience,
|
||||||
|
$3 points to the sc_gpr[1] member of the sigcontext (saved v0 ($2)). */
|
||||||
|
asm volatile
|
||||||
|
(".set noat; .set noreorder; .set nomacro\n"
|
||||||
|
/* Retry the interrupted mach_msg system call. */
|
||||||
|
"li v0, -25\n" /* mach_msg_trap */
|
||||||
|
"syscall\n"
|
||||||
|
/* When the sigcontext was saved, v0 was MACH_RCV_INTERRUPTED. But
|
||||||
|
now the message receive has completed and the original caller of
|
||||||
|
the RPC (i.e. the code running when the signal arrived) needs to
|
||||||
|
see the final return value of the message receive in v0. So
|
||||||
|
store the new v0 value into the sc_gpr[1] member of the sigcontext
|
||||||
|
(whose address is in v1 to make this code simpler). */
|
||||||
|
"sw v0, (v1)\n"
|
||||||
|
/* Since the argument registers needed to have the mach_msg_trap
|
||||||
|
arguments, we've stored the arguments to the handler function
|
||||||
|
in registers s1..s3 ($17..$19). */
|
||||||
|
"move a0, s1\n"
|
||||||
|
"move a1, s2\n"
|
||||||
|
"move a2, s3\n");
|
||||||
|
|
||||||
|
trampoline:
|
||||||
|
/* Entry point for running the handler normally. The arguments to the
|
||||||
|
handler function are already in the standard registers:
|
||||||
|
|
||||||
|
a0 SIGNO
|
||||||
|
a1 SIGCODE
|
||||||
|
a2 SCP
|
||||||
|
*/
|
||||||
|
asm volatile
|
||||||
|
("jal $1; nop\n" /* Call the handler function. */
|
||||||
|
/* Call __sigreturn (SCP); this cannot return. */
|
||||||
|
"j %0\n"
|
||||||
|
"move a0, s0" /* Set up arg from saved SCP in delay slot. */
|
||||||
|
: : "i" (&__sigreturn));
|
||||||
|
|
||||||
|
/* NOTREACHED */
|
||||||
|
asm volatile (".set reorder; .set at; .set macro");
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* STATE describes a thread that had intr_port set (meaning it was inside
|
||||||
|
HURD_EINTR_RPC), after it has been thread_abort'd. It it looks to have
|
||||||
|
just completed a mach_msg_trap system call that returned
|
||||||
|
MACH_RCV_INTERRUPTED, return nonzero and set *PORT to the receive right
|
||||||
|
being waited on. */
|
||||||
|
int
|
||||||
|
_hurdsig_rcv_interrupted_p (struct machine_thread_all_state *state,
|
||||||
|
mach_port_t *port)
|
||||||
|
{
|
||||||
|
if (! setjmp (_hurd_sigthread_fault_env))
|
||||||
|
{
|
||||||
|
const unsigned int *pc = (void *) state->basic.pc;
|
||||||
|
if (state->basic.r2 == MACH_RCV_INTERRUPTED &&
|
||||||
|
pc[-1] == 0xc) /* syscall */
|
||||||
|
{
|
||||||
|
/* We did just return from a mach_msg_trap system call
|
||||||
|
doing a message receive that was interrupted.
|
||||||
|
Examine the parameters to find the receive right. */
|
||||||
|
struct mach_msg_trap_args *args = (void *) &state->basic.r4;
|
||||||
|
|
||||||
|
*port = args->rcv_name;
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue