renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-17 01:34:00 +08:00
Code

ptrace: Remove maxargs from task_current_syscall()

Browse Source 
task_current_syscall() has a single user that passes in 6 for maxargs, which
is the maximum arguments that can be used to get system calls from
syscall_get_arguments(). Instead of passing in a number of arguments to
grab, just get 6 arguments. The args argument even specifies that it's an
array of 6 items.

This will also allow changing syscall_get_arguments() to not get a variable
number of arguments, but always grab 6.

Linus also suggested not passing in a bunch of arguments to
task_current_syscall() but to instead pass in a pointer to a structure, and
just fill the structure. struct seccomp_data has almost all the parameters
that is needed except for the stack pointer (sp). As seccomp_data is part of
uapi, and I'm afraid to change it, a new structure was created
"syscall_info", which includes seccomp_data and adds the "sp" field.

Link: http://lkml.kernel.org/r/20161107213233.466776454@goodmis.org

Cc: Andy Lutomirski <luto@kernel.org>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: linux-fsdevel@vger.kernel.org
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
This commit is contained in:
Steven Rostedt (Red Hat) 2016-11-07 16:26:35 -05:00 committed by Steven Rostedt (VMware)
parent 79a3aaa7b8
commit 631b7abacd
3 changed files with 42 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
fs/proc/base.c
View File

