From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lf1-x131.google.com (mail-lf1-x131.google.com [IPv6:2a00:1450:4864:20::131]) by sourceware.org (Postfix) with ESMTPS id EBD013858C5E for ; Mon, 3 Apr 2023 11:56:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org EBD013858C5E Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-lf1-x131.google.com with SMTP id x17so37757069lfu.5 for ; Mon, 03 Apr 2023 04:56:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1680522998; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=3ea0O1nJlFYCtyK8nUkMBteBwkekOgxFB0F28qoLHxM=; b=GNz5HcxYbjscPh3SkWH2g3OOK8xPYAnPV+46A5c5Z50wKXAmY3k69ghrKEs8lOJo9x p4EjiH4Se+2aQk62yvVl6Ar6RgWFL5r9tcxrW9OUq7tuSlaii121u99VFI+65VBhw+qf Gfv8SPQKB4Gy4zmwkjpczBp3d2mNyHy/EV73rvCKgL7wF4mGfrx03yRMAt0cmhf6WFyF vgKV7J/HF67LBWHdc+1WIF8sm6mvqpx248C8AHxOI2L8gw2kezRYBji0XwpX0NfXAvOM 6IFu/CrI+QeZIHnx0e21HmwvnMb5cv6f/q6iIrRCJRpTtdaHEGaKlcDFL5lecX5MWi8X Utdw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680522998; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=3ea0O1nJlFYCtyK8nUkMBteBwkekOgxFB0F28qoLHxM=; b=t8lAbRShh73mPQMra2ygf0CG9s30lJmjI/pG8NWT+i3oA23VAHDeS8tHnQKeICv2by DvrAwhfkTXPfv+kSUxC6KXW3lNMYeyU6zYGGjTs+hxiRFXHSOwovYMiUiL/l+ZW8iqUZ jAUUxvvpV2EzF/2b4vcO+5+6H32ekm6JhaEKHZ4Xsrdt9khVN1mk/b18Pz3xD/6e7ZIn hZp/uJ8qPf5CATVb3PiXgG69J80l+7v1+n7vFXHlDQYkt9tn3Nac512qdGFTQGyTUKfC jll+hSyHcEES/0ybTuNrERcmGHCN600oy5jHTZBHm/F6mEkTVQTlWMcFibQPUsYa/Z1d Wpjw== X-Gm-Message-State: AAQBX9eZVCXWB7q9eGz/f3QqICrF11IFIOeELENzX0dehOAGtMuvtc8h rXLKFHuvJQoO4dZP5GRMn9EVEm9UmVs= X-Google-Smtp-Source: AKy350ZW/rF6ZRyyccX8TEtqE0GBCGdJQAFT3sN8rh5av0FImtvYuPW5K/5CLugMk5RN47ncCD06PQ== X-Received: by 2002:ac2:4219:0:b0:4db:28ce:e5ef with SMTP id y25-20020ac24219000000b004db28cee5efmr9297983lfh.0.1680522998157; Mon, 03 Apr 2023 04:56:38 -0700 (PDT) Received: from surface-pro-6.. ([194.190.106.50]) by smtp.gmail.com with ESMTPSA id q7-20020ac25147000000b0048a9e899693sm1752524lfd.16.2023.04.03.04.56.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 03 Apr 2023 04:56:37 -0700 (PDT) From: Sergey Bugaev To: bug-hurd@gnu.org, libc-alpha@sourceware.org Cc: Samuel Thibault , Sergey Bugaev Subject: [PATCH v2 18.2/34] hurd: Port trampoline.c to x86_64 Date: Mon, 3 Apr 2023 14:56:21 +0300 Message-Id: <20230403115621.258636-3-bugaevc@gmail.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230403115621.258636-1-bugaevc@gmail.com> References: <20230319151017.531737-19-bugaevc@gmail.com> <20230403115621.258636-1-bugaevc@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-11.0 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM,GIT_PATCH_0,KAM_NUMSUBJECT,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: Signed-off-by: Sergey Bugaev --- sysdeps/mach/hurd/{i386 => x86}/trampoline.c | 158 ++++++++++++++++++- 1 file changed, 151 insertions(+), 7 deletions(-) rename sysdeps/mach/hurd/{i386 => x86}/trampoline.c (68%) diff --git a/sysdeps/mach/hurd/i386/trampoline.c b/sysdeps/mach/hurd/x86/trampoline.c similarity index 68% rename from sysdeps/mach/hurd/i386/trampoline.c rename to sysdeps/mach/hurd/x86/trampoline.c index 9cd60b9c..e13c5d85 100644 --- a/sysdeps/mach/hurd/i386/trampoline.c +++ b/sysdeps/mach/hurd/x86/trampoline.c @@ -1,4 +1,4 @@ -/* Set thread_state for sighandler, and sigcontext to recover. i386 version. +/* Set thread_state for sighandler, and sigcontext to recover. x86 version. Copyright (C) 1994-2023 Free Software Foundation, Inc. This file is part of the GNU C Library. @@ -46,7 +46,13 @@ static void fill_siginfo (siginfo_t *si, int signo, if (detail->exc == EXC_BAD_ACCESS) si->si_addr = (void *) detail->exc_subcode; else - si->si_addr = (void *) state->basic.eip; + { +#ifdef __x86_64__ + si->si_addr = (void *) state->basic.rip; +#else + si->si_addr = (void *) state->basic.eip; +#endif + } /* XXX On SIGCHLD, this should be the exit status of the child * process. We would need a protocol change for the proc server @@ -63,17 +69,26 @@ static void fill_ucontext (ucontext_t *uc, const struct sigcontext *sc) uc->uc_flags = 0; uc->uc_link = NULL; uc->uc_sigmask = sc->sc_mask; +#ifdef __x86_64__ + uc->uc_stack.ss_sp = (__ptr_t) sc->sc_ursp; +#else uc->uc_stack.ss_sp = (__ptr_t) sc->sc_uesp; +#endif uc->uc_stack.ss_size = 0; uc->uc_stack.ss_flags = 0; /* Registers. */ +#ifdef __x86_64__ + memcpy (&uc->uc_mcontext.gregs[REG_GSFS], &sc->sc_gs, + (REG_ERR - REG_GSFS) * sizeof (long)); +#else memcpy (&uc->uc_mcontext.gregs[REG_GS], &sc->sc_gs, - (REG_TRAPNO - REG_GS) * sizeof (int)); - uc->uc_mcontext.gregs[REG_TRAPNO] = 0; - uc->uc_mcontext.gregs[REG_ERR] = 0; + (REG_TRAPNO - REG_GS) * sizeof (int)); memcpy (&uc->uc_mcontext.gregs[REG_EIP], &sc->sc_eip, (NGREG - REG_EIP) * sizeof (int)); +#endif + uc->uc_mcontext.gregs[REG_TRAPNO] = 0; + uc->uc_mcontext.gregs[REG_ERR] = 0; /* XXX FPU state. */ memset (&uc->uc_mcontext.fpregs, 0, sizeof (fpregset_t)); @@ -93,7 +108,14 @@ _hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action struct sigcontext *scp; struct { - int signo; + union + { + int signo; + /* Make sure signo takes up a pointer-sized slot on the stack. + (This should already be the case considering the siginfop + pointer below, but better be explicit.) */ + void *_pointer_sized; + }; union { /* Extra arguments for traditional signal handlers */ @@ -110,6 +132,10 @@ _hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action ucontext_t *uctxp; /* Points to uctx, below. */ } posix; }; + +#ifdef __x86_64__ + void *_pad; +#endif void *sigreturn_addr; void *sigreturn_returns_here; struct sigcontext *return_scp; /* Same; arg to sigreturn. */ @@ -121,6 +147,11 @@ _hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action siginfo_t siginfo; } *stackframe; +#ifdef __x86_64__ + _Static_assert (offsetof (typeof (*stackframe), sigreturn_addr) % 16 == 0, + "sigreturn_addr must be 16-byte aligned"); +#endif + if (ss->context) { /* We have a previous sigcontext that sigreturn was about @@ -142,7 +173,11 @@ _hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action /* Save the original SP in the gratuitous `esp' slot. We may need to reset the SP (the `uesp' slot) to avoid clobbering an interrupted RPC frame. */ +#ifdef __x86_64__ + state->basic.rsp = state->basic.ursp; +#else state->basic.esp = state->basic.uesp; +#endif if ((action->sa_flags & SA_ONSTACK) && !(ss->sigaltstack.ss_flags & (SS_DISABLE|SS_ONSTACK))) @@ -151,7 +186,22 @@ _hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action ss->sigaltstack.ss_flags |= SS_ONSTACK; } else - sigsp = (char *) state->basic.uesp; + { +#ifdef __x86_64__ + /* Per the ABI, we're not supposed to clobber 128 bytes below + SP -- the red zone. */ + sigsp = (char *) state->basic.ursp - 128; +#else + sigsp = (char *) state->basic.uesp; +#endif + } + +#ifdef __x86_64__ + /* Align SP at 16 bytes. Coupled with the fact that sigreturn_addr is + 16-byte aligned within the stackframe struct, this ensures that it ends + up on a 16-byte aligned address, as required by the ABI. */ + sigsp = (void *) ((uintptr_t) sigsp & 16UL); +#endif /* Push the arguments to call `trampoline' on the stack. */ sigsp -= sizeof (*stackframe); @@ -238,6 +288,52 @@ _hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action } /* Modify the thread state to call the trampoline code on the new stack. */ +#ifdef __x86_64__ + if (rpc_wait) + { + /* The signalee thread was blocked in a mach_msg_trap system call, + still waiting for a reply. We will have it run the special + trampoline code which retries the message receive before running + the signal handler. + + To do this we change the OPTION argument (in rsi) to enable only + message reception, since the request message has already been + sent. */ + + assert (state->basic.rsi & MACH_RCV_MSG); + /* Disable the message-send, since it has already completed. The + calls we retry need only wait to receive the reply message. */ + state->basic.rsi &= ~MACH_SEND_MSG; + + /* Limit the time to receive the reply message, in case the server + claimed that `interrupt_operation' succeeded but in fact the RPC + is hung. */ + state->basic.rsi |= MACH_RCV_TIMEOUT; + state->basic.r9 = _hurd_interrupted_rpc_timeout; + + state->basic.rip = (uintptr_t) rpc_wait_trampoline; + /* The reply-receiving trampoline code runs initially on the original + user stack. We pass it the signal stack pointer in %rbx. */ + state->basic.rbx = (uintptr_t) sigsp; + /* After doing the message receive, the trampoline code will need to + update the %rax 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 %r12. */ + state->basic.r12 = (uintptr_t) &scp->sc_rax; + } + else + { + state->basic.rip = (uintptr_t) trampoline; + state->basic.ursp = (uintptr_t) sigsp; + } + /* We pass the handler function to the trampoline code in %r13. */ + state->basic.r13 = (uintptr_t) handler; + + /* The x86 ABI says the DF bit is clear on entry to any function. */ + state->basic.rfl &= ~EFL_DF; + +#else + if (rpc_wait) { /* The signalee thread was blocked in a mach_msg_trap system call, @@ -290,6 +386,7 @@ _hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action /* The x86 ABI says the DF bit is clear on entry to any function. */ state->basic.efl &= ~EFL_DF; +#endif return scp; } @@ -301,6 +398,52 @@ _hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action - in gcc: libgcc/config/i386/gnu-unwind.h x86_gnu_fallback_frame_state, - in gdb: gdb/i386-gnu-tdep.c gnu_sigtramp_code. */ +#ifdef __x86_64__ +asm ("rpc_wait_trampoline:\n" + /* 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 %rsi. The interrupted user + stack pointer has not been changed, so the system call can find its + arguments; the signal stack pointer is in %rbx. For our convenience, + %r12 points to the sc_rax member of the sigcontext. */ + "movq $-25, %rax\n" /* mach_msg_trap */ + "syscall\n" + /* When the sigcontext was saved, %rax 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 %rax. So + store the new %rax value into the sc_rax member of the sigcontext + (whose address is in %r12 to make this code simpler). */ + "movq %rax, (%r12)\n" + /* Switch to the signal stack. */ + "movq %rbx, %rsp\n" + + "trampoline:\n" + /* Entry point for running the handler normally. The arguments to the + handler function are on the top of the stack, same as in the i386 + version: + + 0(%rsp) SIGNO + 8(%rsp) SIGCODE + 16(%rsp) SCP + + Pop them off to the registers, to pass as arguments to the handler. + */ + "popq %rdi\n" + "popq %rsi\n" + "popq %rdx\n" + /* Pop the _pad member to make the stack 16-byte aligned, as per the + ABI. */ + "addq $8, %rsp\n" + "call *%r13\n" /* Call the handler function. */ + /* The word at the top of stack is &__sigreturn; following are a dummy + word to fill the slot for the address for __sigreturn to return to, + and a copy of SCP for __sigreturn's argument. Load the SCP as for a + call, and "return" to calling __sigreturn (SCP); this call never + returns. */ + "movq 16(%rsp), %rdi\n" + "ret"); +#else asm ("rpc_wait_trampoline:\n"); /* 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 @@ -336,6 +479,7 @@ asm ("call *%edx\n" /* Call the handler function. */ and a copy of SCP for __sigreturn's argument. "Return" to calling __sigreturn (SCP); this call never returns. */ "ret"); +#endif asm ("firewall:\n" "hlt"); -- 2.39.2