forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
312 lines
7.0 KiB
312 lines
7.0 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (c) 2020 Collabora Ltd. |
|
* |
|
* Test code for syscall user dispatch |
|
*/ |
|
|
|
#define _GNU_SOURCE |
|
#include <sys/prctl.h> |
|
#include <sys/sysinfo.h> |
|
#include <sys/syscall.h> |
|
#include <signal.h> |
|
|
|
#include <asm/unistd.h> |
|
#include "../kselftest_harness.h" |
|
|
|
#ifndef PR_SET_SYSCALL_USER_DISPATCH |
|
# define PR_SET_SYSCALL_USER_DISPATCH 59 |
|
# define PR_SYS_DISPATCH_OFF 0 |
|
# define PR_SYS_DISPATCH_ON 1 |
|
# define SYSCALL_DISPATCH_FILTER_ALLOW 0 |
|
# define SYSCALL_DISPATCH_FILTER_BLOCK 1 |
|
#endif |
|
|
|
#ifndef SYS_USER_DISPATCH |
|
# define SYS_USER_DISPATCH 2 |
|
#endif |
|
|
|
#ifdef __NR_syscalls |
|
# define MAGIC_SYSCALL_1 (__NR_syscalls + 1) /* Bad Linux syscall number */ |
|
#else |
|
# define MAGIC_SYSCALL_1 (0xff00) /* Bad Linux syscall number */ |
|
#endif |
|
|
|
#define SYSCALL_DISPATCH_ON(x) ((x) = SYSCALL_DISPATCH_FILTER_BLOCK) |
|
#define SYSCALL_DISPATCH_OFF(x) ((x) = SYSCALL_DISPATCH_FILTER_ALLOW) |
|
|
|
/* Test Summary: |
|
* |
|
* - dispatch_trigger_sigsys: Verify if PR_SET_SYSCALL_USER_DISPATCH is |
|
* able to trigger SIGSYS on a syscall. |
|
* |
|
* - bad_selector: Test that a bad selector value triggers SIGSYS with |
|
* si_errno EINVAL. |
|
* |
|
* - bad_prctl_param: Test that the API correctly rejects invalid |
|
* parameters on prctl |
|
* |
|
* - dispatch_and_return: Test that a syscall is selectively dispatched |
|
* to userspace depending on the value of selector. |
|
* |
|
* - disable_dispatch: Test that the PR_SYS_DISPATCH_OFF correctly |
|
* disables the dispatcher |
|
* |
|
* - direct_dispatch_range: Test that a syscall within the allowed range |
|
* can bypass the dispatcher. |
|
*/ |
|
|
|
TEST_SIGNAL(dispatch_trigger_sigsys, SIGSYS) |
|
{ |
|
char sel = SYSCALL_DISPATCH_FILTER_ALLOW; |
|
struct sysinfo info; |
|
int ret; |
|
|
|
ret = sysinfo(&info); |
|
ASSERT_EQ(0, ret); |
|
|
|
ret = prctl(PR_SET_SYSCALL_USER_DISPATCH, PR_SYS_DISPATCH_ON, 0, 0, &sel); |
|
ASSERT_EQ(0, ret) { |
|
TH_LOG("Kernel does not support CONFIG_SYSCALL_USER_DISPATCH"); |
|
} |
|
|
|
SYSCALL_DISPATCH_ON(sel); |
|
|
|
sysinfo(&info); |
|
|
|
EXPECT_FALSE(true) { |
|
TH_LOG("Unreachable!"); |
|
} |
|
} |
|
|
|
TEST(bad_prctl_param) |
|
{ |
|
char sel = SYSCALL_DISPATCH_FILTER_ALLOW; |
|
int op; |
|
|
|
/* Invalid op */ |
|
op = -1; |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, op, 0, 0, &sel); |
|
ASSERT_EQ(EINVAL, errno); |
|
|
|
/* PR_SYS_DISPATCH_OFF */ |
|
op = PR_SYS_DISPATCH_OFF; |
|
|
|
/* offset != 0 */ |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, op, 0x1, 0x0, 0); |
|
EXPECT_EQ(EINVAL, errno); |
|
|
|
/* len != 0 */ |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, op, 0x0, 0xff, 0); |
|
EXPECT_EQ(EINVAL, errno); |
|
|
|
/* sel != NULL */ |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, op, 0x0, 0x0, &sel); |
|
EXPECT_EQ(EINVAL, errno); |
|
|
|
/* Valid parameter */ |
|
errno = 0; |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, op, 0x0, 0x0, 0x0); |
|
EXPECT_EQ(0, errno); |
|
|
|
/* PR_SYS_DISPATCH_ON */ |
|
op = PR_SYS_DISPATCH_ON; |
|
|
|
/* Dispatcher region is bad (offset > 0 && len == 0) */ |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, op, 0x1, 0x0, &sel); |
|
EXPECT_EQ(EINVAL, errno); |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, op, -1L, 0x0, &sel); |
|
EXPECT_EQ(EINVAL, errno); |
|
|
|
/* Invalid selector */ |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, op, 0x0, 0x1, (void *) -1); |
|
ASSERT_EQ(EFAULT, errno); |
|
|
|
/* |
|
* Dispatcher range overflows unsigned long |
|
*/ |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, PR_SYS_DISPATCH_ON, 1, -1L, &sel); |
|
ASSERT_EQ(EINVAL, errno) { |
|
TH_LOG("Should reject bad syscall range"); |
|
} |
|
|
|
/* |
|
* Allowed range overflows usigned long |
|
*/ |
|
prctl(PR_SET_SYSCALL_USER_DISPATCH, PR_SYS_DISPATCH_ON, -1L, 0x1, &sel); |
|
ASSERT_EQ(EINVAL, errno) { |
|
TH_LOG("Should reject bad syscall range"); |
|
} |
|
} |
|
|
|
/* |
|
* Use global selector for handle_sigsys tests, to avoid passing |
|
* selector to signal handler |
|
*/ |
|
char glob_sel; |
|
int nr_syscalls_emulated; |
|
int si_code; |
|
int si_errno; |
|
|
|
static void handle_sigsys(int sig, siginfo_t *info, void *ucontext) |
|
{ |
|
si_code = info->si_code; |
|
si_errno = info->si_errno; |
|
|
|
if (info->si_syscall == MAGIC_SYSCALL_1) |
|
nr_syscalls_emulated++; |
|
|
|
/* In preparation for sigreturn. */ |
|
SYSCALL_DISPATCH_OFF(glob_sel); |
|
} |
|
|
|
TEST(dispatch_and_return) |
|
{ |
|
long ret; |
|
struct sigaction act; |
|
sigset_t mask; |
|
|
|
glob_sel = 0; |
|
nr_syscalls_emulated = 0; |
|
si_code = 0; |
|
si_errno = 0; |
|
|
|
memset(&act, 0, sizeof(act)); |
|
sigemptyset(&mask); |
|
|
|
act.sa_sigaction = handle_sigsys; |
|
act.sa_flags = SA_SIGINFO; |
|
act.sa_mask = mask; |
|
|
|
ret = sigaction(SIGSYS, &act, NULL); |
|
ASSERT_EQ(0, ret); |
|
|
|
/* Make sure selector is good prior to prctl. */ |
|
SYSCALL_DISPATCH_OFF(glob_sel); |
|
|
|
ret = prctl(PR_SET_SYSCALL_USER_DISPATCH, PR_SYS_DISPATCH_ON, 0, 0, &glob_sel); |
|
ASSERT_EQ(0, ret) { |
|
TH_LOG("Kernel does not support CONFIG_SYSCALL_USER_DISPATCH"); |
|
} |
|
|
|
/* MAGIC_SYSCALL_1 doesn't exist. */ |
|
SYSCALL_DISPATCH_OFF(glob_sel); |
|
ret = syscall(MAGIC_SYSCALL_1); |
|
EXPECT_EQ(-1, ret) { |
|
TH_LOG("Dispatch triggered unexpectedly"); |
|
} |
|
|
|
/* MAGIC_SYSCALL_1 should be emulated. */ |
|
nr_syscalls_emulated = 0; |
|
SYSCALL_DISPATCH_ON(glob_sel); |
|
|
|
ret = syscall(MAGIC_SYSCALL_1); |
|
EXPECT_EQ(MAGIC_SYSCALL_1, ret) { |
|
TH_LOG("Failed to intercept syscall"); |
|
} |
|
EXPECT_EQ(1, nr_syscalls_emulated) { |
|
TH_LOG("Failed to emulate syscall"); |
|
} |
|
ASSERT_EQ(SYS_USER_DISPATCH, si_code) { |
|
TH_LOG("Bad si_code in SIGSYS"); |
|
} |
|
ASSERT_EQ(0, si_errno) { |
|
TH_LOG("Bad si_errno in SIGSYS"); |
|
} |
|
} |
|
|
|
TEST_SIGNAL(bad_selector, SIGSYS) |
|
{ |
|
long ret; |
|
struct sigaction act; |
|
sigset_t mask; |
|
struct sysinfo info; |
|
|
|
glob_sel = SYSCALL_DISPATCH_FILTER_ALLOW; |
|
nr_syscalls_emulated = 0; |
|
si_code = 0; |
|
si_errno = 0; |
|
|
|
memset(&act, 0, sizeof(act)); |
|
sigemptyset(&mask); |
|
|
|
act.sa_sigaction = handle_sigsys; |
|
act.sa_flags = SA_SIGINFO; |
|
act.sa_mask = mask; |
|
|
|
ret = sigaction(SIGSYS, &act, NULL); |
|
ASSERT_EQ(0, ret); |
|
|
|
/* Make sure selector is good prior to prctl. */ |
|
SYSCALL_DISPATCH_OFF(glob_sel); |
|
|
|
ret = prctl(PR_SET_SYSCALL_USER_DISPATCH, PR_SYS_DISPATCH_ON, 0, 0, &glob_sel); |
|
ASSERT_EQ(0, ret) { |
|
TH_LOG("Kernel does not support CONFIG_SYSCALL_USER_DISPATCH"); |
|
} |
|
|
|
glob_sel = -1; |
|
|
|
sysinfo(&info); |
|
|
|
/* Even though it is ready to catch SIGSYS, the signal is |
|
* supposed to be uncatchable. |
|
*/ |
|
|
|
EXPECT_FALSE(true) { |
|
TH_LOG("Unreachable!"); |
|
} |
|
} |
|
|
|
TEST(disable_dispatch) |
|
{ |
|
int ret; |
|
struct sysinfo info; |
|
char sel = 0; |
|
|
|
ret = prctl(PR_SET_SYSCALL_USER_DISPATCH, PR_SYS_DISPATCH_ON, 0, 0, &sel); |
|
ASSERT_EQ(0, ret) { |
|
TH_LOG("Kernel does not support CONFIG_SYSCALL_USER_DISPATCH"); |
|
} |
|
|
|
/* MAGIC_SYSCALL_1 doesn't exist. */ |
|
SYSCALL_DISPATCH_OFF(glob_sel); |
|
|
|
ret = prctl(PR_SET_SYSCALL_USER_DISPATCH, PR_SYS_DISPATCH_OFF, 0, 0, 0); |
|
EXPECT_EQ(0, ret) { |
|
TH_LOG("Failed to unset syscall user dispatch"); |
|
} |
|
|
|
/* Shouldn't have any effect... */ |
|
SYSCALL_DISPATCH_ON(glob_sel); |
|
|
|
ret = syscall(__NR_sysinfo, &info); |
|
EXPECT_EQ(0, ret) { |
|
TH_LOG("Dispatch triggered unexpectedly"); |
|
} |
|
} |
|
|
|
TEST(direct_dispatch_range) |
|
{ |
|
int ret = 0; |
|
struct sysinfo info; |
|
char sel = SYSCALL_DISPATCH_FILTER_ALLOW; |
|
|
|
/* |
|
* Instead of calculating libc addresses; allow the entire |
|
* memory map and lock the selector. |
|
*/ |
|
ret = prctl(PR_SET_SYSCALL_USER_DISPATCH, PR_SYS_DISPATCH_ON, 0, -1L, &sel); |
|
ASSERT_EQ(0, ret) { |
|
TH_LOG("Kernel does not support CONFIG_SYSCALL_USER_DISPATCH"); |
|
} |
|
|
|
SYSCALL_DISPATCH_ON(sel); |
|
|
|
ret = sysinfo(&info); |
|
ASSERT_EQ(0, ret) { |
|
TH_LOG("Dispatch triggered unexpectedly"); |
|
} |
|
} |
|
|
|
TEST_HARNESS_MAIN
|
|
|