diff options
| -rw-r--r-- | hurd/intr-msg.c | 188 | ||||
| -rw-r--r-- | sysdeps/mach/hurd/i386/intr-msg.h | 11 |
2 files changed, 140 insertions, 59 deletions
diff --git a/hurd/intr-msg.c b/hurd/intr-msg.c index 2efde2cc9a..a847cff474 100644 --- a/hurd/intr-msg.c +++ b/hurd/intr-msg.c @@ -21,6 +21,7 @@ #include <mach/mig_errors.h> #include <mach/mig_support.h> #include <hurd/signal.h> +#include <assert.h> #include "intr-msg.h" @@ -36,39 +37,75 @@ _hurd_intr_rpc_mach_msg (mach_msg_header_t *msg, { error_t err; struct hurd_sigstate *ss; - int user_timeout; - - if (_hurd_msgport_thread == MACH_PORT_NULL) + const mach_msg_option_t user_option = option; + const mach_msg_timeout_t user_timeout = timeout; + + struct clobber { int i[2]; }; + union msg + { + mach_msg_header_t header; + mig_reply_header_t reply; + struct + { + mach_msg_header_t header; + int type; + int code; + } check; + struct { - /* The signal thread is not set up yet, so we cannot do the - normal signal magic. Do a simple uninterruptible RPC instead. */ - return __mach_msg (msg, option, send_size, rcv_size, rcv_name, + mach_msg_header_t header; + struct clobber data; + } request; + }; + union msg *const m = (void *) msg; + mach_msg_bits_t msgh_bits; + mach_port_t remote_port; + mach_msg_id_t msgid; + struct clobber save_data; + + if ((option & (MACH_SEND_MSG|MACH_RCV_MSG)) != (MACH_SEND_MSG|MACH_RCV_MSG) + || _hurd_msgport_thread == MACH_PORT_NULL) + { + /* Either this is not an RPC (i.e., only a send or only a receive), + so it can't be interruptible; or, the signal thread is not set up + yet, so we cannot do the normal signal magic. Do a normal, + uninterruptible mach_msg call instead. */ + return __mach_msg (&m->header, option, send_size, rcv_size, rcv_name, timeout, notify); } ss = _hurd_self_sigstate (); - /* Notice now if the user requested a timeout. OPTION may have the bit - added by interruption semantics, and we must distinguish. */ - user_timeout = option & MACH_RCV_TIMEOUT; + /* Save state that gets clobbered by an EINTR reply message. + We will need to restore it if we want to retry the RPC. */ + msgh_bits = m->header.msgh_bits; + remote_port = m->header.msgh_remote_port; + msgid = m->header.msgh_id; + assert (rcv_size >= sizeof m->request); + save_data = m->request.data; /* Tell the signal thread that we are doing an interruptible RPC on this port. If we get a signal and should return EINTR, the signal thread will set this variable to MACH_PORT_NULL. The RPC might return EINTR when some other thread gets a signal, in which case we want to restart our call. */ - ss->intr_port = msg->msgh_remote_port; + ss->intr_port = m->header.msgh_remote_port; - /* A signal may arrive here, after intr_port is set, but before - the mach_msg system call. The signal handler might do an - interruptible RPC, and clobber intr_port; then it would not be - set properly when we actually did send the RPC, and a later - signal wouldn't interrupt that RPC. So, - _hurd_setup_sighandler saves intr_port in the sigcontext, and - sigreturn restores it. */ + /* A signal may arrive here, after intr_port is set, but before the + mach_msg system call. The signal handler might do an interruptible + RPC, and clobber intr_port; then it would not be set properly when we + actually did send the RPC, and a later signal wouldn't interrupt that + RPC. So, _hurd_setup_sighandler saves intr_port in the sigcontext, + and sigreturn restores it. */ message: + /* XXX + At all points here (once SS->intr_port is set), the signal thread + thinks we are "about to enter the syscall", and might mutate our + return-value register. This is bogus. + */ + if (ss->cancel) { /* We have been cancelled. Don't do an RPC at all. */ @@ -77,13 +114,14 @@ _hurd_intr_rpc_mach_msg (mach_msg_header_t *msg, return EINTR; } + /* Note that the signal trampoline code might modify our OPTION! */ err = INTR_MSG_TRAP (msg, option, send_size, rcv_size, rcv_name, timeout, notify); switch (err) { case MACH_RCV_TIMED_OUT: - if (user_timeout) + if (user_option & MACH_RCV_TIMEOUT) /* The real user RPC timed out. */ break; else @@ -92,18 +130,34 @@ _hurd_intr_rpc_mach_msg (mach_msg_header_t *msg, goto interrupted; case MACH_SEND_INTERRUPTED: /* RPC didn't get out. */ - case EINTR: /* Server not cooperating with interrupt. */ + if (!(option & MACH_SEND_MSG)) + { + /* Oh yes, it did! Since we were not doing a message send, + this return code cannot have come from the kernel! + Instead, it was the signal thread mutating our state to tell + us not to enter this RPC. However, we are already in the receive! + Since the signal thread thought we weren't in the RPC yet, + it didn't do an interrupt_operation. + XXX */ + goto retry_receive; + } + /* FALLTHROUGH */ + + case EINTR: + /* Either the process was stopped and continued, + or the server doesn't support interrupt_operation. */ if (ss->intr_port != MACH_PORT_NULL) /* If this signal was for us and it should interrupt calls, the signal thread will have cleared SS->intr_port. Since it's not cleared, the signal was for another thread, or SA_RESTART is set. Restart the interrupted call. */ { - restart: - if (rcv_name != MACH_PORT_NULL) - /* Make sure we have a valid reply port. The one we were using - may have been destroyed by interruption. */ - msg->msgh_local_port = rcv_name = __mig_get_reply_port (); + /* Make sure we have a valid reply port. The one we were using + may have been destroyed by interruption. */ + m->header.msgh_local_port = rcv_name = __mig_get_reply_port (); + m->header.msgh_bits = msgh_bits; + option = user_option; + timeout = user_timeout; goto message; } /* FALLTHROUGH */ @@ -122,52 +176,74 @@ _hurd_intr_rpc_mach_msg (mach_msg_header_t *msg, case MACH_RCV_INTERRUPTED: /* RPC sent; no reply. */ option &= ~MACH_SEND_MSG; /* Don't send again. */ + retry_receive: if (ss->intr_port == MACH_PORT_NULL) { /* This signal or cancellation was for us. We need to wait for the reply, but not hang forever. */ option |= MACH_RCV_TIMEOUT; /* Never decrease the user's timeout. */ - if (!user_timeout || timeout > _hurd_interrupted_rpc_timeout) + if (!(user_option & MACH_RCV_TIMEOUT) + || timeout > _hurd_interrupted_rpc_timeout) timeout = _hurd_interrupted_rpc_timeout; } + else + { + option = user_option; + timeout = user_timeout; + } goto message; /* Retry the receive. */ case MACH_MSG_SUCCESS: - if (option & MACH_RCV_MSG) + { + /* We got a reply. Was it EINTR? */ + const union { - /* We got a reply. Was it EINTR? */ - mig_reply_header_t *const reply = (void *) msg; - const union - { - mach_msg_type_t t; - integer_t i; - } check = - { t: { - MACH_MSG_TYPE_INTEGER_T, - sizeof (integer_t) * 8, - 1, - TRUE, - FALSE, - FALSE, - 0 - } }; - if (msg->msgh_size == sizeof *reply && - !(msg->msgh_bits & MACH_MSGH_BITS_COMPLEX) && - *(int *) &reply->RetCodeType == check.i && - reply->RetCode == EINTR) - { - /* It is indeed EINTR. Is the interrupt for us? */ - if (ss->intr_port != MACH_PORT_NULL) + mach_msg_type_t t; + int i; + } check = + { t: { MACH_MSG_TYPE_INTEGER_T, sizeof (integer_t) * 8, + 1, TRUE, FALSE, FALSE, 0 } }; + + if (m->reply.RetCode == EINTR && + m->header.msgh_size == sizeof m->reply && + m->check.type == check.i && + !(m->header.msgh_bits & MACH_MSGH_BITS_COMPLEX)) + { + /* It is indeed EINTR. Is the interrupt for us? */ + if (ss->intr_port != MACH_PORT_NULL) + { /* Nope; repeat the RPC. XXX Resources moved? */ - goto restart; - else - /* The EINTR return indicates cancellation, so clear the - flag. */ - ss->cancel = 0; - } - } + + assert (m->header.msgh_id == msgid + 100); + + /* We know we have a valid reply port, because we just + received the EINTR reply on it. Restore it and the + other fields in the message header needed for send, + since the header now reflects receipt of the reply. */ + m->header.msgh_local_port = rcv_name; + m->header.msgh_remote_port = remote_port; + m->header.msgh_id = msgid; + m->header.msgh_bits = msgh_bits; + /* Restore the two words clobbered by the reply data. */ + m->request.data = save_data; + + /* Restore the original mach_msg options. + OPTION may have had MACH_RCV_TIMEOUT added, + and/or MACH_SEND_MSG removed. */ + option = user_option; + timeout = user_timeout; + + /* Now we are ready to repeat the original message send. */ + goto message; + } + else + /* The EINTR return indicates cancellation, + so clear the flag. */ + ss->cancel = 0; + } + } break; default: /* Quiet -Wswitch-enum. */ diff --git a/sysdeps/mach/hurd/i386/intr-msg.h b/sysdeps/mach/hurd/i386/intr-msg.h index c011447543..a12b2f2174 100644 --- a/sysdeps/mach/hurd/i386/intr-msg.h +++ b/sysdeps/mach/hurd/i386/intr-msg.h @@ -1,5 +1,5 @@ /* Machine-dependent details of interruptible RPC messaging. i386 version. - Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc. + Copyright (C) 1995, 1996, 1997, 1999 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or @@ -18,6 +18,9 @@ Boston, MA 02111-1307, USA. */ +/* Note that we must mark OPTION and TIMEOUT as outputs of this operation, + to indicate that the signal thread might mutate them as part + of sending us to a signal handler. */ #define INTR_MSG_TRAP(msg, option, send_size, rcv_size, rcv_name, timeout, notify) \ ({ \ error_t err; \ @@ -26,12 +29,14 @@ ".globl _hurd_intr_rpc_msg_cx_sp\n" \ ".globl _hurd_intr_rpc_msg_sp_restored\n" \ " movl %%esp, %%ecx\n" \ - " leal %1, %%esp\n" \ + " leal %3, %%esp\n" \ "_hurd_intr_rpc_msg_cx_sp: movl $-25, %%eax\n" \ "_hurd_intr_rpc_msg_do_trap: lcall $7, $0 # status in %0\n" \ "_hurd_intr_rpc_msg_in_trap: movl %%ecx, %%esp\n" \ "_hurd_intr_rpc_msg_sp_restored:" \ - : "=a" (err) : "m" ((&msg)[-1]) : "%ecx"); \ + : "=a" (err), "=m" (option), "=m" (timeout) \ + : "m" ((&msg)[-1]), "1" (option), "2" (timeout) \ + : "%ecx"); \ err; \ }) |