313 lines
7.0 KiB
C
313 lines
7.0 KiB
C
// 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
|