arm64: ptrace: allow tracer to skip a system call

Note: This patch is from v6 of Takahiro's proposed
"arm64: add seccomp support" patchset (leecam@google.com)

If tracer specifies -1 as a syscall number, this traced system call should
be skipped with a value in x0 used as a return value.
This patch enables this semantics, but there is a restriction here:

   when syscall(-1) is issued by user, tracer cannot skip this system call
   and modify a return value at syscall entry.

In order to ease this flavor, we need to treat whatever value in x0 as
a return value, but this might result in a bogus value being returned,
especially when tracer doesn't do anything at this syscall.
So we always return ENOSYS instead, while we have another chance to change
a return value at syscall exit.

Please also note:
* syscall entry tracing and syscall exit tracing (ftrace tracepoint and
  audit) are always executed, if enabled, even when skipping a system call
  (that is, -1).
  In this way, we can avoid a potential bug where audit_syscall_entry()
  might be called without audit_syscall_exit() at the previous system call
  being called, that would cause OOPs in audit_syscall_entry().

* syscallno may also be set to -1 if a fatal signal (SIGKILL) is detected
  in tracehook_report_syscall_entry(), but since a value set to x0 (ENOSYS)
  is not used in this case, we may neglect the case.

Signed-off-by: AKASHI Takahiro <takahiro.akashi <at> linaro.org>
Conflicts:
	arch/arm64/kernel/entry.S

Change-Id: Ifcdcdbcb7c8cf97e5b5f1086a1ea4107e1d4f9a8

diff --git a/arch/arm64/include/asm/ptrace.h b/arch/arm64/include/asm/ptrace.h
index dbe3b00d1eb76a79cd709f8964fec84c023fefa4..c0ebe6fade630ef6f124f9a345600290de473055 100644 (file)
--- a/arch/arm64/include/asm/ptrace.h
+++ b/arch/arm64/include/asm/ptrace.h
@@ -60,6 +60,14 @@
 #define COMPAT_PT_TEXT_ADDR            0x10000
 #define COMPAT_PT_DATA_ADDR            0x10004
 #define COMPAT_PT_TEXT_END_ADDR                0x10008
+
+/*
+ * used to skip a system call when tracer changes its number to -1
+ * with ptrace(PTRACE_SET_SYSCALL)
+ */
+#define RET_SKIP_SYSCALL       -1
+#define IS_SKIP_SYSCALL(no)    ((int)(no & 0xffffffff) == -1)
+
 #ifndef __ASSEMBLY__
 
 /* sizeof(struct user) for AArch32 */

diff --git a/arch/arm64/kernel/entry.S b/arch/arm64/kernel/entry.S
index 3c93e1a9ea8ddb4d59790eefbbd809279403e6d1..a30fab9ea2a30709f34803918677887514655800 100644 (file)
--- a/arch/arm64/kernel/entry.S
+++ b/arch/arm64/kernel/entry.S
@@ -25,6 +25,7 @@
 #include <asm/asm-offsets.h>
 #include <asm/errno.h>
 #include <asm/esr.h>
+#include <asm/ptrace.h>
 #include <asm/thread_info.h>
 #include <asm/unistd.h>
 
@@ -662,6 +663,8 @@ __sys_trace:
        mov     x0, sp
        bl      syscall_trace_enter
        adr     lr, __sys_trace_return          // return address
+       cmp     w0, #RET_SKIP_SYSCALL           // skip syscall?
+       b.eq    __sys_trace_return_skipped
        uxtw    scno, w0                        // syscall number (possibly new)
        mov     x1, sp                          // pointer to regs
        cmp     scno, sc_nr                     // check upper syscall limit
@@ -675,6 +678,7 @@ __sys_trace:
 
 __sys_trace_return:
        str     x0, [sp]                        // save returned x0
+__sys_trace_return_skipped:                    // x0 already in regs[0]
        mov     x0, sp
        bl      syscall_trace_exit
        b       ret_to_user

diff --git a/arch/arm64/kernel/ptrace.c b/arch/arm64/kernel/ptrace.c
index 56a62ebf2bafb1696c2ca94b3af63952860804e8..2a6edfb0079b237209803549a89a3d2c4720846d 100644 (file)
--- a/arch/arm64/kernel/ptrace.c
+++ b/arch/arm64/kernel/ptrace.c
@@ -1108,9 +1108,29 @@ static void tracehook_report_syscall(struct pt_regs *regs,
 
 asmlinkage int syscall_trace_enter(struct pt_regs *regs)
 {
+       unsigned int saved_syscallno = regs->syscallno;
+
        if (test_thread_flag(TIF_SYSCALL_TRACE))
                tracehook_report_syscall(regs, PTRACE_SYSCALL_ENTER);
 
+       if (IS_SKIP_SYSCALL(regs->syscallno)) {
+               /*
+                * RESTRICTION: we can't modify a return value of user
+                * issued syscall(-1) here. In order to ease this flavor,
+                * we need to treat whatever value in x0 as a return value,
+                * but this might result in a bogus value being returned.
+                */
+               /*
+                * NOTE: syscallno may also be set to -1 if fatal signal is
+                * detected in tracehook_report_syscall_entry(), but since
+                * a value set to x0 here is not used in this case, we may
+                * neglect the case.
+                */
+               if (!test_thread_flag(TIF_SYSCALL_TRACE) ||
+                               (IS_SKIP_SYSCALL(saved_syscallno)))
+                       regs->regs[0] = -ENOSYS;
+       }
+
        audit_syscall_entry(syscall_get_arch(), regs->syscallno,
                regs->orig_x0, regs->regs[1], regs->regs[2], regs->regs[3]);