Merge branch 'x86-asm-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull x86 asm changes from Ingo Molnar:
 "The main change in this cycle is another step in the big x86 system
  call interface rework by Andy Lutomirski, which moves most of the low
  level x86 entry code from assembly to C, for all syscall entries
  except native 64-bit system calls:

    arch/x86/entry/entry_32.S        | 182 ++++------
    arch/x86/entry/entry_64_compat.S | 547 ++++++++-----------------------
    194 insertions(+), 535 deletions(-)

  ... our hope is that the final remaining step (converting native
  64-bit system calls) will be less painful as all the previous steps,
  given that most of the legacies and quirks are concentrated around
  native 32-bit and compat environments"

* 'x86-asm-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (47 commits)
  x86/entry/32: Fix FS and GS restore in opportunistic SYSEXIT
  x86/entry/32: Fix entry_INT80_32() to expect interrupts to be on
  um/x86: Fix build after x86 syscall changes
  x86/asm: Remove the xyz_cfi macros from dwarf2.h
  selftests/x86: Style fixes for the 'unwind_vdso' test
  x86/entry/64/compat: Document sysenter_fix_flags's reason for existence
  x86/entry: Split and inline syscall_return_slowpath()
  x86/entry: Split and inline prepare_exit_to_usermode()
  x86/entry: Use pt_regs_to_thread_info() in syscall entry tracing
  x86/entry: Hide two syscall entry assertions behind CONFIG_DEBUG_ENTRY
  x86/entry: Micro-optimize compat fast syscall arg fetch
  x86/entry: Force inlining of 32-bit syscall code
  x86/entry: Make irqs_disabled checks in exit code depend on lockdep
  x86/entry: Remove unnecessary IRQ twiddling in fast 32-bit syscalls
  x86/asm: Remove thread_info.sysenter_return
  x86/entry/32: Re-implement SYSENTER using the new C path
  x86/entry/32: Switch INT80 to the new C syscall path
  x86/entry/32: Open-code return tracking from fork and kthreads
  x86/entry/compat: Implement opportunistic SYSRETL for compat syscalls
  x86/vdso/compat: Wire up SYSENTER and SYSCSALL for compat userspace
  ...

6 files changed, 1011 insertions, 2 deletions

diff --git a/tools/testing/selftests/x86/Makefile b/tools/testing/selftests/x86/Makefile
index 29089b24d18b..389701f59940 100644
--- a/tools/testing/selftests/x86/Makefile
+++ b/tools/testing/selftests/x86/Makefile
@@ -4,8 +4,8 @@ include ../lib.mk
 
 .PHONY: all all_32 all_64 warn_32bit_failure clean
 
-TARGETS_C_BOTHBITS := single_step_syscall sysret_ss_attrs ldt_gdt syscall_nt
-TARGETS_C_32BIT_ONLY := entry_from_vm86 syscall_arg_fault sigreturn
+TARGETS_C_BOTHBITS := single_step_syscall sysret_ss_attrs ldt_gdt syscall_nt ptrace_syscall
+TARGETS_C_32BIT_ONLY := entry_from_vm86 syscall_arg_fault sigreturn test_syscall_vdso unwind_vdso
 
 TARGETS_C_32BIT_ALL := $(TARGETS_C_BOTHBITS) $(TARGETS_C_32BIT_ONLY)
 BINARIES_32 := $(TARGETS_C_32BIT_ALL:%=%_32)
@@ -60,3 +60,5 @@ endif
 
 # Some tests have additional dependencies.
 sysret_ss_attrs_64: thunks.S
