From patchwork Thu Mar 13 10:45:41 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Will Newton X-Patchwork-Id: 26198 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-pb0-f72.google.com (mail-pb0-f72.google.com [209.85.160.72]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 0B65B206A0 for ; Thu, 13 Mar 2014 10:46:17 +0000 (UTC) Received: by mail-pb0-f72.google.com with SMTP id jt11sf1998337pbb.3 for ; Thu, 13 Mar 2014 03:46:17 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:delivered-to:mailing-list :precedence:list-id:list-unsubscribe:list-subscribe:list-archive :list-post:list-help:sender:delivered-to:from:to:subject:date :message-id:in-reply-to:references:x-original-sender :x-original-authentication-results; bh=14fHQSwGraUEZFhwpaVq1C+0o+O4M1OMbCH+MG7QUhI=; b=FOorgb+dXFUEdq2vnhuEhKA+Qff4I5jF+pGIob3z9O8ev4ZLfq3a58G1hh//NlIXGJ azvVdH/lc9eaXRIPGj+A2KPSfYeaXJToPJ7RgEj0VdhbeCo1kDKw2bEXmuSP2vnSWDI2 GmGOMbVkhLv7N0bjo/iTV3jrwtzlhd4DbQkBZzPq4CngmzlQGKVC9JsQ7C3Ke2+zGfd6 6hRtXlqowWGgvHaPd19rgemxjKixg1XtaFifHDl3THtz6W7Uzv9dUh6nXY15MM7l1H7I S0Akoz7+M68fRpt8ggtd5UVVbiFb7LxXTCGTOH38T4e9qWUI5AXb5OIEG7o+/Hbq7EeQ jZsg== X-Gm-Message-State: ALoCoQk/QrtirLxbNBi7J/o0JXntp8kdHFZwwGPRi7RKcAgVmLjuHcLSwq3PrQVj6CnlXh0blCYm X-Received: by 10.68.253.66 with SMTP id zy2mr472239pbc.1.1394707577078; Thu, 13 Mar 2014 03:46:17 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.140.44.101 with SMTP id f92ls215787qga.61.gmail; Thu, 13 Mar 2014 03:46:16 -0700 (PDT) X-Received: by 10.221.22.71 with SMTP id qv7mr183685vcb.34.1394707576909; Thu, 13 Mar 2014 03:46:16 -0700 (PDT) Received: from mail-ve0-x233.google.com (mail-ve0-x233.google.com [2607:f8b0:400c:c01::233]) by mx.google.com with ESMTPS id ie18si144034vec.89.2014.03.13.03.46.16 for (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Thu, 13 Mar 2014 03:46:16 -0700 (PDT) Received-SPF: neutral (google.com: 2607:f8b0:400c:c01::233 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) client-ip=2607:f8b0:400c:c01::233; Received: by mail-ve0-f179.google.com with SMTP id db12so853473veb.38 for ; Thu, 13 Mar 2014 03:46:16 -0700 (PDT) X-Received: by 10.58.154.10 with SMTP id vk10mr868769veb.18.1394707573641; Thu, 13 Mar 2014 03:46:13 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.220.78.9 with SMTP id i9csp357643vck; Thu, 13 Mar 2014 03:46:13 -0700 (PDT) X-Received: by 10.68.218.3 with SMTP id pc3mr1364694pbc.71.1394707572620; Thu, 13 Mar 2014 03:46:12 -0700 (PDT) Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id pk2si1893406pbb.179.2014.03.13.03.46.12 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 13 Mar 2014 03:46:12 -0700 (PDT) Received-SPF: pass (google.com: domain of libc-alpha-return-48041-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Received: (qmail 28857 invoked by alias); 13 Mar 2014 10:45:55 -0000 Mailing-List: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org Precedence: list List-Id: List-Unsubscribe: , List-Subscribe: List-Archive: List-Post: , List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 28754 invoked by uid 89); 13 Mar 2014 10:45:55 -0000 X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.8 required=5.0 tests=AWL, BAYES_00, KAM_STOCKGEN, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=no version=3.3.2 X-HELO: mail-wg0-f42.google.com X-Received: by 10.180.149.206 with SMTP id uc14mr1078020wib.10.1394707549994; Thu, 13 Mar 2014 03:45:49 -0700 (PDT) From: Will Newton To: libc-alpha@sourceware.org Subject: [PATCH 2/4] aarch64: Re-implement setcontext without sigreturn syscall Date: Thu, 13 Mar 2014 10:45:41 +0000 Message-Id: <1394707543-9690-2-git-send-email-will.newton@linaro.org> In-Reply-To: <1394707543-9690-1-git-send-email-will.newton@linaro.org> References: <1394707543-9690-1-git-send-email-will.newton@linaro.org> X-Original-Sender: will.newton@linaro.org X-Original-Authentication-Results: mx.google.com; spf=neutral (google.com: 2607:f8b0:400c:c01::233 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org; dkim=pass header.i=@sourceware.org X-Google-Group-Id: 836684582541 The current implementation of setcontext uses sigreturn to restore the contents of registers. This contrasts with the way most other architectures implement setcontext: powerpc, mips, tile: Call sigreturn if context was created by a call to a signal handler, otherwise restore in user code. x86_64, sparc, hppa, sh, ia64, m68k, s390, arm: Only support restoring "synchronous" contexts, that is contexts created by getcontext, and restoring in user code. alpha, aarch64: Call sigreturn in all cases to do the restore. The text of the setcontext manpage suggests that the requirement to be able to restore a signal handler created context has been dropped from SUSv2: If the context was obtained by a call to a signal handler, then old standard text says that "program execution continues with the program instruction following the instruction interrupted by the signal". However, this sentence was removed in SUSv2, and the present verdict is "the result is unspecified". Implementing setcontext by calling sigreturn unconditionally causes problems when used with sigaltstack as in BZ #16629. On this basis it seems that aarch64 and likely alpha are broken and that new ports should only support restoring contexts created with getcontext and do not need to call sigreturn at all. This patch re-implements the aarch64 setcontext function to restore the context in user code in a similar manner to x86_64 and other ports. ChangeLog: 2014-03-13 Will Newton [BZ #16629] * sysdeps/unix/sysv/linux/aarch64/setcontext.S (__setcontext): Re-implement to restore registers in user code and avoid sigreturn system call. --- sysdeps/unix/sysv/linux/aarch64/setcontext.S | 139 +++++++++++++++++---------- 1 file changed, 88 insertions(+), 51 deletions(-) diff --git a/sysdeps/unix/sysv/linux/aarch64/setcontext.S b/sysdeps/unix/sysv/linux/aarch64/setcontext.S index d220c41..2a70cc2 100644 --- a/sysdeps/unix/sysv/linux/aarch64/setcontext.S +++ b/sysdeps/unix/sysv/linux/aarch64/setcontext.S @@ -22,63 +22,100 @@ #include "ucontext_i.h" #include "ucontext-internal.h" -/* int setcontext (const ucontext_t *ucp) */ +/* int __setcontext (const ucontext_t *ucp) - .text - -ENTRY(__setcontext) - - /* Create a signal frame on the stack: - - fp - lr - ... - sp-> rt_sigframe - */ - - stp x29, x30, [sp, -16]! - cfi_adjust_cfa_offset (16) - cfi_rel_offset (x29, 0) - cfi_rel_offset (x30, 8) - - mov x29, sp - cfi_def_cfa_register (x29) - - /* Allocate space for the sigcontext. */ - mov w3, #((RT_SIGFRAME_SIZE + SP_ALIGN_SIZE) & SP_ALIGN_MASK) - sub sp, sp, x3 + Restores the machine context in UCP and thereby resumes execution + in that context. - /* Compute the base address of the ucontext structure. */ - add x1, sp, #RT_SIGFRAME_UCONTEXT + This implementation is intended to be used for *synchronous* context + switches only. Therefore, it does not have to restore anything + other than the PRESERVED state. */ - /* Only ucontext is required in the frame, *copy* it in. */ - -#if UCONTEXT_SIZE % 16 -#error The implementation of setcontext.S assumes sizeof(ucontext_t) % 16 == 0 -#endif - - mov x2, #UCONTEXT_SIZE / 16 -0: - ldp x3, x4, [x0], #16 - stp x3, x4, [x1], #16 - sub x2, x2, 1 - cbnz x2, 0b + .text - /* rt_sigreturn () -- no arguments, sp points to struct rt_sigframe. */ - mov x8, SYS_ify (rt_sigreturn) +ENTRY(__setcontext) + /* Save a copy of UCP. */ + mov x9, x0 + + /* Set the signal mask with + rt_sigprocmask (SIG_SETMASK, mask, NULL, _NSIG/8). */ + mov x0, #SIG_SETMASK + ldr x1, [x9, UCONTEXT_SIGMASK] + mov x2, #0 + mov x3, #_NSIG8 + mov x8, SYS_ify (rt_sigprocmask) svc 0 - - /* Ooops we failed. Recover the stack */ - - mov sp, x29 - cfi_def_cfa_register (sp) - - ldp x29, x30, [sp], 16 - cfi_adjust_cfa_offset (16) - cfi_restore (x29) - cfi_restore (x30) + cbz x0, 1f b C_SYMBOL_NAME(__syscall_error) - +1: + /* Restore the general purpose registers. */ + mov x0, x9 + cfi_def_cfa(x0, 0) + cfi_offset(x18, oX0 + 18 * SZREG) + cfi_offset(x19, oX0 + 19 * SZREG) + cfi_offset(x20, oX0 + 20 * SZREG) + cfi_offset(x21, oX0 + 21 * SZREG) + cfi_offset(x22, oX0 + 22 * SZREG) + cfi_offset(x23, oX0 + 23 * SZREG) + cfi_offset(x24, oX0 + 24 * SZREG) + cfi_offset(x25, oX0 + 25 * SZREG) + cfi_offset(x26, oX0 + 26 * SZREG) + cfi_offset(x27, oX0 + 27 * SZREG) + cfi_offset(x28, oX0 + 28 * SZREG) + cfi_offset(x29, oX0 + 29 * SZREG) + cfi_offset(x30, oX0 + 30 * SZREG) + + cfi_offset( d8, oV0 + 8 * SZVREG) + cfi_offset( d9, oV0 + 9 * SZVREG) + cfi_offset(d10, oV0 + 10 * SZVREG) + cfi_offset(d11, oV0 + 11 * SZVREG) + cfi_offset(d12, oV0 + 12 * SZVREG) + cfi_offset(d13, oV0 + 13 * SZVREG) + cfi_offset(d14, oV0 + 14 * SZVREG) + cfi_offset(d15, oV0 + 15 * SZVREG) + ldp x18, x19, [x0, oX0 + 18 * SZREG] + ldp x20, x21, [x0, oX0 + 20 * SZREG] + ldp x22, x23, [x0, oX0 + 22 * SZREG] + ldp x24, x25, [x0, oX0 + 24 * SZREG] + ldp x26, x27, [x0, oX0 + 26 * SZREG] + ldp x28, x29, [x0, oX0 + 28 * SZREG] + ldr x30, [x0, oX0 + 30 * SZREG] + ldr x2, [x0, oSP] + mov sp, x2 + + /* Check for FP SIMD context. */ + add x2, x0, #oEXTENSION + + mov w3, #(FPSIMD_MAGIC & 0xffff) + movk w3, #(FPSIMD_MAGIC >> 16), lsl #16 + ldr w1, [x2, #oHEAD + oMAGIC] + cmp w1, w3 + b.ne 2f + + /* Restore the FP SIMD context. */ + add x3, x2, #oV0 + 8 * SZVREG + ldp d8, d9, [x3], #2 * SZVREG + ldp d10, d11, [x3], #2 * SZVREG + ldp d12, d13, [x3], #2 * SZVREG + ldp d14, d15, [x3], #2 * SZVREG + + add x3, x2, oFPSR + + ldr w4, [x3] + msr fpsr, x4 + + ldr w4, [x3, oFPCR - oFPSR] + msr fpcr, x4 + +2: + ldr x16, [x0, oPC] + /* Restore arg registers. */ + ldp x2, x3, [x0, oX0 + 2 * SZREG] + ldp x4, x5, [x0, oX0 + 4 * SZREG] + ldp x6, x7, [x0, oX0 + 6 * SZREG] + ldp x0, x1, [x0, oX0 + 0 * SZREG] + /* Jump to the new pc value. */ + br x16 PSEUDO_END (__setcontext) weak_alias (__setcontext, setcontext)