selftests/x86: Add a test for vDSO unwinding
authorAndy Lutomirski <luto@kernel.org>
Tue, 6 Oct 2015 00:47:51 +0000 (17:47 -0700)
committerIngo Molnar <mingo@kernel.org>
Wed, 7 Oct 2015 09:34:06 +0000 (11:34 +0200)
While the kernel itself doesn't use DWARF unwinding, user code
expects to be able to unwind the vDSO.  The vsyscall
(AT_SYSINFO) entry is manually CFI-annotated, and this tests
that it unwinds correctly.

I tested the test by incorrectly annotating __kernel_vsyscall,
and the test indeed fails if I do that.

Signed-off-by: Andy Lutomirski <luto@kernel.org>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Shuah Khan <shuahkh@osg.samsung.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Link: http://lkml.kernel.org/r/8bf736d1925cdd165c0f980156a4248e55af47a1.1444091584.git.luto@kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
tools/testing/selftests/x86/Makefile
tools/testing/selftests/x86/unwind_vdso.c [new file with mode: 0644]

index fd55bc37fa18c29fc64ab611f28b23d9c421c9fa..75413529f4a241b651f7138bdb41a7cc7f5760b8 100644 (file)
@@ -5,7 +5,7 @@ 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 test_syscall_vdso
+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)
diff --git a/tools/testing/selftests/x86/unwind_vdso.c b/tools/testing/selftests/x86/unwind_vdso.c
new file mode 100644 (file)
index 0000000..5992ff2
--- /dev/null
@@ -0,0 +1,209 @@
+/*
+ * 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 */