[RFC,17/34] hurd: Implement x86_64/intr-msg.h

  Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---

This is a prelimenary version of intr-msg.h. I can't know whether or not
it works until we can test it. The code relies on syscall preserving values
of the registers used to pass syscall arguments. The code in SYSCALL_EXAMINE
that just compares two bytes to the encoded syscall instruction is sure to
give many false positives; we're going to need to come up with a more reliable
scheme.

 sysdeps/mach/hurd/x86_64/intr-msg.h | 119 ++++++++++++++++++++++++++++
 1 file changed, 119 insertions(+)
 create mode 100644 sysdeps/mach/hurd/x86_64/intr-msg.h
  

Applied, thanks!

Sergey Bugaev, le dim. 19 mars 2023 18:10:00 +0300, a ecrit:
> This is a prelimenary version of intr-msg.h. I can't know whether or not
> it works until we can test it.

Sure :)

> The code relies on syscall preserving values
> of the registers used to pass syscall arguments. The code in SYSCALL_EXAMINE
> that just compares two bytes to the encoded syscall instruction is sure to
> give many false positives; we're going to need to come up with a more reliable
> scheme.

Not necessarily: this is only used for msg_report_wait, which is already
extra cautious about what it's doing, at worse it will report dumb
information, which should be fine enough for msg_report_wait.  Possibly
we could filter out by addresses of the functions known to perform an
actual system call.

Samuel

>  sysdeps/mach/hurd/x86_64/intr-msg.h | 119 ++++++++++++++++++++++++++++
>  1 file changed, 119 insertions(+)
>  create mode 100644 sysdeps/mach/hurd/x86_64/intr-msg.h
> 
> diff --git a/sysdeps/mach/hurd/x86_64/intr-msg.h b/sysdeps/mach/hurd/x86_64/intr-msg.h
> new file mode 100644
> index 00000000..5d94c85f
> --- /dev/null
> +++ b/sysdeps/mach/hurd/x86_64/intr-msg.h
> @@ -0,0 +1,119 @@
> +/* Machine-dependent details of interruptible RPC messaging.  x86_64 version.
> +   Copyright (C) 1995-2023 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
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   The GNU C Library is distributed in the hope that it will be useful,
> +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with the GNU C Library; if not, see
> +   <https://www.gnu.org/licenses/>.  */
> +
> +
> +/* 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, cancel_p, intr_port_p) \
> +({									      \
> +  error_t err;								      \
> +  register uintptr_t rcv_size_r10 asm ("r10") = rcv_size;		      \
> +  register uintptr_t rcv_name_r8 asm ("r8") = rcv_name;			      \
> +  register uintptr_t timeout_r9 asm ("r9") = timeout;			      \
> +  asm volatile (							      \
> +       ".globl _hurd_intr_rpc_msg_about_to\n"				      \
> +       ".globl _hurd_intr_rpc_msg_setup_done\n"				      \
> +       ".globl _hurd_intr_rpc_msg_in_trap\n"				      \
> +       /* Clear rax before we do the check for cancel below.  This is to
> +          detect rax being set to non-zero (actually MACH_SEND_INTERRUPTED)
> +          from the outside (namely, _hurdsig_abort_rpcs), which signals us
> +          to skip the trap we were about to enter.  */			      \
> +       "				xor %[err], %[err]\n"		      \
> +       "_hurd_intr_rpc_msg_about_to:"					      \
> +       /* We need to make a last check of cancel, in case we got interrupted
> +          right before _hurd_intr_rpc_msg_about_to.  */			      \
> +       "				cmpl $0, %[cancel]\n"		      \
> +       "				jz _hurd_intr_rpc_msg_do\n"	      \
> +       /* We got interrupted, note so and return EINTR.  */		      \
> +       "				movl $0, %[intr_port]\n"	      \
> +       "				movl %[eintr], %[err]\n"	      \
> +       "				jmp _hurd_intr_rpc_msg_sp_restored\n" \
> +       "_hurd_intr_rpc_msg_do:"						      \
> +       /* Ok, prepare the mach_msg_trap arguments.  We pass the first 6 args
> +          in registers, and push the last one and a fake return address.  */  \
> +       "				pushq %[notify]\n"		      \
> +       "				pushq $0\n"			      \
> +       "_hurd_intr_rpc_msg_setup_done:"					      \
> +       /* From here on, it is safe to make us jump over the syscall.  Now
> +          check if we have been told to skip the syscall while running
> +          the above.  */						      \
> +       "				test %[err], %[err]\n"		      \
> +       "				jnz _hurd_intr_rpc_msg_in_trap\n"     \
> +       /* Do the actual syscall.  */					      \
> +       "				movq $-25, %%rax\n"		      \
> +       "_hurd_intr_rpc_msg_do_trap:	syscall # status in %[err]\n"	      \
> +       "_hurd_intr_rpc_msg_in_trap:"					      \
> +       /* Clean the arguments.  */					      \
> +       "				addq $16, %%rsp\n"		      \
> +       "_hurd_intr_rpc_msg_sp_restored:"				      \
> +       : [err] "=&a" (err), "+S" (option), [intr_port] "=m" (*intr_port_p),   \
> +         "+r" (timeout_r9)						      \
> +       : "D" (msg), "d" (send_size), "r" (rcv_size_r10), "r" (rcv_name_r8),   \
> +         [notify] "rm" ((uintptr_t) notify), [cancel] "m" (*cancel_p),	      \
> +         [eintr] "i" (EINTR)						      \
> +       : "rcx", "r11");							      \
> +  timeout = timeout_r9;							      \
> +  err;									      \
> +})
> +
> +#include "hurdfault.h"
> +
> +/* This cannot be an inline function because it calls setjmp.  */
> +#define SYSCALL_EXAMINE(state, callno)					      \
> +({									      \
> +  struct { unsigned char c[2]; } *p = (void *) ((state)->rip - 2);	      \
> +  int result;								      \
> +  if (_hurdsig_catch_memory_fault (p))					      \
> +    return 0;								      \
> +  if (result = p->c[0] == 0xf && p->c[1] == 0x5)			      \
> +    /* The PC appears to be just after a `syscall' instruction.		      \
> +       This is a system call in progress; %rax holds the call number.  */     \
> +    *(callno) = (state)->rax;						      \
> +  _hurdsig_end_catch_fault ();						      \
> +  result;								      \
> +})
> +
> +
> +/* This cannot be an inline function because it calls setjmp.  */
> +#define MSG_EXAMINE(state, msgid, rcvname, send_name, opt, tmout)	      \
> +({									      \
> +  int ret = 0;								      \
> +  const struct machine_thread_state *s = (state);			      \
> +  const mach_msg_header_t *msg = (const void *) s->rdi;			      \
> +  *(rcvname) = s->r8;							      \
> +  *(opt) = s->rsi;							      \
> +  *(tmout) = s->r9;							      \
> +  if (msg == 0)								      \
> +    {									      \
> +      *(send_name) = MACH_PORT_NULL;					      \
> +      *(msgid) = 0;							      \
> +    }									      \
> +  else									      \
> +    {									      \
> +      ret = _hurdsig_catch_memory_fault (msg) ? -1 : 0;			      \
> +      if (ret == 0)							      \
> +        {								      \
> +          *(send_name) = msg->msgh_remote_port;				      \
> +          *(msgid) = msg->msgh_id;					      \
> +          _hurdsig_end_catch_fault ();					      \
> +	}								      \
> +    }									      \
> +  ret;									      \
> +})
> -- 
> 2.39.2
>