@ -616,24 +616,25 @@ static int proc_pid_limits(struct seq_file *m, struct pid_namespace *ns,
static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns, static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns,
struct pid *pid, struct task_struct *task) struct pid *pid, struct task_struct *task)
{ {
long nr; struct syscall_info info;
unsigned long args[6], sp, pc; u64 *args = &info.data.args[0];
int res; int res;
res = lock_trace(task); res = lock_trace(task);
if (res) if (res)
return res; return res;
if (task_current_syscall(task, &nr, args, 6, &sp, &pc)) if (task_current_syscall(task, &info))
seq_puts(m, "running\n"); seq_puts(m, "running\n");
else if (nr < 0) else if (info.data.nr < 0)
seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc); seq_printf(m, "%d 0x%llx 0x%llx\n",
info.data.nr, info.sp, info.data.instruction_pointer);
else else
seq_printf(m, seq_printf(m,
"%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", "%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n",
nr, info.data.nr,
args[0], args[1], args[2], args[3], args[4], args[5], args[0], args[1], args[2], args[3], args[4], args[5],
sp, pc); info.sp, info.data.instruction_pointer);
unlock_trace(task); unlock_trace(task);
return 0; return 0;

11
include/linux/ptrace.h
View File

@ -9,6 +9,13 @@
#include <linux/bug.h> /* For BUG_ON. */ #include <linux/bug.h> /* For BUG_ON. */
#include <linux/pid_namespace.h> /* For task_active_pid_ns. */ #include <linux/pid_namespace.h> /* For task_active_pid_ns. */
#include <uapi/linux/ptrace.h> #include <uapi/linux/ptrace.h>
#include <linux/seccomp.h>
/* Add sp to seccomp_data, as seccomp is user API, we don't want to modify it */
struct syscall_info {
__u64 sp;
struct seccomp_data data;
};
extern int ptrace_access_vm(struct task_struct *tsk, unsigned long addr, extern int ptrace_access_vm(struct task_struct *tsk, unsigned long addr,
void *buf, int len, unsigned int gup_flags); void *buf, int len, unsigned int gup_flags);
@ -407,9 +414,7 @@ static inline void user_single_step_report(struct pt_regs *regs)
#define current_user_stack_pointer() user_stack_pointer(current_pt_regs()) #define current_user_stack_pointer() user_stack_pointer(current_pt_regs())
#endif #endif
extern int task_current_syscall(struct task_struct *target, long *callno, extern int task_current_syscall(struct task_struct *target, struct syscall_info *info);
unsigned long args[6], unsigned int maxargs,
unsigned long *sp, unsigned long *pc);
extern void sigaction_compat_abi(struct k_sigaction *act, struct k_sigaction *oact); extern void sigaction_compat_abi(struct k_sigaction *act, struct k_sigaction *oact);
#endif #endif

57
lib/syscall.c
View File

@ -5,16 +5,14 @@
#include <linux/export.h> #include <linux/export.h>
#include <asm/syscall.h> #include <asm/syscall.h>
static int collect_syscall(struct task_struct *target, long *callno, static int collect_syscall(struct task_struct *target, struct syscall_info *info)
unsigned long args[6], unsigned int maxargs,
unsigned long *sp, unsigned long *pc)
{ {
struct pt_regs *regs; struct pt_regs *regs;
if (!try_get_task_stack(target)) { if (!try_get_task_stack(target)) {
/* Task has no stack, so the task isn't in a syscall. */ /* Task has no stack, so the task isn't in a syscall. */
*sp = *pc = 0; memset(info, 0, sizeof(*info));
*callno = -1; info->data.nr = -1;
return 0; return 0;
} }
@ -24,12 +22,13 @@ static int collect_syscall(struct task_struct *target, long *callno,
return -EAGAIN; return -EAGAIN;
} }
*sp = user_stack_pointer(regs); info->sp = user_stack_pointer(regs);
*pc = instruction_pointer(regs); info->data.instruction_pointer = instruction_pointer(regs);
*callno = syscall_get_nr(target, regs); info->data.nr = syscall_get_nr(target, regs);
if (*callno != -1L && maxargs > 0) if (info->data.nr != -1L)
syscall_get_arguments(target, regs, 0, maxargs, args); syscall_get_arguments(target, regs, 0, 6,
(unsigned long *)&info->data.args[0]);
put_task_stack(target); put_task_stack(target);
return 0; return 0;
@ -38,41 +37,35 @@ static int collect_syscall(struct task_struct *target, long *callno,
/** /**
* task_current_syscall - Discover what a blocked task is doing. * task_current_syscall - Discover what a blocked task is doing.
* @target: thread to examine * @target: thread to examine
* @callno: filled with system call number or -1 * @info: structure with the following fields:
* @args: filled with @maxargs system call arguments * .sp - filled with user stack pointer
* @maxargs: number of elements in @args to fill * .data.nr - filled with system call number or -1
* @sp: filled with user stack pointer * .data.args - filled with @maxargs system call arguments
* @pc: filled with user PC * .data.instruction_pointer - filled with user PC
* *
* If @target is blocked in a system call, returns zero with *@callno * If @target is blocked in a system call, returns zero with @info.data.nr
* set to the the call's number and @args filled in with its arguments. * set to the the call's number and @info.data.args filled in with its
* Registers not used for system call arguments may not be available and * arguments. Registers not used for system call arguments may not be available
* it is not kosher to use &struct user_regset calls while the system * and it is not kosher to use &struct user_regset calls while the system
* call is still in progress. Note we may get this result if @target * call is still in progress. Note we may get this result if @target
* has finished its system call but not yet returned to user mode, such * has finished its system call but not yet returned to user mode, such
* as when it's stopped for signal handling or syscall exit tracing. * as when it's stopped for signal handling or syscall exit tracing.
* *
* If @target is blocked in the kernel during a fault or exception, * If @target is blocked in the kernel during a fault or exception,
* returns zero with *@callno set to -1 and does not fill in @args. * returns zero with *@info.data.nr set to -1 and does not fill in
* If so, it's now safe to examine @target using &struct user_regset * @info.data.args. If so, it's now safe to examine @target using
* get() calls as long as we're sure @target won't return to user mode. * &struct user_regset get() calls as long as we're sure @target won't return
* to user mode.
* *
* Returns -%EAGAIN if @target does not remain blocked. * Returns -%EAGAIN if @target does not remain blocked.
*
* Returns -%EINVAL if @maxargs is too large (maximum is six).
*/ */
int task_current_syscall(struct task_struct *target, long *callno, int task_current_syscall(struct task_struct *target, struct syscall_info *info)
unsigned long args[6], unsigned int maxargs,
unsigned long *sp, unsigned long *pc)
{ {
long state; long state;
unsigned long ncsw; unsigned long ncsw;
if (unlikely(maxargs > 6))
return -EINVAL;
if (target == current) if (target == current)
return collect_syscall(target, callno, args, maxargs, sp, pc); return collect_syscall(target, info);
state = target->state; state = target->state;
if (unlikely(!state)) if (unlikely(!state))
@ -80,7 +73,7 @@ int task_current_syscall(struct task_struct *target, long *callno,
ncsw = wait_task_inactive(target, state); ncsw = wait_task_inactive(target, state);
if (unlikely(!ncsw) || if (unlikely(!ncsw) ||
unlikely(collect_syscall(target, callno, args, maxargs, sp, pc)) || unlikely(collect_syscall(target, info)) ||
unlikely(wait_task_inactive(target, state) != ncsw)) unlikely(wait_task_inactive(target, state) != ncsw))
return -EAGAIN; return -EAGAIN;