+ptrace_syscall_32: raw_syscall_helper_32.S
+test_syscall_vdso_32: thunks_32.S
diff --git a/tools/testing/selftests/x86/ptrace_syscall.c b/tools/testing/selftests/x86/ptrace_syscall.c
new file mode 100644
index 000000000000..5105b49cd8aa
--- /dev/null
+++ b/tools/testing/selftests/x86/ptrace_syscall.c
@@ -0,0 +1,294 @@
+#define _GNU_SOURCE
+
+#include <sys/ptrace.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/syscall.h>
+#include <sys/user.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <err.h>
+#include <string.h>
+#include <asm/ptrace-abi.h>
+#include <sys/auxv.h>
+
+/* Bitness-agnostic defines for user_regs_struct fields. */
+#ifdef __x86_64__
+# define user_syscall_nr        orig_rax
+# define user_arg0              rdi
+# define user_arg1              rsi
+# define user_arg2              rdx
+# define user_arg3              r10
+# define user_arg4              r8
+# define user_arg5              r9
+# define user_ip                rip
+# define user_ax                rax
+#else
+# define user_syscall_nr        orig_eax
+# define user_arg0              ebx
+# define user_arg1              ecx
+# define user_arg2              edx
+# define user_arg3              esi
+# define user_arg4              edi
+# define user_arg5              ebp
+# define user_ip                eip
+# define user_ax                eax
+#endif
+
+static int nerrs = 0;
+
+struct syscall_args32 {
+        uint32_t nr, arg0, arg1, arg2, arg3, arg4, arg5;
+};
+
+#ifdef __i386__
+extern void sys32_helper(struct syscall_args32 *, void *);
+extern void int80_and_ret(void);
+#endif
+
+/*
+ * Helper to invoke int80 with controlled regs and capture the final regs.
+ */
+static void do_full_int80(struct syscall_args32 *args)
+{
+#ifdef __x86_64__
+        register unsigned long bp asm("bp") = args->arg5;
+        asm volatile ("int $0x80"
+                      : "+a" (args->nr),
+                        "+b" (args->arg0), "+c" (args->arg1), "+d" (args->arg2),
+                        "+S" (args->arg3), "+D" (args->arg4), "+r" (bp));
+        args->arg5 = bp;
+#else
+        sys32_helper(args, int80_and_ret);
+#endif
+}
+
+#ifdef __i386__
+static void (*vsyscall32)(void);
+
+/*
+ * Nasty helper to invoke AT_SYSINFO (i.e. __kernel_vsyscall) with
+ * controlled regs and capture the final regs.  This is so nasty that it
+ * crashes my copy of gdb :)
+ */
+static void do_full_vsyscall32(struct syscall_args32 *args)
+{
+        sys32_helper(args, vsyscall32);
+}
+#endif
+
+static siginfo_t wait_trap(pid_t chld)
+{
+        siginfo_t si;
+        if (waitid(P_PID, chld, &si, WEXITED|WSTOPPED) != 0)
+                err(1, "waitid");
+        if (si.si_pid != chld)
+                errx(1, "got unexpected pid in event\n");
+        if (si.si_code != CLD_TRAPPED)
+                errx(1, "got unexpected event type %d\n", si.si_code);
+        return si;
+}
+
+static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
+                       int flags)
+{
+        struct sigaction sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_sigaction = handler;
+        sa.sa_flags = SA_SIGINFO | flags;
+        sigemptyset(&sa.sa_mask);
+        if (sigaction(sig, &sa, 0))
+                err(1, "sigaction");
+}
+
+static void clearhandler(int sig)
+{
+        struct sigaction sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_handler = SIG_DFL;
+        sigemptyset(&sa.sa_mask);
+        if (sigaction(sig, &sa, 0))
+                err(1, "sigaction");
+}
+
+#ifdef __x86_64__
+# define REG_BP REG_RBP
+#else
+# define REG_BP REG_EBP
+#endif
+
+static void empty_handler(int sig, siginfo_t *si, void *ctx_void)
+{
+}
+
+static void test_sys32_regs(void (*do_syscall)(struct syscall_args32 *))
+{
+        struct syscall_args32 args = {
+                .nr = 224,      /* gettid */
+                .arg0 = 10, .arg1 = 11, .arg2 = 12,
+                .arg3 = 13, .arg4 = 14, .arg5 = 15,
+        };
+
+        do_syscall(&args);
+
+        if (args.nr != getpid() ||
+            args.arg0 != 10 || args.arg1 != 11 || args.arg2 != 12 ||
+            args.arg3 != 13 || args.arg4 != 14 || args.arg5 != 15) {
+                printf("[FAIL]\tgetpid() failed to preseve regs\n");
+                nerrs++;
+        } else {
+                printf("[OK]\tgetpid() preserves regs\n");
+        }
+
+        sethandler(SIGUSR1, empty_handler, 0);
+
+        args.nr = 37;   /* kill */
+        args.arg0 = getpid();
+        args.arg1 = SIGUSR1;
+        do_syscall(&args);
+        if (args.nr != 0 ||
+            args.arg0 != getpid() || args.arg1 != SIGUSR1 || args.arg2 != 12 ||
+            args.arg3 != 13 || args.arg4 != 14 || args.arg5 != 15) {
+                printf("[FAIL]\tkill(getpid(), SIGUSR1) failed to preseve regs\n");
+                nerrs++;
+        } else {
+                printf("[OK]\tkill(getpid(), SIGUSR1) preserves regs\n");
+        }
+        clearhandler(SIGUSR1);
+}
+
+static void test_ptrace_syscall_restart(void)
+{
+        printf("[RUN]\tptrace-induced syscall restart\n");
+        pid_t chld = fork();
+        if (chld < 0)
+                err(1, "fork");
+
+        if (chld == 0) {
+                if (ptrace(PTRACE_TRACEME, 0, 0, 0) != 0)
+                        err(1, "PTRACE_TRACEME");
+
+                printf("\tChild will make one syscall\n");
+                raise(SIGSTOP);
+
+                syscall(SYS_gettid, 10, 11, 12, 13, 14, 15);
+                _exit(0);
+        }
+
+        int status;
+
+        /* Wait for SIGSTOP. */
+        if (waitpid(chld, &status, 0) != chld || !WIFSTOPPED(status))
+                err(1, "waitpid");
+
+        struct user_regs_struct regs;
+
+        printf("[RUN]\tSYSEMU\n");
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSCALL");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        if (regs.user_syscall_nr != SYS_gettid ||
+            regs.user_arg0 != 10 || regs.user_arg1 != 11 ||
+            regs.user_arg2 != 12 || regs.user_arg3 != 13 ||
+            regs.user_arg4 != 14 || regs.user_arg5 != 15) {
+                printf("[FAIL]\tInitial args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n", (unsigned long)regs.user_syscall_nr, (unsigned long)regs.user_arg0, (unsigned long)regs.user_arg1, (unsigned long)regs.user_arg2, (unsigned long)regs.user_arg3, (unsigned long)regs.user_arg4, (unsigned long)regs.user_arg5);
+                nerrs++;
+        } else {
+                printf("[OK]\tInitial nr and args are correct\n");
+        }
+
+        printf("[RUN]\tRestart the syscall (ip = 0x%lx)\n",
+               (unsigned long)regs.user_ip);
+
+        /*
+         * This does exactly what it appears to do if syscall is int80 or
+         * SYSCALL64.  For SYSCALL32 or SYSENTER, though, this is highly
+         * magical.  It needs to work so that ptrace and syscall restart
+         * work as expected.
+         */
+        regs.user_ax = regs.user_syscall_nr;
+        regs.user_ip -= 2;
+        if (ptrace(PTRACE_SETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_SETREGS");
+
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSCALL");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        if (regs.user_syscall_nr != SYS_gettid ||
+            regs.user_arg0 != 10 || regs.user_arg1 != 11 ||
+            regs.user_arg2 != 12 || regs.user_arg3 != 13 ||
+            regs.user_arg4 != 14 || regs.user_arg5 != 15) {
+                printf("[FAIL]\tRestart nr or args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n", (unsigned long)regs.user_syscall_nr, (unsigned long)regs.user_arg0, (unsigned long)regs.user_arg1, (unsigned long)regs.user_arg2, (unsigned long)regs.user_arg3, (unsigned long)regs.user_arg4, (unsigned long)regs.user_arg5);
+                nerrs++;
+        } else {
+                printf("[OK]\tRestarted nr and args are correct\n");
+        }
+
+        printf("[RUN]\tChange nr and args and restart the syscall (ip = 0x%lx)\n",
+               (unsigned long)regs.user_ip);
+
+        regs.user_ax = SYS_getpid;
+        regs.user_arg0 = 20;
+        regs.user_arg1 = 21;
+        regs.user_arg2 = 22;
+        regs.user_arg3 = 23;
+        regs.user_arg4 = 24;
+        regs.user_arg5 = 25;
+        regs.user_ip -= 2;
+
+        if (ptrace(PTRACE_SETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_SETREGS");
+
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSCALL");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        if (regs.user_syscall_nr != SYS_getpid ||
+            regs.user_arg0 != 20 || regs.user_arg1 != 21 || regs.user_arg2 != 22 ||
+            regs.user_arg3 != 23 || regs.user_arg4 != 24 || regs.user_arg5 != 25) {
+                printf("[FAIL]\tRestart nr or args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n", (unsigned long)regs.user_syscall_nr, (unsigned long)regs.user_arg0, (unsigned long)regs.user_arg1, (unsigned long)regs.user_arg2, (unsigned long)regs.user_arg3, (unsigned long)regs.user_arg4, (unsigned long)regs.user_arg5);
+                nerrs++;
+        } else {
+                printf("[OK]\tReplacement nr and args are correct\n");
+        }
+
+        if (ptrace(PTRACE_CONT, chld, 0, 0) != 0)
+                err(1, "PTRACE_CONT");
+        if (waitpid(chld, &status, 0) != chld)
+                err(1, "waitpid");
+        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+                printf("[FAIL]\tChild failed\n");
+                nerrs++;
+        } else {
+                printf("[OK]\tChild exited cleanly\n");
+        }
+}
+
+int main()
+{
+        printf("[RUN]\tCheck int80 return regs\n");
+        test_sys32_regs(do_full_int80);
+
+#if defined(__i386__) && (!defined(__GLIBC__) || __GLIBC__ > 2 || __GLIBC_MINOR__ >= 16)
+        vsyscall32 = (void *)getauxval(AT_SYSINFO);
+        printf("[RUN]\tCheck AT_SYSINFO return regs\n");
+        test_sys32_regs(do_full_vsyscall32);
+#endif
+
+        test_ptrace_syscall_restart();
+
+        return 0;
+}
diff --git a/tools/testing/selftests/x86/raw_syscall_helper_32.S b/tools/testing/selftests/x86/raw_syscall_helper_32.S
new file mode 100644
index 000000000000..534e71e35c6a
--- /dev/null
+++ b/tools/testing/selftests/x86/raw_syscall_helper_32.S
@@ -0,0 +1,46 @@
+.global sys32_helper
+sys32_helper:
+        /* Args: syscall_args_32*, function pointer */
+        pushl   %ebp
+        pushl   %ebx
+        pushl   %esi
+        pushl   %edi
+        movl    5*4(%esp), %eax /* pointer to args struct */
+
+        movl    1*4(%eax), %ebx
+        movl    2*4(%eax), %ecx
+        movl    3*4(%eax), %edx
+        movl    4*4(%eax), %esi
+        movl    5*4(%eax), %edi
+        movl    6*4(%eax), %ebp
+        movl    0*4(%eax), %eax
+
+        call    *(6*4)(%esp)    /* Do the syscall */
+
+        /* Now we need to recover without losing any reg values */
+        pushl   %eax
+        movl    6*4(%esp), %eax
+        popl    0*4(%eax)
+        movl    %ebx, 1*4(%eax)
+        movl    %ecx, 2*4(%eax)
+        movl    %edx, 3*4(%eax)
+        movl    %esi, 4*4(%eax)
+        movl    %edi, 5*4(%eax)
+        movl    %ebp, 6*4(%eax)
+
+        popl    %edi
+        popl    %esi
+        popl    %ebx
+        popl    %ebp
+        ret
+
+        .type sys32_helper, @function
+        .size sys32_helper, .-sys32_helper
+
+.global int80_and_ret
+int80_and_ret:
+        int     $0x80
+        ret
+
+        .type int80_and_ret, @function
+        .size int80_and_ret, .-int80_and_ret
diff --git a/tools/testing/selftests/x86/test_syscall_vdso.c b/tools/testing/selftests/x86/test_syscall_vdso.c
new file mode 100644
index 000000000000..40370354d4c1
--- /dev/null
+++ b/tools/testing/selftests/x86/test_syscall_vdso.c
@@ -0,0 +1,401 @@
+/*
+ * 32-bit syscall ABI conformance test.
+ *
+ * Copyright (c) 2015 Denys Vlasenko
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+/*
+ * Can be built statically:
+ * gcc -Os -Wall -static -m32 test_syscall_vdso.c thunks_32.S
+ */
+#undef _GNU_SOURCE
+#define _GNU_SOURCE 1
+#undef __USE_GNU
+#define __USE_GNU 1
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <elf.h>
+#include <sys/ptrace.h>
+#include <sys/wait.h>
+
+#if !defined(__i386__)
+int main(int argc, char **argv, char **envp)
+{
+        printf("[SKIP]\tNot a 32-bit x86 userspace\n");
+        return 0;
+}
+#else
+
+long syscall_addr;
+long get_syscall(char **envp)
+{
+        Elf32_auxv_t *auxv;
+        while (*envp++ != NULL)
+                continue;
+        for (auxv = (void *)envp; auxv->a_type != AT_NULL; auxv++)
+                if (auxv->a_type == AT_SYSINFO)
+                        return auxv->a_un.a_val;
+        printf("[WARN]\tAT_SYSINFO not supplied\n");
+        return 0;
+}
+
+asm (
+        "       .pushsection .text\n"
+        "       .global int80\n"
+        "int80:\n"
+        "       int     $0x80\n"
+        "       ret\n"
+        "       .popsection\n"
+);
+extern char int80;
+
+struct regs64 {
+        uint64_t rax, rbx, rcx, rdx;
+        uint64_t rsi, rdi, rbp, rsp;
+        uint64_t r8,  r9,  r10, r11;
+        uint64_t r12, r13, r14, r15;
+};
+struct regs64 regs64;
+int kernel_is_64bit;
+
+asm (
+        "       .pushsection .text\n"
+        "       .code64\n"
+        "get_regs64:\n"
+        "       push    %rax\n"
+        "       mov     $regs64, %eax\n"
+        "       pop     0*8(%rax)\n"
+        "       movq    %rbx, 1*8(%rax)\n"
+        "       movq    %rcx, 2*8(%rax)\n"
+        "       movq    %rdx, 3*8(%rax)\n"
+        "       movq    %rsi, 4*8(%rax)\n"
+        "       movq    %rdi, 5*8(%rax)\n"
+        "       movq    %rbp, 6*8(%rax)\n"
+        "       movq    %rsp, 7*8(%rax)\n"
+        "       movq    %r8,  8*8(%rax)\n"
+        "       movq    %r9,  9*8(%rax)\n"
+        "       movq    %r10, 10*8(%rax)\n"
+        "       movq    %r11, 11*8(%rax)\n"
+        "       movq    %r12, 12*8(%rax)\n"
+        "       movq    %r13, 13*8(%rax)\n"
+        "       movq    %r14, 14*8(%rax)\n"
+        "       movq    %r15, 15*8(%rax)\n"
+        "       ret\n"
+        "poison_regs64:\n"
+        "       movq    $0x7f7f7f7f, %r8\n"
+        "       shl     $32, %r8\n"
+        "       orq     $0x7f7f7f7f, %r8\n"
+        "       movq    %r8, %r9\n"
+        "       movq    %r8, %r10\n"
+        "       movq    %r8, %r11\n"
+        "       movq    %r8, %r12\n"
+        "       movq    %r8, %r13\n"
+        "       movq    %r8, %r14\n"
+        "       movq    %r8, %r15\n"
+        "       ret\n"
+        "       .code32\n"
+        "       .popsection\n"
+);
+extern void get_regs64(void);
+extern void poison_regs64(void);
+extern unsigned long call64_from_32(void (*function)(void));
+void print_regs64(void)
+{
+        if (!kernel_is_64bit)
+                return;
+        printf("ax:%016llx bx:%016llx cx:%016llx dx:%016llx\n", regs64.rax,  regs64.rbx,  regs64.rcx,  regs64.rdx);
+        printf("si:%016llx di:%016llx bp:%016llx sp:%016llx\n", regs64.rsi,  regs64.rdi,  regs64.rbp,  regs64.rsp);
+        printf(" 8:%016llx  9:%016llx 10:%016llx 11:%016llx\n", regs64.r8 ,  regs64.r9 ,  regs64.r10,  regs64.r11);
+        printf("12:%016llx 13:%016llx 14:%016llx 15:%016llx\n", regs64.r12,  regs64.r13,  regs64.r14,  regs64.r15);
+}
+
+int check_regs64(void)
+{
+        int err = 0;
+        int num = 8;
+        uint64_t *r64 = &regs64.r8;
+
+        if (!kernel_is_64bit)
+                return 0;
+
+        do {
+                if (*r64 == 0x7f7f7f7f7f7f7f7fULL)
+                        continue; /* register did not change */
+                if (syscall_addr != (long)&int80) {
+                        /*
+                         * Non-INT80 syscall entrypoints are allowed to clobber R8+ regs:
+                         * either clear them to 0, or for R11, load EFLAGS.
+                         */
+                        if (*r64 == 0)
+                                continue;
+                        if (num == 11) {
+                                printf("[NOTE]\tR11 has changed:%016llx - assuming clobbered by SYSRET insn\n", *r64);
+                                continue;
+                        }
+                } else {
+                        /* INT80 syscall entrypoint can be used by
+                         * 64-bit programs too, unlike SYSCALL/SYSENTER.
+                         * Therefore it must preserve R12+
+                         * (they are callee-saved registers in 64-bit C ABI).
+                         *
+                         * This was probably historically not intended,
+                         * but R8..11 are clobbered (cleared to 0).
+                         * IOW: they are the only registers which aren't
+                         * preserved across INT80 syscall.
+                         */
+                        if (*r64 == 0 && num <= 11)
+                                continue;
+                }
+                printf("[FAIL]\tR%d has changed:%016llx\n", num, *r64);
+                err++;
+        } while (r64++, ++num < 16);
+
+        if (!err)
+                printf("[OK]\tR8..R15 did not leak kernel data\n");
+        return err;
+}
+
+int nfds;
+fd_set rfds;
+fd_set wfds;
+fd_set efds;
+struct timespec timeout;
+sigset_t sigmask;
+struct {
+        sigset_t *sp;
+        int sz;
+} sigmask_desc;
+
+void prep_args()
+{
+        nfds = 42;
+        FD_ZERO(&rfds);
+        FD_ZERO(&wfds);
+        FD_ZERO(&efds);
+        FD_SET(0, &rfds);
+        FD_SET(1, &wfds);
+        FD_SET(2, &efds);
+        timeout.tv_sec = 0;
+        timeout.tv_nsec = 123;
+        sigemptyset(&sigmask);
+        sigaddset(&sigmask, SIGINT);
+        sigaddset(&sigmask, SIGUSR2);
+        sigaddset(&sigmask, SIGRTMAX);
+        sigmask_desc.sp = &sigmask;
+        sigmask_desc.sz = 8; /* bytes */
+}
+
+static void print_flags(const char *name, unsigned long r)
+{
+        static const char *bitarray[] = {
+        "\n" ,"c\n" ,/* Carry Flag */
+        "0 " ,"1 "  ,/* Bit 1 - always on */
+        ""   ,"p "  ,/* Parity Flag */
+        "0 " ,"3? " ,
+        ""   ,"a "  ,/* Auxiliary carry Flag */
+        "0 " ,"5? " ,
+        ""   ,"z "  ,/* Zero Flag */
+        ""   ,"s "  ,/* Sign Flag */
+        ""   ,"t "  ,/* Trap Flag */
+        ""   ,"i "  ,/* Interrupt Flag */
+        ""   ,"d "  ,/* Direction Flag */
+        ""   ,"o "  ,/* Overflow Flag */
+        "0 " ,"1 "  ,/* I/O Privilege Level (2 bits) */
+        "0"  ,"1"   ,/* I/O Privilege Level (2 bits) */
+        ""   ,"n "  ,/* Nested Task */
+        "0 " ,"15? ",
+        ""   ,"r "  ,/* Resume Flag */
+        ""   ,"v "  ,/* Virtual Mode */
+        ""   ,"ac " ,/* Alignment Check/Access Control */
+        ""   ,"vif ",/* Virtual Interrupt Flag */
+        ""   ,"vip ",/* Virtual Interrupt Pending */
+        ""   ,"id " ,/* CPUID detection */
+        NULL
+        };
+        const char **bitstr;
+        int bit;
+
+        printf("%s=%016lx ", name, r);
+        bitstr = bitarray + 42;
+        bit = 21;
+        if ((r >> 22) != 0)
+                printf("(extra bits are set) ");
+        do {
+                if (bitstr[(r >> bit) & 1][0])
+                        fputs(bitstr[(r >> bit) & 1], stdout);
+                bitstr -= 2;
+                bit--;
+        } while (bit >= 0);
+}
+
+int run_syscall(void)
+{
+        long flags, bad_arg;
+
+        prep_args();
+
+        if (kernel_is_64bit)
+                call64_from_32(poison_regs64);
+        /*print_regs64();*/
+
+        asm("\n"
+        /* Try 6-arg syscall: pselect. It should return quickly */
+        "       push    %%ebp\n"
+        "       mov     $308, %%eax\n"     /* PSELECT */
+        "       mov     nfds, %%ebx\n"     /* ebx  arg1 */
+        "       mov     $rfds, %%ecx\n"    /* ecx  arg2 */
+        "       mov     $wfds, %%edx\n"    /* edx  arg3 */
+        "       mov     $efds, %%esi\n"    /* esi  arg4 */
+        "       mov     $timeout, %%edi\n" /* edi  arg5 */
+        "       mov     $sigmask_desc, %%ebp\n" /* %ebp arg6 */
+        "       push    $0x200ed7\n"      /* set almost all flags */
+        "       popf\n"         /* except TF, IOPL, NT, RF, VM, AC, VIF, VIP */
+        "       call    *syscall_addr\n"
+        /* Check that registers are not clobbered */
+        "       pushf\n"
+        "       pop     %%eax\n"
+        "       cld\n"
+        "       cmp     nfds, %%ebx\n"     /* ebx  arg1 */
+        "       mov     $1, %%ebx\n"
+        "       jne     1f\n"
+        "       cmp     $rfds, %%ecx\n"    /* ecx  arg2 */
+        "       mov     $2, %%ebx\n"
+        "       jne     1f\n"
+        "       cmp     $wfds, %%edx\n"    /* edx  arg3 */
+        "       mov     $3, %%ebx\n"
+        "       jne     1f\n"
+        "       cmp     $efds, %%esi\n"    /* esi  arg4 */
+        "       mov     $4, %%ebx\n"
+        "       jne     1f\n"
+        "       cmp     $timeout, %%edi\n" /* edi  arg5 */
+        "       mov     $5, %%ebx\n"
+        "       jne     1f\n"
+        "       cmpl    $sigmask_desc, %%ebp\n" /* %ebp arg6 */
+        "       mov     $6, %%ebx\n"
+        "       jne     1f\n"
+        "       mov     $0, %%ebx\n"
+        "1:\n"
+        "       pop     %%ebp\n"
+        : "=a" (flags), "=b" (bad_arg)
+        :
+        : "cx", "dx", "si", "di"
+        );
+
+        if (kernel_is_64bit) {
+                memset(&regs64, 0x77, sizeof(regs64));
+                call64_from_32(get_regs64);
+                /*print_regs64();*/
+        }
+
+        /*
+         * On paravirt kernels, flags are not preserved across syscalls.
+         * Thus, we do not consider it a bug if some are changed.
+         * We just show ones which do.
+         */
+        if ((0x200ed7 ^ flags) != 0) {
+                print_flags("[WARN]\tFlags before", 0x200ed7);
+                print_flags("[WARN]\tFlags  after", flags);
+                print_flags("[WARN]\tFlags change", (0x200ed7 ^ flags));
+        }
+
+        if (bad_arg) {
+                printf("[FAIL]\targ#%ld clobbered\n", bad_arg);
+                return 1;
+        }
+        printf("[OK]\tArguments are preserved across syscall\n");
+
+        return check_regs64();
+}
+
+int run_syscall_twice()
+{
+        int exitcode = 0;
+        long sv;
+
+        if (syscall_addr) {
+                printf("[RUN]\tExecuting 6-argument 32-bit syscall via VDSO\n");
+                exitcode = run_syscall();
+        }
+        sv = syscall_addr;
+        syscall_addr = (long)&int80;
+        printf("[RUN]\tExecuting 6-argument 32-bit syscall via INT 80\n");
+        exitcode += run_syscall();
+        syscall_addr = sv;
+        return exitcode;
+}
+
+void ptrace_me()
+{
+        pid_t pid;
+
+        fflush(NULL);
+        pid = fork();
+        if (pid < 0)
+                exit(1);
+        if (pid == 0) {
+                /* child */
+                if (ptrace(PTRACE_TRACEME, 0L, 0L, 0L) != 0)
+                        exit(0);
+                raise(SIGSTOP);
+                return;
+        }
+        /* parent */
+        printf("[RUN]\tRunning tests under ptrace\n");
+        while (1) {
+                int status;
+                pid = waitpid(-1, &status, __WALL);
+                if (WIFEXITED(status))
+                        exit(WEXITSTATUS(status));
+                if (WIFSIGNALED(status))
+                        exit(WTERMSIG(status));
+                if (pid <= 0 || !WIFSTOPPED(status)) /* paranoia */
+                        exit(255);
+                /*
+                 * Note: we do not inject sig = WSTOPSIG(status).
+                 * We probably should, but careful: do not inject SIGTRAP
+                 * generated by syscall entry/exit stops.
+                 * That kills the child.
+                 */
+                ptrace(PTRACE_SYSCALL, pid, 0L, 0L /*sig*/);
+        }
+}
+
+int main(int argc, char **argv, char **envp)
+{
+        int exitcode = 0;
+        int cs;
+
+        asm("\n"
+        "       movl    %%cs, %%eax\n"
+        : "=a" (cs)
+        );
+        kernel_is_64bit = (cs == 0x23);
+        if (!kernel_is_64bit)
+                printf("[NOTE]\tNot a 64-bit kernel, won't test R8..R15 leaks\n");
+
+        /* This only works for non-static builds:
+         * syscall_addr = dlsym(dlopen("linux-gate.so.1", RTLD_NOW), "__kernel_vsyscall");
+         */
+        syscall_addr = get_syscall(envp);
+
+        exitcode += run_syscall_twice();
+        ptrace_me();
+        exitcode += run_syscall_twice();
+
+        return exitcode;
+}
+#endif
diff --git a/tools/testing/selftests/x86/thunks_32.S b/tools/testing/selftests/x86/thunks_32.S
new file mode 100644
index 000000000000..29b644bb9f2f
--- /dev/null
+++ b/tools/testing/selftests/x86/thunks_32.S
@@ -0,0 +1,55 @@
+/*
+ * thunks_32.S - assembly helpers for mixed-bitness code
+ * Copyright (c) 2015 Denys Vlasenko
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * These are little helpers that make it easier to switch bitness on
+ * the fly.
+ */
+
+        .text
+        .code32
+
+        .global call64_from_32
+        .type call32_from_64, @function
+
+        // 4(%esp): function to call
+call64_from_32:
+        // Fetch function address
+        mov     4(%esp), %eax
+
+        // Save registers which are callee-clobbered by 64-bit ABI
+        push    %ecx
+        push    %edx
+        push    %esi
+        push    %edi
+
+        // Switch to long mode
+        jmp     $0x33,$1f
+1:      .code64
+
+        // Call the function
+        call    *%rax
+
+        // Switch to compatibility mode
+        push    $0x23  /* USER32_CS */
+        .code32; push $1f; .code64 /* hack: can't have X86_64_32S relocation in 32-bit ELF */
+        lretq
+1:      .code32
+
+        pop     %edi
+        pop     %esi
+        pop     %edx
+        pop     %ecx
+
+        ret
+
+.size call64_from_32, .-call64_from_32
diff --git a/tools/testing/selftests/x86/unwind_vdso.c b/tools/testing/selftests/x86/unwind_vdso.c
new file mode 100644
index 000000000000..00a26a82fa98
--- /dev/null
+++ b/tools/testing/selftests/x86/unwind_vdso.c
@@ -0,0 +1,211 @@
+/*
+ * unwind_vdso.c - tests unwind info for AT_SYSINFO in the vDSO
+ * Copyright (c) 2014-2015 Andrew Lutomirski
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * This tests __kernel_vsyscall's unwind info.
+ */
+
+#define _GNU_SOURCE
+
+#include <features.h>
+#include <stdio.h>
+
+#if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16
+
+int main()
+{
+        /* We need getauxval(). */
+        printf("[SKIP]\tGLIBC before 2.16 cannot compile this test\n");
+        return 0;
+}
+
+#else
+
+#include <sys/time.h>
+#include <stdlib.h>
+#include <syscall.h>
+#include <unistd.h>
+#include <string.h>
+#include <inttypes.h>
+#include <sys/mman.h>
+#include <signal.h>
+#include <sys/ucontext.h>
+#include <err.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <sys/ptrace.h>
+#include <sys/user.h>
+#include <sys/ucontext.h>
+#include <link.h>
+#include <sys/auxv.h>
+#include <dlfcn.h>
+#include <unwind.h>
+
+static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
+                       int flags)
+{
+        struct sigaction sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_sigaction = handler;
+        sa.sa_flags = SA_SIGINFO | flags;
+        sigemptyset(&sa.sa_mask);
+        if (sigaction(sig, &sa, 0))
+                err(1, "sigaction");
+}
+
+#ifdef __x86_64__
+# define WIDTH "q"
+#else
+# define WIDTH "l"
+#endif
+
+static unsigned long get_eflags(void)
+{
+        unsigned long eflags;
+        asm volatile ("pushf" WIDTH "\n\tpop" WIDTH " %0" : "=rm" (eflags));
+        return eflags;
+}
+
+static void set_eflags(unsigned long eflags)
+{
+        asm volatile ("push" WIDTH " %0\n\tpopf" WIDTH
+                      : : "rm" (eflags) : "flags");
+}
+
+#define X86_EFLAGS_TF (1UL << 8)
+
+static volatile sig_atomic_t nerrs;
+static unsigned long sysinfo;
+static bool got_sysinfo = false;
+static unsigned long return_address;
+
+struct unwind_state {
+        unsigned long ip;       /* trap source */
+        int depth;              /* -1 until we hit the trap source */
+};
+
+_Unwind_Reason_Code trace_fn(struct _Unwind_Context * ctx, void *opaque)
+{
+        struct unwind_state *state = opaque;
+        unsigned long ip = _Unwind_GetIP(ctx);
+
+        if (state->depth == -1) {
+                if (ip == state->ip)
+                        state->depth = 0;
+                else
+                        return _URC_NO_REASON;  /* Not there yet */
+        }
+        printf("\t  0x%lx\n", ip);
+
+        if (ip == return_address) {
+                /* Here we are. */
+                unsigned long eax = _Unwind_GetGR(ctx, 0);
+                unsigned long ecx = _Unwind_GetGR(ctx, 1);
+                unsigned long edx = _Unwind_GetGR(ctx, 2);
+                unsigned long ebx = _Unwind_GetGR(ctx, 3);
+                unsigned long ebp = _Unwind_GetGR(ctx, 5);
+                unsigned long esi = _Unwind_GetGR(ctx, 6);
+                unsigned long edi = _Unwind_GetGR(ctx, 7);
+                bool ok = (eax == SYS_getpid || eax == getpid()) &&
+                        ebx == 1 && ecx == 2 && edx == 3 &&
+                        esi == 4 && edi == 5 && ebp == 6;
+
+                if (!ok)
+                        nerrs++;
+                printf("[%s]\t  NR = %ld, args = %ld, %ld, %ld, %ld, %ld, %ld\n",
+                       (ok ? "OK" : "FAIL"),
+                       eax, ebx, ecx, edx, esi, edi, ebp);
+
+                return _URC_NORMAL_STOP;
+        } else {
+                state->depth++;
+                return _URC_NO_REASON;
+        }
+}
+
+static void sigtrap(int sig, siginfo_t *info, void *ctx_void)
+{
+        ucontext_t *ctx = (ucontext_t *)ctx_void;
+        struct unwind_state state;
+        unsigned long ip = ctx->uc_mcontext.gregs[REG_EIP];
+
+        if (!got_sysinfo && ip == sysinfo) {
+                got_sysinfo = true;
+
+                /* Find the return address. */
+                return_address = *(unsigned long *)(unsigned long)ctx->uc_mcontext.gregs[REG_ESP];
+
+                printf("\tIn vsyscall at 0x%lx, returning to 0x%lx\n",
+                       ip, return_address);
+        }
+
+        if (!got_sysinfo)
+                return;         /* Not there yet */
+
+        if (ip == return_address) {
+                ctx->uc_mcontext.gregs[REG_EFL] &= ~X86_EFLAGS_TF;
+                printf("\tVsyscall is done\n");
+                return;
+        }
+
+        printf("\tSIGTRAP at 0x%lx\n", ip);
+
+        state.ip = ip;
+        state.depth = -1;
+        _Unwind_Backtrace(trace_fn, &state);
+}
+
+int main()
+{
+        sysinfo = getauxval(AT_SYSINFO);
+        printf("\tAT_SYSINFO is 0x%lx\n", sysinfo);
+
+        Dl_info info;
+        if (!dladdr((void *)sysinfo, &info)) {
+                printf("[WARN]\tdladdr failed on AT_SYSINFO\n");
+        } else {
+                printf("[OK]\tAT_SYSINFO maps to %s, loaded at 0x%p\n",
+                       info.dli_fname, info.dli_fbase);
+        }
+
+        sethandler(SIGTRAP, sigtrap, 0);
+
+        syscall(SYS_getpid);  /* Force symbol binding without TF set. */
+        printf("[RUN]\tSet TF and check a fast syscall\n");
+        set_eflags(get_eflags() | X86_EFLAGS_TF);
+        syscall(SYS_getpid, 1, 2, 3, 4, 5, 6);
+        if (!got_sysinfo) {
+                set_eflags(get_eflags() & ~X86_EFLAGS_TF);
+
+                /*
+                 * The most likely cause of this is that you're on Debian or
+                 * a Debian-based distro, you're missing libc6-i686, and you're
+                 * affected by libc/19006 (https://sourceware.org/PR19006).
+                 */
+                printf("[WARN]\tsyscall(2) didn't enter AT_SYSINFO\n");
+        }
+
+        if (get_eflags() & X86_EFLAGS_TF) {
+                printf("[FAIL]\tTF is still set\n");
+                nerrs++;
+        }
+
+        if (nerrs) {
+                printf("[FAIL]\tThere were errors\n");
+                return 1;
+        } else {
+                printf("[OK]\tAll is well\n");
+                return 0;
+        }
+}
+
+#endif  /* New enough libc */