lkml.org 
[lkml]   [2015]   [Oct]   [7]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[tip:x86/asm] selftests/x86: Add a test for vDSO unwinding
    Commit-ID:  3b56aae34bc695638b8673fc8459be1837c18730
    Gitweb: http://git.kernel.org/tip/3b56aae34bc695638b8673fc8459be1837c18730
    Author: Andy Lutomirski <luto@kernel.org>
    AuthorDate: Mon, 5 Oct 2015 17:47:51 -0700
    Committer: Ingo Molnar <mingo@kernel.org>
    CommitDate: Wed, 7 Oct 2015 11:34:06 +0200

    selftests/x86: Add a test for vDSO unwinding

    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 | 2 +-
    tools/testing/selftests/x86/unwind_vdso.c | 209 ++++++++++++++++++++++++++++++
    2 files changed, 210 insertions(+), 1 deletion(-)

    diff --git a/tools/testing/selftests/x86/Makefile b/tools/testing/selftests/x86/Makefile
    index fd55bc3..7541352 100644
    --- a/tools/testing/selftests/x86/Makefile
    +++ b/tools/testing/selftests/x86/Makefile
    @@ -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
    index 0000000..5992ff2
    --- /dev/null
    +++ b/tools/testing/selftests/x86/unwind_vdso.c
    @@ -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 */

    \
     
     \ /
      Last update: 2015-10-07 18:41    [W:6.001 / U:0.020 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site