x86/entry: Add new, comprehensible entry and exit handlers written in C

The current x86 entry and exit code, written in a mixture of assembly and
C code, is incomprehensible due to being open-coded in a lot of places
without coherent documentation.

It appears to work primary by luck and duct tape: i.e. obvious runtime
failures were fixed on-demand, without re-thinking the design.

Due to those reasons our confidence level in that code is low, and it is
very difficult to incrementally improve.

Add new code written in C, in preparation for simply deleting the old
entry code.

prepare_exit_to_usermode() is a new function that will handle all
slow path exits to user mode.  It is called with IRQs disabled
and it leaves us in a state in which it is safe to immediately
return to user mode.  IRQs must not be re-enabled at any point
after prepare_exit_to_usermode() returns and user mode is actually
entered. (We can, of course, fail to enter user mode and treat
that failure as a fresh entry to kernel mode.)

All callers of do_notify_resume() will be migrated to call
prepare_exit_to_usermode() instead; prepare_exit_to_usermode() needs
to do everything that do_notify_resume() does today, but it also
takes care of scheduling and context tracking.  Unlike
do_notify_resume(), it does not need to be called in a loop.

syscall_return_slowpath() is exactly what it sounds like: it will
be called on any syscall exit slow path. It will replace
syscall_trace_leave() and it calls prepare_exit_to_usermode() on the
way out.

Signed-off-by: Andy Lutomirski <luto@kernel.org>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Denys Vlasenko <vda.linux@googlemail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: paulmck@linux.vnet.ibm.com
Link: http://lkml.kernel.org/r/c57c8b87661a4152801d7d3786eac2d1a2f209dd.1435952415.git.luto@kernel.org
[ Improved the changelog a bit. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c
index 9a327ee24eef088a5c436e18831d808017cfb160..febc53086a691d4a19808dd8ad2991c51675d572 100644 (file)
--- a/arch/x86/entry/common.c
+++ b/arch/x86/entry/common.c
@@ -207,6 +207,7 @@ long syscall_trace_enter(struct pt_regs *regs)
                return syscall_trace_enter_phase2(regs, arch, phase1_result);
 }
 
+/* Deprecated. */
 void syscall_trace_leave(struct pt_regs *regs)
 {
        bool step;
@@ -237,8 +238,117 @@ void syscall_trace_leave(struct pt_regs *regs)
        user_enter();
 }
 
+static struct thread_info *pt_regs_to_thread_info(struct pt_regs *regs)
+{
+       unsigned long top_of_stack =
+               (unsigned long)(regs + 1) + TOP_OF_KERNEL_STACK_PADDING;
+       return (struct thread_info *)(top_of_stack - THREAD_SIZE);
+}
+
+/* Called with IRQs disabled. */
+__visible void prepare_exit_to_usermode(struct pt_regs *regs)
+{
+       if (WARN_ON(!irqs_disabled()))
+               local_irq_disable();
+
+       /*
+        * In order to return to user mode, we need to have IRQs off with
+        * none of _TIF_SIGPENDING, _TIF_NOTIFY_RESUME, _TIF_USER_RETURN_NOTIFY,
+        * _TIF_UPROBE, or _TIF_NEED_RESCHED set.  Several of these flags
+        * can be set at any time on preemptable kernels if we have IRQs on,
+        * so we need to loop.  Disabling preemption wouldn't help: doing the
+        * work to clear some of the flags can sleep.
+        */
+       while (true) {
+               u32 cached_flags =
+                       READ_ONCE(pt_regs_to_thread_info(regs)->flags);
+
+               if (!(cached_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME |
+                                     _TIF_UPROBE | _TIF_NEED_RESCHED)))
+                       break;
+
+               /* We have work to do. */
+               local_irq_enable();
+
+               if (cached_flags & _TIF_NEED_RESCHED)
+                       schedule();
+
+               if (cached_flags & _TIF_UPROBE)
+                       uprobe_notify_resume(regs);
+
+               /* deal with pending signal delivery */
+               if (cached_flags & _TIF_SIGPENDING)
+                       do_signal(regs);
+
+               if (cached_flags & _TIF_NOTIFY_RESUME) {
+                       clear_thread_flag(TIF_NOTIFY_RESUME);
+                       tracehook_notify_resume(regs);
+               }
+
+               if (cached_flags & _TIF_USER_RETURN_NOTIFY)
+                       fire_user_return_notifiers();
+
+               /* Disable IRQs and retry */
+               local_irq_disable();
+       }
+
+       user_enter();
+}
+
+/*
+ * Called with IRQs on and fully valid regs.  Returns with IRQs off in a
+ * state such that we can immediately switch to user mode.
+ */
+__visible void syscall_return_slowpath(struct pt_regs *regs)
+{
+       struct thread_info *ti = pt_regs_to_thread_info(regs);
+       u32 cached_flags = READ_ONCE(ti->flags);
+       bool step;
+
+       CT_WARN_ON(ct_state() != CONTEXT_KERNEL);
+
+       if (WARN(irqs_disabled(), "syscall %ld left IRQs disabled",
+                regs->orig_ax))
+               local_irq_enable();
+
+       /*
+        * First do one-time work.  If these work items are enabled, we
+        * want to run them exactly once per syscall exit with IRQs on.
+        */
+       if (cached_flags & (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT |
+                           _TIF_SINGLESTEP | _TIF_SYSCALL_TRACEPOINT)) {
+               audit_syscall_exit(regs);
+
+               if (cached_flags & _TIF_SYSCALL_TRACEPOINT)
+                       trace_sys_exit(regs, regs->ax);
+
+               /*
+                * If TIF_SYSCALL_EMU is set, we only get here because of
+                * TIF_SINGLESTEP (i.e. this is PTRACE_SYSEMU_SINGLESTEP).
+                * We already reported this syscall instruction in
+                * syscall_trace_enter().
+                */
+               step = unlikely(
+                       (cached_flags & (_TIF_SINGLESTEP | _TIF_SYSCALL_EMU))
+                       == _TIF_SINGLESTEP);
+               if (step || cached_flags & _TIF_SYSCALL_TRACE)
+                       tracehook_report_syscall_exit(regs, step);
+       }
+
+#ifdef CONFIG_COMPAT
+       /*
+        * Compat syscalls set TS_COMPAT.  Make sure we clear it before
+        * returning to user mode.
+        */
+       ti->status &= ~TS_COMPAT;
+#endif
+
+       local_irq_disable();
+       prepare_exit_to_usermode(regs);
+}
+
 /*
- * notification of userspace execution resumption
+ * Deprecated notification of userspace execution resumption
  * - triggered by the TIF_WORK_MASK flags
  */
 __visible void