uml: more page fault path trimming

More trimming of the page fault path.

Permissions are passed around in a single int rather than one bit per
int.  The permission values are copied from libc so that they can be
passed to mmap and mprotect without any further conversion.

The register sets used by do_syscall_stub and copy_context_skas0 are
initialized once, at boot time, rather than once per call.

wait_stub_done checks whether it is getting the signals it expects by
comparing the wait status to a mask containing bits for the signals of
interest rather than comparing individually to the signal numbers.  It
also has one check for a wait failure instead of two.  The caller is
expected to do the initial continue of the stub.  This gets rid of an
argument and some logic.  The fname argument is gone, as that can be
had from a stack trace.

user_signal() is collapsed into userspace() as it is basically one or
two lines of code afterwards.

The physical memory remapping stuff is gone, as it is unused.

flush_tlb_page is inlined.

Signed-off-by: Jeff Dike <jdike@linux.intel.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

3 files changed, 103 insertions, 87 deletions

diff --git a/arch/um/os-Linux/skas/mem.c b/arch/um/os-Linux/skas/mem.c
index af0790719b77..8e490fff3d47 100644
--- a/arch/um/os-Linux/skas/mem.c
+++ b/arch/um/os-Linux/skas/mem.c
@@ -24,10 +24,11 @@
 #include "uml-config.h"
 #include "sysdep/ptrace.h"
 #include "sysdep/stub.h"
+#include "init.h"
 
 extern unsigned long batch_syscall_stub, __syscall_stub_start;
 
-extern void wait_stub_done(int pid, int sig, char * fname);
+extern void wait_stub_done(int pid);
 
 static inline unsigned long *check_init_stack(struct mm_id * mm_idp,
                                               unsigned long *stack)
@@ -39,6 +40,19 @@ static inline unsigned long *check_init_stack(struct mm_id * mm_idp,
         return stack;
 }
 
+static unsigned long syscall_regs[MAX_REG_NR];
+
+static int __init init_syscall_regs(void)
+{
+        get_safe_registers(syscall_regs, NULL);
+        syscall_regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
+                ((unsigned long) &batch_syscall_stub -
+                 (unsigned long) &__syscall_stub_start);
+        return 0;
+}
+
+__initcall(init_syscall_regs);
+
 extern int proc_mm;
 
 int single_count = 0;
