ptrace: add PTRACE_GET_SYSCALL_INFO request

PTRACE_GET_SYSCALL_INFO is a generic ptrace API that lets ptracer obtain
details of the syscall the tracee is blocked in.

There are two reasons for a special syscall-related ptrace request.

Firstly, with the current ptrace API there are cases when ptracer cannot
retrieve necessary information about syscalls.  Some examples include:

 * The notorious int-0x80-from-64-bit-task issue. See [1] for details.
   In short, if a 64-bit task performs a syscall through int 0x80, its
   tracer has no reliable means to find out that the syscall was, in
   fact, a compat syscall, and misidentifies it.

 * Syscall-enter-stop and syscall-exit-stop look the same for the
   tracer. Common practice is to keep track of the sequence of
   ptrace-stops in order not to mix the two syscall-stops up. But it is
   not as simple as it looks; for example, strace had a (just recently
   fixed) long-standing bug where attaching strace to a tracee that is
   performing the execve system call led to the tracer identifying the
   following syscall-exit-stop as syscall-enter-stop, which messed up
   all the state tracking.

 * Since the introduction of commit 84d77d3f06e7 ("ptrace: Don't allow
   accessing an undumpable mm"), both PTRACE_PEEKDATA and
   process_vm_readv become unavailable when the process dumpable flag is
   cleared. On such architectures as ia64 this results in all syscall
   arguments being unavailable for the tracer.

Secondly, ptracers also have to support a lot of arch-specific code for
obtaining information about the tracee.  For some architectures, this
requires a ptrace(PTRACE_PEEKUSER, ...) invocation for every syscall
argument and return value.

ptrace(2) man page:

long ptrace(enum __ptrace_request request, pid_t pid,
            void *addr, void *data);
...
PTRACE_GET_SYSCALL_INFO
       Retrieve information about the syscall that caused the stop.
       The information is placed into the buffer pointed by "data"
       argument, which should be a pointer to a buffer of type
       "struct ptrace_syscall_info".
       The "addr" argument contains the size of the buffer pointed to
       by "data" argument (i.e., sizeof(struct ptrace_syscall_info)).
       The return value contains the number of bytes available
       to be written by the kernel.
       If the size of data to be written by the kernel exceeds the size
       specified by "addr" argument, the output is truncated.

[ldv@altlinux.org: selftests/seccomp/seccomp_bpf: update for PTRACE_GET_SYSCALL_INFO]
Link: http://lkml.kernel.org/r/20190708182904.GA12332@altlinux.org
Link: http://lkml.kernel.org/r/20190510152842.GF28558@altlinux.org
Signed-off-by: Elvira Khabirova <lineprinter@altlinux.org>
Co-developed-by: Dmitry V. Levin <ldv@altlinux.org>
Signed-off-by: Dmitry V. Levin <ldv@altlinux.org>
Reviewed-by: Oleg Nesterov <oleg@redhat.com>
Reviewed-by: Kees Cook <keescook@chromium.org>
Reviewed-by: Andy Lutomirski <luto@kernel.org>
Cc: Eugene Syromyatnikov <esyr@redhat.com>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Greentime Hu <greentime@andestech.com>
Cc: Helge Deller <deller@gmx.de>	[parisc]
Cc: James E.J. Bottomley <jejb@parisc-linux.org>
Cc: James Hogan <jhogan@kernel.org>
Cc: kbuild test robot <lkp@intel.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Paul Burton <paul.burton@mips.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Richard Kuo <rkuo@codeaurora.org>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Vincent Chen <deanbo422@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index 8446573..36fb3bb 100644 (file)
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -54,13 +54,15 @@ struct linux_binprm;
 /*
  * ptrace report for syscall entry and exit looks identical.
  */
-static inline int ptrace_report_syscall(struct pt_regs *regs)
+static inline int ptrace_report_syscall(struct pt_regs *regs,
+                                       unsigned long message)
 {
        int ptrace = current->ptrace;
 
        if (!(ptrace & PT_PTRACED))
                return 0;
 
+       current->ptrace_message = message;
        ptrace_notify(SIGTRAP | ((ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));
 
        /*
@@ -73,6 +75,7 @@ static inline int ptrace_report_syscall(struct pt_regs *regs)
                current->exit_code = 0;
        }
 
+       current->ptrace_message = 0;
        return fatal_signal_pending(current);
 }
 
@@ -98,7 +101,7 @@ static inline int ptrace_report_syscall(struct pt_regs *regs)
 static inline __must_check int tracehook_report_syscall_entry(
        struct pt_regs *regs)
 {
-       return ptrace_report_syscall(regs);
+       return ptrace_report_syscall(regs, PTRACE_EVENTMSG_SYSCALL_ENTRY);
 }
 
 /**
@@ -123,7 +126,7 @@ static inline void tracehook_report_syscall_exit(struct pt_regs *regs, int step)
        if (step)
                user_single_step_report(regs);
        else
-               ptrace_report_syscall(regs);
+               ptrace_report_syscall(regs, PTRACE_EVENTMSG_SYSCALL_EXIT);
 }
 
 /**

diff --git a/include/uapi/linux/ptrace.h b/include/uapi/linux/ptrace.h
index d5a1b8a..a71b6e3 100644 (file)
--- a/include/uapi/linux/ptrace.h
+++ b/include/uapi/linux/ptrace.h
@@ -73,6 +73,41 @@ struct seccomp_metadata {
        __u64 flags;            /* Output: filter's flags */
 };
 
+#define PTRACE_GET_SYSCALL_INFO                0x420e
+#define PTRACE_SYSCALL_INFO_NONE       0
+#define PTRACE_SYSCALL_INFO_ENTRY      1
+#define PTRACE_SYSCALL_INFO_EXIT       2
+#define PTRACE_SYSCALL_INFO_SECCOMP    3
+
+struct ptrace_syscall_info {
+       __u8 op;        /* PTRACE_SYSCALL_INFO_* */
+       __u32 arch __attribute__((__aligned__(sizeof(__u32))));
+       __u64 instruction_pointer;
+       __u64 stack_pointer;
+       union {
+               struct {
+                       __u64 nr;
+                       __u64 args[6];
+               } entry;
+               struct {
+                       __s64 rval;
+                       __u8 is_error;
+               } exit;
+               struct {
+                       __u64 nr;
+                       __u64 args[6];
+                       __u32 ret_data;
+               } seccomp;
+       };
+};
+
+/*
+ * These values are stored in task->ptrace_message
+ * by tracehook_report_syscall_* to describe the current syscall-stop.
+ */
+#define PTRACE_EVENTMSG_SYSCALL_ENTRY  1
+#define PTRACE_EVENTMSG_SYSCALL_EXIT   2
+
 /* Read signals from a shared (process wide) queue */
 #define PTRACE_PEEKSIGINFO_SHARED      (1 << 0)
 

diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 83a531c..cb9ddcc 100644 (file)
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -32,6 +32,8 @@
 #include <linux/compat.h>
 #include <linux/sched/signal.h>
 
+#include <asm/syscall.h>       /* for syscall_get_* */
+
 /*
  * Access another process' address space via ptrace.
  * Source/target buffer must be kernel space,
@@ -897,7 +899,100 @@ static int ptrace_regset(struct task_struct *task, int req, unsigned int type,
  * to ensure no machine forgets it.
  */
 EXPORT_SYMBOL_GPL(task_user_regset_view);
-#endif
+
+static unsigned long
+ptrace_get_syscall_info_entry(struct task_struct *child, struct pt_regs *regs,
+                             struct ptrace_syscall_info *info)
+{
+       unsigned long args[ARRAY_SIZE(info->entry.args)];
+       int i;
+
+       info->op = PTRACE_SYSCALL_INFO_ENTRY;
+       info->entry.nr = syscall_get_nr(child, regs);
+       syscall_get_arguments(child, regs, args);
+       for (i = 0; i < ARRAY_SIZE(args); i++)
+               info->entry.args[i] = args[i];
+
+       /* args is the last field in struct ptrace_syscall_info.entry */
+       return offsetofend(struct ptrace_syscall_info, entry.args);
+}
+
+static unsigned long
+ptrace_get_syscall_info_seccomp(struct task_struct *child, struct pt_regs *regs,
+                               struct ptrace_syscall_info *info)
+{
+       /*
+        * As struct ptrace_syscall_info.entry is currently a subset
+        * of struct ptrace_syscall_info.seccomp, it makes sense to
+        * initialize that subset using ptrace_get_syscall_info_entry().
+        * This can be reconsidered in the future if these structures
+        * diverge significantly enough.
+        */
+       ptrace_get_syscall_info_entry(child, regs, info);
+       info->op = PTRACE_SYSCALL_INFO_SECCOMP;
+       info->seccomp.ret_data = child->ptrace_message;
+
+       /* ret_data is the last field in struct ptrace_syscall_info.seccomp */
+       return offsetofend(struct ptrace_syscall_info, seccomp.ret_data);
+}
+
+static unsigned long
+ptrace_get_syscall_info_exit(struct task_struct *child, struct pt_regs *regs,
+                            struct ptrace_syscall_info *info)
+{
+       info->op = PTRACE_SYSCALL_INFO_EXIT;
+       info->exit.rval = syscall_get_error(child, regs);
+       info->exit.is_error = !!info->exit.rval;
+       if (!info->exit.is_error)
+               info->exit.rval = syscall_get_return_value(child, regs);
+
+       /* is_error is the last field in struct ptrace_syscall_info.exit */
+       return offsetofend(struct ptrace_syscall_info, exit.is_error);
+}
+
+static int
+ptrace_get_syscall_info(struct task_struct *child, unsigned long user_size,
+                       void __user *datavp)
+{
+       struct pt_regs *regs = task_pt_regs(child);
+       struct ptrace_syscall_info info = {
+               .op = PTRACE_SYSCALL_INFO_NONE,
+               .arch = syscall_get_arch(child),
+               .instruction_pointer = instruction_pointer(regs),
+               .stack_pointer = user_stack_pointer(regs),
+       };
+       unsigned long actual_size = offsetof(struct ptrace_syscall_info, entry);
+       unsigned long write_size;
+
+       /*
+        * This does not need lock_task_sighand() to access
+        * child->last_siginfo because ptrace_freeze_traced()
+        * called earlier by ptrace_check_attach() ensures that
+        * the tracee cannot go away and clear its last_siginfo.
+        */
+       switch (child->last_siginfo ? child->last_siginfo->si_code : 0) {
+       case SIGTRAP | 0x80:
+               switch (child->ptrace_message) {
+               case PTRACE_EVENTMSG_SYSCALL_ENTRY:
+                       actual_size = ptrace_get_syscall_info_entry(child, regs,
+                                                                   &info);
+                       break;
+               case PTRACE_EVENTMSG_SYSCALL_EXIT:
+                       actual_size = ptrace_get_syscall_info_exit(child, regs,
+                                                                  &info);
+                       break;
+               }
+               break;
+       case SIGTRAP | (PTRACE_EVENT_SECCOMP << 8):
+               actual_size = ptrace_get_syscall_info_seccomp(child, regs,
+                                                             &info);
+               break;
+       }
+
+       write_size = min(actual_size, user_size);
+       return copy_to_user(datavp, &info, write_size) ? -EFAULT : actual_size;
+}
+#endif /* CONFIG_HAVE_ARCH_TRACEHOOK */
 
 int ptrace_request(struct task_struct *child, long request,
                   unsigned long addr, unsigned long data)
@@ -1114,6 +1209,10 @@ int ptrace_request(struct task_struct *child, long request,
                        ret = __put_user(kiov.iov_len, &uiov->iov_len);
                break;
        }
+
+       case PTRACE_GET_SYSCALL_INFO:
+               ret = ptrace_get_syscall_info(child, addr, datavp);
+               break;
 #endif
 
        case PTRACE_SECCOMP_GET_FILTER:

diff --git a/tools/testing/selftests/seccomp/seccomp_bpf.c b/tools/testing/selftests/seccomp/seccomp_bpf.c
index dc66fe8..6ef7f16 100644 (file)
--- a/tools/testing/selftests/seccomp/seccomp_bpf.c
+++ b/tools/testing/selftests/seccomp/seccomp_bpf.c
@@ -1775,13 +1775,18 @@ void tracer_ptrace(struct __test_metadata *_metadata, pid_t tracee,
        unsigned long msg;
        static bool entry;
 
-       /* Make sure we got an empty message. */
+       /*
+        * The traditional way to tell PTRACE_SYSCALL entry/exit
+        * is by counting.
+        */
+       entry = !entry;
+
+       /* Make sure we got an appropriate message. */
        ret = ptrace(PTRACE_GETEVENTMSG, tracee, NULL, &msg);
        EXPECT_EQ(0, ret);
-       EXPECT_EQ(0, msg);
+       EXPECT_EQ(entry ? PTRACE_EVENTMSG_SYSCALL_ENTRY
+                       : PTRACE_EVENTMSG_SYSCALL_EXIT, msg);
 
-       /* The only way to tell PTRACE_SYSCALL entry/exit is by counting. */
-       entry = !entry;
        if (!entry)
                return;