Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Jiri Olsa | 1222 | 99.92% | 5 | 83.33% |
Arnd Bergmann | 1 | 0.08% | 1 | 16.67% |
Total | 1223 | 6 |
// SPDX-License-Identifier: GPL-2.0 #include <test_progs.h> #ifdef __x86_64__ #include <unistd.h> #include <asm/ptrace.h> #include <linux/compiler.h> #include <linux/stringify.h> #include <sys/wait.h> #include <sys/syscall.h> #include <sys/prctl.h> #include <asm/prctl.h> #include "uprobe_syscall.skel.h" #include "uprobe_syscall_executed.skel.h" __naked unsigned long uretprobe_regs_trigger(void) { asm volatile ( "movq $0xdeadbeef, %rax\n" "ret\n" ); } __naked void uretprobe_regs(struct pt_regs *before, struct pt_regs *after) { asm volatile ( "movq %r15, 0(%rdi)\n" "movq %r14, 8(%rdi)\n" "movq %r13, 16(%rdi)\n" "movq %r12, 24(%rdi)\n" "movq %rbp, 32(%rdi)\n" "movq %rbx, 40(%rdi)\n" "movq %r11, 48(%rdi)\n" "movq %r10, 56(%rdi)\n" "movq %r9, 64(%rdi)\n" "movq %r8, 72(%rdi)\n" "movq %rax, 80(%rdi)\n" "movq %rcx, 88(%rdi)\n" "movq %rdx, 96(%rdi)\n" "movq %rsi, 104(%rdi)\n" "movq %rdi, 112(%rdi)\n" "movq $0, 120(%rdi)\n" /* orig_rax */ "movq $0, 128(%rdi)\n" /* rip */ "movq $0, 136(%rdi)\n" /* cs */ "pushf\n" "pop %rax\n" "movq %rax, 144(%rdi)\n" /* eflags */ "movq %rsp, 152(%rdi)\n" /* rsp */ "movq $0, 160(%rdi)\n" /* ss */ /* save 2nd argument */ "pushq %rsi\n" "call uretprobe_regs_trigger\n" /* save return value and load 2nd argument pointer to rax */ "pushq %rax\n" "movq 8(%rsp), %rax\n" "movq %r15, 0(%rax)\n" "movq %r14, 8(%rax)\n" "movq %r13, 16(%rax)\n" "movq %r12, 24(%rax)\n" "movq %rbp, 32(%rax)\n" "movq %rbx, 40(%rax)\n" "movq %r11, 48(%rax)\n" "movq %r10, 56(%rax)\n" "movq %r9, 64(%rax)\n" "movq %r8, 72(%rax)\n" "movq %rcx, 88(%rax)\n" "movq %rdx, 96(%rax)\n" "movq %rsi, 104(%rax)\n" "movq %rdi, 112(%rax)\n" "movq $0, 120(%rax)\n" /* orig_rax */ "movq $0, 128(%rax)\n" /* rip */ "movq $0, 136(%rax)\n" /* cs */ /* restore return value and 2nd argument */ "pop %rax\n" "pop %rsi\n" "movq %rax, 80(%rsi)\n" "pushf\n" "pop %rax\n" "movq %rax, 144(%rsi)\n" /* eflags */ "movq %rsp, 152(%rsi)\n" /* rsp */ "movq $0, 160(%rsi)\n" /* ss */ "ret\n" ); } static void test_uretprobe_regs_equal(void) { struct uprobe_syscall *skel = NULL; struct pt_regs before = {}, after = {}; unsigned long *pb = (unsigned long *) &before; unsigned long *pa = (unsigned long *) &after; unsigned long *pp; unsigned int i, cnt; int err; skel = uprobe_syscall__open_and_load(); if (!ASSERT_OK_PTR(skel, "uprobe_syscall__open_and_load")) goto cleanup; err = uprobe_syscall__attach(skel); if (!ASSERT_OK(err, "uprobe_syscall__attach")) goto cleanup; uretprobe_regs(&before, &after); pp = (unsigned long *) &skel->bss->regs; cnt = sizeof(before)/sizeof(*pb); for (i = 0; i < cnt; i++) { unsigned int offset = i * sizeof(unsigned long); /* * Check register before and after uretprobe_regs_trigger call * that triggers the uretprobe. */ switch (offset) { case offsetof(struct pt_regs, rax): ASSERT_EQ(pa[i], 0xdeadbeef, "return value"); break; default: if (!ASSERT_EQ(pb[i], pa[i], "register before-after value check")) fprintf(stdout, "failed register offset %u\n", offset); } /* * Check register seen from bpf program and register after * uretprobe_regs_trigger call */ switch (offset) { /* * These values will be different (not set in uretprobe_regs), * we don't care. */ case offsetof(struct pt_regs, orig_rax): case offsetof(struct pt_regs, rip): case offsetof(struct pt_regs, cs): case offsetof(struct pt_regs, rsp): case offsetof(struct pt_regs, ss): break; default: if (!ASSERT_EQ(pp[i], pa[i], "register prog-after value check")) fprintf(stdout, "failed register offset %u\n", offset); } } cleanup: uprobe_syscall__destroy(skel); } #define BPF_TESTMOD_UPROBE_TEST_FILE "/sys/kernel/bpf_testmod_uprobe" static int write_bpf_testmod_uprobe(unsigned long offset) { size_t n, ret; char buf[30]; int fd; n = sprintf(buf, "%lu", offset); fd = open(BPF_TESTMOD_UPROBE_TEST_FILE, O_WRONLY); if (fd < 0) return -errno; ret = write(fd, buf, n); close(fd); return ret != n ? (int) ret : 0; } static void test_uretprobe_regs_change(void) { struct pt_regs before = {}, after = {}; unsigned long *pb = (unsigned long *) &before; unsigned long *pa = (unsigned long *) &after; unsigned long cnt = sizeof(before)/sizeof(*pb); unsigned int i, err, offset; offset = get_uprobe_offset(uretprobe_regs_trigger); err = write_bpf_testmod_uprobe(offset); if (!ASSERT_OK(err, "register_uprobe")) return; uretprobe_regs(&before, &after); err = write_bpf_testmod_uprobe(0); if (!ASSERT_OK(err, "unregister_uprobe")) return; for (i = 0; i < cnt; i++) { unsigned int offset = i * sizeof(unsigned long); switch (offset) { case offsetof(struct pt_regs, rax): ASSERT_EQ(pa[i], 0x12345678deadbeef, "rax"); break; case offsetof(struct pt_regs, rcx): ASSERT_EQ(pa[i], 0x87654321feebdaed, "rcx"); break; case offsetof(struct pt_regs, r11): ASSERT_EQ(pa[i], (__u64) -1, "r11"); break; default: if (!ASSERT_EQ(pa[i], pb[i], "register before-after value check")) fprintf(stdout, "failed register offset %u\n", offset); } } } #ifndef __NR_uretprobe #define __NR_uretprobe 335 #endif __naked unsigned long uretprobe_syscall_call_1(void) { /* * Pretend we are uretprobe trampoline to trigger the return * probe invocation in order to verify we get SIGILL. */ asm volatile ( "pushq %rax\n" "pushq %rcx\n" "pushq %r11\n" "movq $" __stringify(__NR_uretprobe) ", %rax\n" "syscall\n" "popq %r11\n" "popq %rcx\n" "retq\n" ); } __naked unsigned long uretprobe_syscall_call(void) { asm volatile ( "call uretprobe_syscall_call_1\n" "retq\n" ); } static void test_uretprobe_syscall_call(void) { LIBBPF_OPTS(bpf_uprobe_multi_opts, opts, .retprobe = true, ); struct uprobe_syscall_executed *skel; int pid, status, err, go[2], c; if (!ASSERT_OK(pipe(go), "pipe")) return; skel = uprobe_syscall_executed__open_and_load(); if (!ASSERT_OK_PTR(skel, "uprobe_syscall_executed__open_and_load")) goto cleanup; pid = fork(); if (!ASSERT_GE(pid, 0, "fork")) goto cleanup; /* child */ if (pid == 0) { close(go[1]); /* wait for parent's kick */ err = read(go[0], &c, 1); if (err != 1) exit(-1); uretprobe_syscall_call(); _exit(0); } skel->links.test = bpf_program__attach_uprobe_multi(skel->progs.test, pid, "/proc/self/exe", "uretprobe_syscall_call", &opts); if (!ASSERT_OK_PTR(skel->links.test, "bpf_program__attach_uprobe_multi")) goto cleanup; /* kick the child */ write(go[1], &c, 1); err = waitpid(pid, &status, 0); ASSERT_EQ(err, pid, "waitpid"); /* verify the child got killed with SIGILL */ ASSERT_EQ(WIFSIGNALED(status), 1, "WIFSIGNALED"); ASSERT_EQ(WTERMSIG(status), SIGILL, "WTERMSIG"); /* verify the uretprobe program wasn't called */ ASSERT_EQ(skel->bss->executed, 0, "executed"); cleanup: uprobe_syscall_executed__destroy(skel); close(go[1]); close(go[0]); } /* * Borrowed from tools/testing/selftests/x86/test_shadow_stack.c. * * For use in inline enablement of shadow stack. * * The program can't return from the point where shadow stack gets enabled * because there will be no address on the shadow stack. So it can't use * syscall() for enablement, since it is a function. * * Based on code from nolibc.h. Keep a copy here because this can't pull * in all of nolibc.h. */ #define ARCH_PRCTL(arg1, arg2) \ ({ \ long _ret; \ register long _num asm("eax") = __NR_arch_prctl; \ register long _arg1 asm("rdi") = (long)(arg1); \ register long _arg2 asm("rsi") = (long)(arg2); \ \ asm volatile ( \ "syscall\n" \ : "=a"(_ret) \ : "r"(_arg1), "r"(_arg2), \ "0"(_num) \ : "rcx", "r11", "memory", "cc" \ ); \ _ret; \ }) #ifndef ARCH_SHSTK_ENABLE #define ARCH_SHSTK_ENABLE 0x5001 #define ARCH_SHSTK_DISABLE 0x5002 #define ARCH_SHSTK_SHSTK (1ULL << 0) #endif static void test_uretprobe_shadow_stack(void) { if (ARCH_PRCTL(ARCH_SHSTK_ENABLE, ARCH_SHSTK_SHSTK)) { test__skip(); return; } /* Run all of the uretprobe tests. */ test_uretprobe_regs_equal(); test_uretprobe_regs_change(); test_uretprobe_syscall_call(); ARCH_PRCTL(ARCH_SHSTK_DISABLE, ARCH_SHSTK_SHSTK); } #else static void test_uretprobe_regs_equal(void) { test__skip(); } static void test_uretprobe_regs_change(void) { test__skip(); } static void test_uretprobe_syscall_call(void) { test__skip(); } static void test_uretprobe_shadow_stack(void) { test__skip(); } #endif void test_uprobe_syscall(void) { if (test__start_subtest("uretprobe_regs_equal")) test_uretprobe_regs_equal(); if (test__start_subtest("uretprobe_regs_change")) test_uretprobe_regs_change(); if (test__start_subtest("uretprobe_syscall_call")) test_uretprobe_syscall_call(); if (test__start_subtest("uretprobe_shadow_stack")) test_uretprobe_shadow_stack(); }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1