@@ -47,12 +61,11 @@ int multi_op_count = 0;
 
 static inline long do_syscall_stub(struct mm_id * mm_idp, void **addr)
 {
-        unsigned long regs[MAX_REG_NR];
         int n, i;
         long ret, offset;
         unsigned long * data;
         unsigned long * syscall;
-        int pid = mm_idp->u.pid;
+        int err, pid = mm_idp->u.pid;
 
         if(proc_mm)
 #warning Need to look up userspace_pid by cpu
@@ -60,21 +73,21 @@ static inline long do_syscall_stub(struct mm_id * mm_idp, void **addr)
 
         multi_count++;
 
-        get_safe_registers(regs, NULL);
-        regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
-                ((unsigned long) &batch_syscall_stub -
-                 (unsigned long) &__syscall_stub_start);
-
-        n = ptrace_setregs(pid, regs);
+        n = ptrace_setregs(pid, syscall_regs);
         if(n < 0){
                 printk("Registers - \n");
                 for(i = 0; i < MAX_REG_NR; i++)
-                        printk("\t%d\t0x%lx\n", i, regs[i]);
+                        printk("\t%d\t0x%lx\n", i, syscall_regs[i]);
                 panic("do_syscall_stub : PTRACE_SETREGS failed, errno = %d\n",
                       -n);
         }
 
-        wait_stub_done(pid, 0, "do_syscall_stub");
+        err = ptrace(PTRACE_CONT, pid, 0, 0);
+        if(err)
+                panic("Failed to continue stub, pid = %d, errno = %d\n", pid,
+                      errno);
+
+        wait_stub_done(pid);
 
         /* When the stub stops, we find the following values on the
          * beginning of the stack:
@@ -176,14 +189,10 @@ long syscall_stub_data(struct mm_id * mm_idp,
         return 0;
 }
 
-int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len,
-        int r, int w, int x, int phys_fd, unsigned long long offset,
-        int done, void **data)
+int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len, int prot,
+        int phys_fd, unsigned long long offset, int done, void **data)
 {
-        int prot, ret;
-
-        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
-                (x ? PROT_EXEC : 0);
+        int ret;
 
         if(proc_mm){
                 struct proc_mm_op map;
@@ -253,13 +262,11 @@ int unmap(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
 }
 
 int protect(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
-            int r, int w, int x, int done, void **data)
+            unsigned int prot, int done, void **data)
 {
         struct proc_mm_op protect;
-        int prot, ret;
+        int ret;
 
-        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
-                (x ? PROT_EXEC : 0);
         if(proc_mm){
                 int fd = mm_idp->u.mm_fd;
 
diff --git a/arch/um/os-Linux/skas/process.c b/arch/um/os-Linux/skas/process.c
index 1f39f2bf7ce9..5c088a55396c 100644
--- a/arch/um/os-Linux/skas/process.c
+++ b/arch/um/os-Linux/skas/process.c
@@ -34,6 +34,7 @@
 #include "process.h"
 #include "longjmp.h"
 #include "kern_constants.h"
+#include "as-layout.h"
 
 int is_skas_winch(int pid, int fd, void *data)
 {
@@ -60,37 +61,42 @@ static int ptrace_dump_regs(int pid)
         return 0;
 }
 
-void wait_stub_done(int pid, int sig, char * fname)
+/*
+ * Signals that are OK to receive in the stub - we'll just continue it.
+ * SIGWINCH will happen when UML is inside a detached screen.
+ */
+#define STUB_SIG_MASK ((1 << SIGVTALRM) | (1 << SIGWINCH))
+
+/* Signals that the stub will finish with - anything else is an error */
+#define STUB_DONE_MASK ((1 << SIGUSR1) | (1 << SIGTRAP))
+
+void wait_stub_done(int pid)
 {
         int n, status, err;
 
-        do {
-                if ( sig != -1 ) {
-                        err = ptrace(PTRACE_CONT, pid, 0, sig);
-                        if(err)
-                                panic("%s : continue failed, errno = %d\n",
-                                      fname, errno);
-                }
-                sig = 0;
-
+        while(1){
                 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
-        } while((n >= 0) && WIFSTOPPED(status) &&
-                ((WSTOPSIG(status) == SIGVTALRM) ||
-                 /* running UML inside a detached screen can cause
-                  * SIGWINCHes
-                  */
-                 (WSTOPSIG(status) == SIGWINCH)));
-
-        if((n < 0) || !WIFSTOPPED(status) ||
-           (WSTOPSIG(status) != SIGUSR1 && WSTOPSIG(status) != SIGTRAP)){
-                err = ptrace_dump_regs(pid);
+                if((n < 0) || !WIFSTOPPED(status))
+                        goto bad_wait;
+
+                if(((1 << WSTOPSIG(status)) & STUB_SIG_MASK) == 0)
+                        break;
+
+                err = ptrace(PTRACE_CONT, pid, 0, 0);
                 if(err)
-                        printk("Failed to get registers from stub, "
-                               "errno = %d\n", -err);
-                panic("%s : failed to wait for SIGUSR1/SIGTRAP, "
-                      "pid = %d, n = %d, errno = %d, status = 0x%x\n",
-                      fname, pid, n, errno, status);
+                        panic("wait_stub_done : continue failed, errno = %d\n",
+                              errno);
         }
+
+        if(((1 << WSTOPSIG(status)) & STUB_DONE_MASK) != 0)
+                return;
+
+bad_wait:
+        err = ptrace_dump_regs(pid);
+        if(err)
+                printk("Failed to get registers from stub, errno = %d\n", -err);
+        panic("wait_stub_done : failed to wait for SIGUSR1/SIGTRAP, pid = %d, "
+              "n = %d, errno = %d, status = 0x%x\n", pid, n, errno, status);
 }
 
 extern unsigned long current_stub_stack(void);
@@ -112,7 +118,11 @@ void get_skas_faultinfo(int pid, struct faultinfo * fi)
                                sizeof(struct ptrace_faultinfo));
         }
         else {
-                wait_stub_done(pid, SIGSEGV, "get_skas_faultinfo");
+                err = ptrace(PTRACE_CONT, pid, 0, SIGSEGV);
+                if(err)
+                        panic("Failed to continue stub, pid = %d, errno = %d\n",
+                              pid, errno);
+                wait_stub_done(pid);
 
                 /* faultinfo is prepared by the stub-segv-handler at start of
                  * the stub stack page. We just have to copy it.
@@ -304,10 +314,13 @@ void userspace(union uml_pt_regs *regs)
                 UPT_SYSCALL_NR(regs) = -1; /* Assume: It's not a syscall */
 
                 if(WIFSTOPPED(status)){
-                        switch(WSTOPSIG(status)){
+                        int sig = WSTOPSIG(status);
+                        switch(sig){
                         case SIGSEGV:
-                                if(PTRACE_FULL_FAULTINFO || !ptrace_faultinfo)
-                                        user_signal(SIGSEGV, regs, pid);
+                                if(PTRACE_FULL_FAULTINFO || !ptrace_faultinfo){
+                                        get_skas_faultinfo(pid, &regs->skas.faultinfo);
+                                        (*sig_info[SIGSEGV])(SIGSEGV, regs);
+                                }
                                 else handle_segv(pid, regs);
                                 break;
                         case SIGTRAP + 0x80:
@@ -322,11 +335,13 @@ void userspace(union uml_pt_regs *regs)
                         case SIGBUS:
                         case SIGFPE:
                         case SIGWINCH:
-                                user_signal(WSTOPSIG(status), regs, pid);
+                                block_signals();
+                                (*sig_info[sig])(sig, regs);
+                                unblock_signals();
                                 break;
                         default:
                                 printk("userspace - child stopped with signal "
-                                       "%d\n", WSTOPSIG(status));
+                                       "%d\n", sig);
                         }
                         pid = userspace_pid[0];
                         interrupt_end();
@@ -338,11 +353,29 @@ void userspace(union uml_pt_regs *regs)
         }
 }
 
