mirror of
https://github.com/tbsdtv/linux_media.git
synced 2025-07-23 12:43:29 +02:00
463b7715e7
To support checkpoint/restart, ptrace must be able to set the selector of the tracee. The selector is a user pointer that may be subject to memory tagging extensions on some architectures (namely ARM MTE). access_ok() clears memory tags for tagged addresses if the current task has memory tagging enabled. This obviously fails when ptrace modifies the selector of a tracee when tracer and tracee do not have the same memory tagging enabled state. Solve this by untagging the selector address before handing it to access_ok(), like other ptrace functions which modify tracee pointers do. Obviously a tracer can set an invalid selector address for the tracee, but that's independent of tagging and a general capability of the tracer. Suggested-by: Catalin Marinas <catalin.marinas@arm.com> Signed-off-by: Gregory Price <gregory.price@memverge.com> Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Catalin Marinas <catalin.marinas@arm.com> Acked-by: Oleg Nesterov <oleg@redhat.com> Link: https://lore.kernel.org/all/ZCWXE04nLZ4pXEtM@arm.com/ Link: https://lore.kernel.org/r/20230407171834.3558-3-gregory.price@memverge.com
125 lines
3.0 KiB
C
125 lines
3.0 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2020 Collabora Ltd.
|
|
*/
|
|
#include <linux/sched.h>
|
|
#include <linux/prctl.h>
|
|
#include <linux/syscall_user_dispatch.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/signal.h>
|
|
#include <linux/elf.h>
|
|
|
|
#include <linux/sched/signal.h>
|
|
#include <linux/sched/task_stack.h>
|
|
|
|
#include <asm/syscall.h>
|
|
|
|
#include "common.h"
|
|
|
|
static void trigger_sigsys(struct pt_regs *regs)
|
|
{
|
|
struct kernel_siginfo info;
|
|
|
|
clear_siginfo(&info);
|
|
info.si_signo = SIGSYS;
|
|
info.si_code = SYS_USER_DISPATCH;
|
|
info.si_call_addr = (void __user *)KSTK_EIP(current);
|
|
info.si_errno = 0;
|
|
info.si_arch = syscall_get_arch(current);
|
|
info.si_syscall = syscall_get_nr(current, regs);
|
|
|
|
force_sig_info(&info);
|
|
}
|
|
|
|
bool syscall_user_dispatch(struct pt_regs *regs)
|
|
{
|
|
struct syscall_user_dispatch *sd = ¤t->syscall_dispatch;
|
|
char state;
|
|
|
|
if (likely(instruction_pointer(regs) - sd->offset < sd->len))
|
|
return false;
|
|
|
|
if (unlikely(arch_syscall_is_vdso_sigreturn(regs)))
|
|
return false;
|
|
|
|
if (likely(sd->selector)) {
|
|
/*
|
|
* access_ok() is performed once, at prctl time, when
|
|
* the selector is loaded by userspace.
|
|
*/
|
|
if (unlikely(__get_user(state, sd->selector))) {
|
|
force_exit_sig(SIGSEGV);
|
|
return true;
|
|
}
|
|
|
|
if (likely(state == SYSCALL_DISPATCH_FILTER_ALLOW))
|
|
return false;
|
|
|
|
if (state != SYSCALL_DISPATCH_FILTER_BLOCK) {
|
|
force_exit_sig(SIGSYS);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
sd->on_dispatch = true;
|
|
syscall_rollback(current, regs);
|
|
trigger_sigsys(regs);
|
|
|
|
return true;
|
|
}
|
|
|
|
static int task_set_syscall_user_dispatch(struct task_struct *task, unsigned long mode,
|
|
unsigned long offset, unsigned long len,
|
|
char __user *selector)
|
|
{
|
|
switch (mode) {
|
|
case PR_SYS_DISPATCH_OFF:
|
|
if (offset || len || selector)
|
|
return -EINVAL;
|
|
break;
|
|
case PR_SYS_DISPATCH_ON:
|
|
/*
|
|
* Validate the direct dispatcher region just for basic
|
|
* sanity against overflow and a 0-sized dispatcher
|
|
* region. If the user is able to submit a syscall from
|
|
* an address, that address is obviously valid.
|
|
*/
|
|
if (offset && offset + len <= offset)
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* access_ok() will clear memory tags for tagged addresses
|
|
* if current has memory tagging enabled.
|
|
|
|
* To enable a tracer to set a tracees selector the
|
|
* selector address must be untagged for access_ok(),
|
|
* otherwise an untagged tracer will always fail to set a
|
|
* tagged tracees selector.
|
|
*/
|
|
if (selector && !access_ok(untagged_addr(selector), sizeof(*selector)))
|
|
return -EFAULT;
|
|
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
task->syscall_dispatch.selector = selector;
|
|
task->syscall_dispatch.offset = offset;
|
|
task->syscall_dispatch.len = len;
|
|
task->syscall_dispatch.on_dispatch = false;
|
|
|
|
if (mode == PR_SYS_DISPATCH_ON)
|
|
set_task_syscall_work(task, SYSCALL_USER_DISPATCH);
|
|
else
|
|
clear_task_syscall_work(task, SYSCALL_USER_DISPATCH);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int set_syscall_user_dispatch(unsigned long mode, unsigned long offset,
|
|
unsigned long len, char __user *selector)
|
|
{
|
|
return task_set_syscall_user_dispatch(current, mode, offset, len, selector);
|
|
}
|