+static unsigned long thread_regs[MAX_REG_NR];
+static unsigned long thread_fp_regs[HOST_FP_SIZE];
+
+static int __init init_thread_regs(void)
+{
+        get_safe_registers(thread_regs, thread_fp_regs);
+        /* Set parent's instruction pointer to start of clone-stub */
+        thread_regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
+                                (unsigned long) stub_clone_handler -
+                                (unsigned long) &__syscall_stub_start;
+        thread_regs[REGS_SP_INDEX] = UML_CONFIG_STUB_DATA + PAGE_SIZE -
+                sizeof(void *);
+#ifdef __SIGNAL_FRAMESIZE
+        thread_regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE;
+#endif
+        return 0;
+}
+
+__initcall(init_thread_regs);
+
 int copy_context_skas0(unsigned long new_stack, int pid)
 {
         int err;
-        unsigned long regs[MAX_REG_NR];
-        unsigned long fp_regs[HOST_FP_SIZE];
         unsigned long current_stack = current_stub_stack();
         struct stub_data *data = (struct stub_data *) current_stack;
         struct stub_data *child_data = (struct stub_data *) new_stack;
@@ -357,23 +390,12 @@ int copy_context_skas0(unsigned long new_stack, int pid)
                                       .timer    = ((struct itimerval)
                                                     { { 0, 1000000 / hz() },
                                                       { 0, 1000000 / hz() }})});
-        get_safe_registers(regs, fp_regs);
-
-        /* Set parent's instruction pointer to start of clone-stub */
-        regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
-                                (unsigned long) stub_clone_handler -
-                                (unsigned long) &__syscall_stub_start;
-        regs[REGS_SP_INDEX] = UML_CONFIG_STUB_DATA + PAGE_SIZE -
-                sizeof(void *);
-#ifdef __SIGNAL_FRAMESIZE
-        regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE;
-#endif
-        err = ptrace_setregs(pid, regs);
+        err = ptrace_setregs(pid, thread_regs);
         if(err < 0)
                 panic("copy_context_skas0 : PTRACE_SETREGS failed, "
                       "pid = %d, errno = %d\n", pid, -err);
 
-        err = ptrace_setfpregs(pid, fp_regs);
+        err = ptrace_setfpregs(pid, thread_fp_regs);
         if(err < 0)
                 panic("copy_context_skas0 : PTRACE_SETFPREGS failed, "
                       "pid = %d, errno = %d\n", pid, -err);
@@ -384,7 +406,11 @@ int copy_context_skas0(unsigned long new_stack, int pid)
         /* Wait, until parent has finished its work: read child's pid from
          * parent's stack, and check, if bad result.
          */
-        wait_stub_done(pid, 0, "copy_context_skas0");
+        err = ptrace(PTRACE_CONT, pid, 0, 0);
+        if(err)
+                panic("Failed to continue new process, pid = %d, "
+                      "errno = %d\n", pid, errno);
+        wait_stub_done(pid);
 
         pid = data->err;
         if(pid < 0)
@@ -394,7 +420,7 @@ int copy_context_skas0(unsigned long new_stack, int pid)
         /* Wait, until child has finished too: read child's result from
          * child's stack and check it.
          */
-        wait_stub_done(pid, -1, "copy_context_skas0");
+        wait_stub_done(pid);
         if (child_data->err != UML_CONFIG_STUB_DATA)
                 panic("copy_context_skas0 - stub-child reports error %ld\n",
                       child_data->err);
diff --git a/arch/um/os-Linux/skas/trap.c b/arch/um/os-Linux/skas/trap.c
index 5110eff51b90..3b600c2e63b8 100644
--- a/arch/um/os-Linux/skas/trap.c
+++ b/arch/um/os-Linux/skas/trap.c
@@ -64,20 +64,3 @@ void sig_handler_common_skas(int sig, void *sc_ptr)
         errno = save_errno;
         r->skas.is_user = save_user;
 }
-
-extern int ptrace_faultinfo;
-
-void user_signal(int sig, union uml_pt_regs *regs, int pid)
-{
-        void (*handler)(int, union uml_pt_regs *);
-        int segv = ((sig == SIGFPE) || (sig == SIGSEGV) || (sig == SIGBUS) ||
-                    (sig == SIGILL) || (sig == SIGTRAP));
-
-        if (segv)
-                get_skas_faultinfo(pid, &regs->skas.faultinfo);
-
-        handler = sig_info[sig];
-        handler(sig, (union uml_pt_regs *) regs);
-
-        unblock_signals();
-}