Patched in Tegra support.

28 files changed, 226 insertions, 166 deletions

diff --git a/arch/um/os-Linux/Makefile b/arch/um/os-Linux/Makefile
index 08ff5094fcd..b33f4dfe7ae 100644
--- a/arch/um/os-Linux/Makefile
+++ b/arch/um/os-Linux/Makefile
@@ -4,14 +4,16 @@
 #
 
 obj-y = aio.o execvp.o file.o helper.o irq.o main.o mem.o process.o \
-        registers.o sigio.o signal.o start_up.o time.o tty.o \
-        umid.o user_syms.o util.o drivers/ skas/
+        registers.o sigio.o signal.o start_up.o time.o tty.o uaccess.o \
+        umid.o tls.o user_syms.o util.o drivers/ sys-$(SUBARCH)/ skas/
 
 obj-$(CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA) += elf_aux.o
 
 USER_OBJS := $(user-objs-y) aio.o elf_aux.o execvp.o file.o helper.o irq.o \
         main.o mem.o process.o registers.o sigio.o signal.o start_up.o time.o \
-        tty.o umid.o util.o
+        tty.o tls.o uaccess.o umid.o util.o
+
+CFLAGS_user_syms.o += -DSUBARCH_$(SUBARCH)
 
 HAVE_AIO_ABI := $(shell [ -r /usr/include/linux/aio_abi.h ] && \
         echo -DHAVE_AIO_ABI )
diff --git a/arch/um/os-Linux/aio.c b/arch/um/os-Linux/aio.c
index 3a6bc2af096..57e3d46c989 100644
--- a/arch/um/os-Linux/aio.c
+++ b/arch/um/os-Linux/aio.c
@@ -9,10 +9,12 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <asm/unistd.h>
-#include <aio.h>
-#include <init.h>
-#include <kern_util.h>
-#include <os.h>
+#include "aio.h"
+#include "init.h"
+#include "kern_constants.h"
+#include "kern_util.h"
+#include "os.h"
+#include "user.h"
 
 struct aio_thread_req {
         enum aio_type type;
diff --git a/arch/um/os-Linux/drivers/etap.h b/arch/um/os-Linux/drivers/etap.h
index 54183a679fd..ddffd41c3f3 100644
--- a/arch/um/os-Linux/drivers/etap.h
+++ b/arch/um/os-Linux/drivers/etap.h
@@ -6,7 +6,7 @@
 #ifndef __DRIVERS_ETAP_H
 #define __DRIVERS_ETAP_H
 
-#include <net_user.h>
+#include "net_user.h"
 
 struct ethertap_data {
         char *dev_name;
diff --git a/arch/um/os-Linux/drivers/ethertap_kern.c b/arch/um/os-Linux/drivers/ethertap_kern.c
index f424600a583..7f6f9a71aae 100644
--- a/arch/um/os-Linux/drivers/ethertap_kern.c
+++ b/arch/um/os-Linux/drivers/ethertap_kern.c
@@ -9,7 +9,7 @@
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include "etap.h"
-#include <net_kern.h>
+#include "net_kern.h"
 
 struct ethertap_init {
         char *dev_name;
diff --git a/arch/um/os-Linux/drivers/ethertap_user.c b/arch/um/os-Linux/drivers/ethertap_user.c
index b39b6696ac5..cc72cb2c1af 100644
--- a/arch/um/os-Linux/drivers/ethertap_user.c
+++ b/arch/um/os-Linux/drivers/ethertap_user.c
@@ -13,9 +13,11 @@
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include "etap.h"
-#include <os.h>
-#include <net_user.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "os.h"
+#include "net_user.h"
+#include "um_malloc.h"
+#include "user.h"
 
 #define MAX_PACKET ETH_MAX_PACKET
 
diff --git a/arch/um/os-Linux/drivers/tuntap.h b/arch/um/os-Linux/drivers/tuntap.h
index 7367354ac8d..f17c31586c8 100644
--- a/arch/um/os-Linux/drivers/tuntap.h
+++ b/arch/um/os-Linux/drivers/tuntap.h
@@ -6,7 +6,7 @@
 #ifndef __UM_TUNTAP_H
 #define __UM_TUNTAP_H
 
-#include <net_user.h>
+#include "net_user.h"
 
 struct tuntap_data {
         char *dev_name;
diff --git a/arch/um/os-Linux/drivers/tuntap_kern.c b/arch/um/os-Linux/drivers/tuntap_kern.c
index d9d56e5810f..4048800e469 100644
--- a/arch/um/os-Linux/drivers/tuntap_kern.c
+++ b/arch/um/os-Linux/drivers/tuntap_kern.c
@@ -7,7 +7,7 @@
 #include <linux/init.h>
 #include <linux/skbuff.h>
 #include <asm/errno.h>
-#include <net_kern.h>
+#include "net_kern.h"
 #include "tuntap.h"
 
 struct tuntap_init {
diff --git a/arch/um/os-Linux/drivers/tuntap_user.c b/arch/um/os-Linux/drivers/tuntap_user.c
index 14126d9176a..2448be03fd7 100644
--- a/arch/um/os-Linux/drivers/tuntap_user.c
+++ b/arch/um/os-Linux/drivers/tuntap_user.c
@@ -13,9 +13,11 @@
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <sys/uio.h>
-#include <kern_util.h>
-#include <os.h>
+#include "kern_constants.h"
+#include "kern_util.h"
+#include "os.h"
 #include "tuntap.h"
+#include "user.h"
 
 static int tuntap_user_init(void *data, void *dev)
 {
diff --git a/arch/um/os-Linux/elf_aux.c b/arch/um/os-Linux/elf_aux.c
index 1a365ddc4d0..95332379938 100644
--- a/arch/um/os-Linux/elf_aux.c
+++ b/arch/um/os-Linux/elf_aux.c
@@ -9,9 +9,10 @@
  */
 #include <elf.h>
 #include <stddef.h>
-#include <init.h>
-#include <elf_user.h>
-#include <mem_user.h>
+#include "init.h"
+#include "elf_user.h"
+#include "mem_user.h"
+#include <kern_constants.h>
 
 typedef Elf32_auxv_t elf_auxv_t;
 
diff --git a/arch/um/os-Linux/execvp.c b/arch/um/os-Linux/execvp.c
index 8fb25ca07c4..66e583a4031 100644
--- a/arch/um/os-Linux/execvp.c
+++ b/arch/um/os-Linux/execvp.c
@@ -27,12 +27,12 @@
 #include <limits.h>
 
 #ifndef TEST
-#include <um_malloc.h>
+#include "um_malloc.h"
 #else
 #include <stdio.h>
 #define um_kmalloc malloc
 #endif
-#include <os.h>
+#include "os.h"
 
 /* Execute FILE, searching in the `PATH' environment variable if it contains
    no slashes, with arguments ARGV and environment from `environ'.  */
diff --git a/arch/um/os-Linux/file.c b/arch/um/os-Linux/file.c
index c17bd6f7d67..140e587bc0a 100644
--- a/arch/um/os-Linux/file.c
+++ b/arch/um/os-Linux/file.c
@@ -13,7 +13,9 @@
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.h>
-#include <os.h>
+#include "kern_constants.h"
+#include "os.h"
+#include "user.h"
 
 static void copy_stat(struct uml_stat *dst, const struct stat64 *src)
 {
diff --git a/arch/um/os-Linux/helper.c b/arch/um/os-Linux/helper.c
index e3ee4a51ef6..feff22d6467 100644
--- a/arch/um/os-Linux/helper.c
+++ b/arch/um/os-Linux/helper.c
@@ -10,9 +10,11 @@
 #include <linux/limits.h>
 #include <sys/socket.h>
 #include <sys/wait.h>
-#include <kern_util.h>
-#include <os.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "kern_util.h"
+#include "os.h"
+#include "um_malloc.h"
+#include "user.h"
 
 struct helper_data {
         void (*pre_exec)(void*);
diff --git a/arch/um/os-Linux/internal.h b/arch/um/os-Linux/internal.h
deleted file mode 100644
index 0dc2c9f135f..00000000000
--- a/arch/um/os-Linux/internal.h
+++ /dev/null
@@ -1 +0,0 @@
-void alarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc);
diff --git a/arch/um/os-Linux/irq.c b/arch/um/os-Linux/irq.c
index b9afb74b79a..0348b975e81 100644
--- a/arch/um/os-Linux/irq.c
+++ b/arch/um/os-Linux/irq.c
@@ -8,9 +8,12 @@
 #include <poll.h>
 #include <signal.h>
 #include <string.h>
-#include <irq_user.h>
-#include <os.h>
-#include <um_malloc.h>
+#include "irq_user.h"
+#include "kern_constants.h"
+#include "os.h"
+#include "process.h"
+#include "um_malloc.h"
+#include "user.h"
 
 /*
  * Locked by irq_lock in arch/um/kernel/irq.c.  Changed by os_create_pollfd
diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c
index 749c96da7b9..8471b817d94 100644
--- a/arch/um/os-Linux/main.c
+++ b/arch/um/os-Linux/main.c
@@ -10,11 +10,12 @@
 #include <signal.h>
 #include <string.h>
 #include <sys/resource.h>
-#include <as-layout.h>
-#include <init.h>
-#include <kern_util.h>
-#include <os.h>
-#include <um_malloc.h>
+#include "as-layout.h"
+#include "init.h"
+#include "kern_constants.h"
+#include "kern_util.h"
+#include "os.h"
+#include "um_malloc.h"
 
 #define PGD_BOUND (4 * 1024 * 1024)
 #define STACKSIZE (8 * 1024 * 1024)
diff --git a/arch/um/os-Linux/mem.c b/arch/um/os-Linux/mem.c
index ba4398056fe..62878cf1d33 100644
--- a/arch/um/os-Linux/mem.c
+++ b/arch/um/os-Linux/mem.c
@@ -13,8 +13,10 @@
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <sys/param.h>
-#include <init.h>
-#include <os.h>
+#include "init.h"
+#include "kern_constants.h"
+#include "os.h"
+#include "user.h"
 
 /* Modified by which_tmpdir, which is called during early boot */
 static char *default_tmpdir = "/tmp";
diff --git a/arch/um/os-Linux/process.c b/arch/um/os-Linux/process.c
index b8f34c9e53a..0c45dc8efb0 100644
--- a/arch/um/os-Linux/process.c
+++ b/arch/um/os-Linux/process.c
@@ -12,10 +12,13 @@
 #include <sys/ptrace.h>
 #include <sys/wait.h>
 #include <asm/unistd.h>
-#include <init.h>
-#include <longjmp.h>
-#include <os.h>
-#include <skas_ptrace.h>
+#include "init.h"
+#include "kern_constants.h"
+#include "longjmp.h"
+#include "os.h"
+#include "process.h"
+#include "skas_ptrace.h"
+#include "user.h"
 
 #define ARBITRARY_ADDR -1
 #define FAILURE_PID    -1
@@ -234,13 +237,34 @@ out:
 
 void init_new_thread_signals(void)
 {
-        set_handler(SIGSEGV);
-        set_handler(SIGTRAP);
-        set_handler(SIGFPE);
-        set_handler(SIGILL);
-        set_handler(SIGBUS);
+        set_handler(SIGSEGV, (__sighandler_t) sig_handler, SA_ONSTACK,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
+        set_handler(SIGTRAP, (__sighandler_t) sig_handler, SA_ONSTACK,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
+        set_handler(SIGFPE, (__sighandler_t) sig_handler, SA_ONSTACK,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
+        set_handler(SIGILL, (__sighandler_t) sig_handler, SA_ONSTACK,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
+        set_handler(SIGBUS, (__sighandler_t) sig_handler, SA_ONSTACK,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
         signal(SIGHUP, SIG_IGN);
-        set_handler(SIGIO);
+
+        set_handler(SIGIO, (__sighandler_t) sig_handler,
+                    SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGWINCH, SIGALRM,
+                    SIGVTALRM, -1);
         signal(SIGWINCH, SIG_IGN);
         signal(SIGTERM, SIG_DFL);
 }
+
+int run_kernel_thread(int (*fn)(void *), void *arg, jmp_buf **jmp_ptr)
+{
+        jmp_buf buf;
+        int n;
+
+        *jmp_ptr = &buf;
+        n = UML_SETJMP(&buf);
+        if (n != 0)
+                return n;
+        (*fn)(arg);
+        return 0;
+}
diff --git a/arch/um/os-Linux/registers.c b/arch/um/os-Linux/registers.c
index 2ff8d4fe83c..b866b9e3bef 100644
--- a/arch/um/os-Linux/registers.c
+++ b/arch/um/os-Linux/registers.c
@@ -7,9 +7,9 @@
 #include <errno.h>
 #include <string.h>
 #include <sys/ptrace.h>
-#include <sysdep/ptrace.h>
-#include <sysdep/ptrace_user.h>
-#include <registers.h>
+#include "sysdep/ptrace.h"
+#include "sysdep/ptrace_user.h"
+#include "registers.h"
 
 int save_registers(int pid, struct uml_pt_regs *regs)
 {
diff --git a/arch/um/os-Linux/sigio.c b/arch/um/os-Linux/sigio.c
index 8b61cc0e82c..63d299df152 100644
--- a/arch/um/os-Linux/sigio.c
+++ b/arch/um/os-Linux/sigio.c
@@ -11,11 +11,14 @@
 #include <sched.h>
 #include <signal.h>
 #include <string.h>
-#include <kern_util.h>
-#include <init.h>
-#include <os.h>
-#include <sigio.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "kern_util.h"
+#include "init.h"
+#include "os.h"
+#include "process.h"
+#include "sigio.h"
+#include "um_malloc.h"
+#include "user.h"
 
 /*
  * Protected by sigio_lock(), also used by sigio_cleanup, which is an
diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c
index b1469fe9329..6ae180703a6 100644
--- a/arch/um/os-Linux/signal.c
+++ b/arch/um/os-Linux/signal.c
@@ -9,13 +9,18 @@
 #include <errno.h>
 #include <signal.h>
 #include <strings.h>
-#include <as-layout.h>
-#include <kern_util.h>
-#include <os.h>
-#include <sysdep/mcontext.h>
-#include "internal.h"
-
-void (*sig_info[NSIG])(int, siginfo_t *, struct uml_pt_regs *) = {
+#include "as-layout.h"
+#include "kern_util.h"
+#include "os.h"
+#include "process.h"
+#include "sysdep/barrier.h"
+#include "sysdep/sigcontext.h"
+#include "user.h"
+
+/* Copied from linux/compiler-gcc.h since we can't include it directly */
+#define barrier() __asm__ __volatile__("": : :"memory")
+
+void (*sig_info[NSIG])(int, struct uml_pt_regs *) = {
         [SIGTRAP]       = relay_signal,
         [SIGFPE]        = relay_signal,
         [SIGILL]        = relay_signal,
@@ -25,7 +30,7 @@ void (*sig_info[NSIG])(int, siginfo_t *, struct uml_pt_regs *) = {
         [SIGIO]         = sigio_handler,
         [SIGVTALRM]     = timer_handler };
 
-static void sig_handler_common(int sig, siginfo_t *si, mcontext_t *mc)
+static void sig_handler_common(int sig, struct sigcontext *sc)
 {
         struct uml_pt_regs r;
         int save_errno = errno;
@@ -33,15 +38,15 @@ static void sig_handler_common(int sig, siginfo_t *si, mcontext_t *mc)
         r.is_user = 0;
         if (sig == SIGSEGV) {
                 /* For segfaults, we want the data from the sigcontext. */
-                get_regs_from_mc(&r, mc);
-                GET_FAULTINFO_FROM_MC(r.faultinfo, mc);
+                copy_sc(&r, sc);
+                GET_FAULTINFO_FROM_SC(r.faultinfo, sc);
         }
 
         /* enable signals if sig isn't IRQ signal */
         if ((sig != SIGIO) && (sig != SIGWINCH) && (sig != SIGVTALRM))
                 unblock_signals();
 
-        (*sig_info[sig])(sig, si, &r);
+        (*sig_info[sig])(sig, &r);
 
         errno = save_errno;
 }
@@ -61,7 +66,7 @@ static void sig_handler_common(int sig, siginfo_t *si, mcontext_t *mc)
 static int signals_enabled;
 static unsigned int signals_pending;
 
-void sig_handler(int sig, siginfo_t *si, mcontext_t *mc)
+void sig_handler(int sig, struct sigcontext *sc)
 {
         int enabled;
 
@@ -73,23 +78,23 @@ void sig_handler(int sig, siginfo_t *si, mcontext_t *mc)
 
         block_signals();
 
-        sig_handler_common(sig, si, mc);
+        sig_handler_common(sig, sc);
 
         set_signals(enabled);
 }
 
-static void real_alarm_handler(mcontext_t *mc)
+static void real_alarm_handler(struct sigcontext *sc)
 {
         struct uml_pt_regs regs;
 
-        if (mc != NULL)
-                get_regs_from_mc(&regs, mc);
+        if (sc != NULL)
+                copy_sc(&regs, sc);
         regs.is_user = 0;
         unblock_signals();
-        timer_handler(SIGVTALRM, NULL, &regs);
+        timer_handler(SIGVTALRM, &regs);
 }
 
-void alarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc)
+void alarm_handler(int sig, struct sigcontext *sc)
 {
         int enabled;
 
@@ -101,13 +106,14 @@ void alarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc)
 
         block_signals();
 
-        real_alarm_handler(mc);
+        real_alarm_handler(sc);
         set_signals(enabled);
 }
 
 void timer_init(void)
 {
-        set_handler(SIGVTALRM);
+        set_handler(SIGVTALRM, (__sighandler_t) alarm_handler,
+                    SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGWINCH, -1);
 }
 
 void set_sigstack(void *sig_stack, int size)
@@ -120,23 +126,10 @@ void set_sigstack(void *sig_stack, int size)
                 panic("enabling signal stack failed, errno = %d\n", errno);
 }
 
-static void (*handlers[_NSIG])(int sig, siginfo_t *si, mcontext_t *mc) = {
-        [SIGSEGV] = sig_handler,
-        [SIGBUS] = sig_handler,
-        [SIGILL] = sig_handler,
-        [SIGFPE] = sig_handler,
-        [SIGTRAP] = sig_handler,
-
-        [SIGIO] = sig_handler,
-        [SIGWINCH] = sig_handler,
-        [SIGVTALRM] = alarm_handler
-};
-
+static void (*handlers[_NSIG])(int sig, struct sigcontext *sc);
 
-static void hard_handler(int sig, siginfo_t *si, void *p)
+void handle_signal(int sig, struct sigcontext *sc)
 {
-        struct ucontext *uc = p;
-        mcontext_t *mc = &uc->uc_mcontext;
         unsigned long pending = 1UL << sig;
 
         do {
@@ -162,7 +155,7 @@ static void hard_handler(int sig, siginfo_t *si, void *p)
                 while ((sig = ffs(pending)) != 0){
                         sig--;
                         pending &= ~(1 << sig);
-                        (*handlers[sig])(sig, si, mc);
+                        (*handlers[sig])(sig, sc);
                 }
 
                 /*
@@ -176,26 +169,28 @@ static void hard_handler(int sig, siginfo_t *si, void *p)
         } while (pending);
 }
 
-void set_handler(int sig)
+extern void hard_handler(int sig);
+
+void set_handler(int sig, void (*handler)(int), int flags, ...)
 {
         struct sigaction action;
-        int flags = SA_SIGINFO | SA_ONSTACK;
+        va_list ap;
         sigset_t sig_mask;
+        int mask;
 
-        action.sa_sigaction = hard_handler;
+        handlers[sig] = (void (*)(int, struct sigcontext *)) handler;
+        action.sa_handler = hard_handler;
 
-        /* block irq ones */
         sigemptyset(&action.sa_mask);
-        sigaddset(&action.sa_mask, SIGVTALRM);
-        sigaddset(&action.sa_mask, SIGIO);
-        sigaddset(&action.sa_mask, SIGWINCH);
+
+        va_start(ap, flags);
+        while ((mask = va_arg(ap, int)) != -1)
+                sigaddset(&action.sa_mask, mask);
+        va_end(ap);
 
         if (sig == SIGSEGV)
                 flags |= SA_NODEFER;
 
-        if (sigismember(&action.sa_mask, sig))
-                flags |= SA_RESTART; /* if it's an irq signal */
-
         action.sa_flags = flags;
         action.sa_restorer = NULL;
         if (sigaction(sig, &action, NULL) < 0)
@@ -274,12 +269,9 @@ void unblock_signals(void)
                  * Deal with SIGIO first because the alarm handler might
                  * schedule, leaving the pending SIGIO stranded until we come
                  * back here.
-                 *
-                 * SIGIO's handler doesn't use siginfo or mcontext,
-                 * so they can be NULL.
                  */
                 if (save_pending & SIGIO_MASK)
-                        sig_handler_common(SIGIO, NULL, NULL);
+                        sig_handler_common(SIGIO, NULL);
 
                 if (save_pending & SIGVTALRM_MASK)
                         real_alarm_handler(NULL);
diff --git a/arch/um/os-Linux/skas/mem.c b/arch/um/os-Linux/skas/mem.c
index 689b18db798..e771398be5f 100644
--- a/arch/um/os-Linux/skas/mem.c
+++ b/arch/um/os-Linux/skas/mem.c
@@ -8,16 +8,18 @@
 #include <errno.h>
 #include <string.h>
 #include <sys/mman.h>
-#include <init.h>
-#include <as-layout.h>
-#include <mm_id.h>
-#include <os.h>
-#include <proc_mm.h>
-#include <ptrace_user.h>
-#include <registers.h>
-#include <skas.h>
-#include <sysdep/ptrace.h>
-#include <sysdep/stub.h>
+#include "init.h"
+#include "kern_constants.h"
+#include "as-layout.h"
+#include "mm_id.h"
+#include "os.h"
+#include "proc_mm.h"
+#include "ptrace_user.h"
+#include "registers.h"
+#include "skas.h"
+#include "user.h"
+#include "sysdep/ptrace.h"
+#include "sysdep/stub.h"
 
 extern unsigned long batch_syscall_stub, __syscall_stub_start;
 
@@ -48,6 +50,10 @@ __initcall(init_syscall_regs);
 
 extern int proc_mm;
 
+int single_count = 0;
+int multi_count = 0;
+int multi_op_count = 0;
+
 static inline long do_syscall_stub(struct mm_id * mm_idp, void **addr)
 {
         int n, i;
@@ -60,6 +66,8 @@ static inline long do_syscall_stub(struct mm_id * mm_idp, void **addr)
                 /* FIXME: Need to look up userspace_pid by cpu */
                 pid = userspace_pid[0];
 
+        multi_count++;
+
         n = ptrace_setregs(pid, syscall_regs);
         if (n < 0) {
                 printk(UM_KERN_ERR "Registers - \n");
@@ -120,6 +128,9 @@ long run_syscall_stub(struct mm_id * mm_idp, int syscall,
 {
         unsigned long *stack = check_init_stack(mm_idp, *addr);
 
+        if (done && *addr == NULL)
+                single_count++;
+
         *stack += sizeof(long);
         stack += *stack / sizeof(long);
 
@@ -132,6 +143,7 @@ long run_syscall_stub(struct mm_id * mm_idp, int syscall,
         *stack++ = args[5];
         *stack++ = expected;
         *stack = 0;
+        multi_op_count++;
 
         if (!done && ((((unsigned long) stack) & ~UM_KERN_PAGE_MASK) <
                      UM_KERN_PAGE_SIZE - 10 * sizeof(long))) {
diff --git a/arch/um/os-Linux/skas/process.c b/arch/um/os-Linux/skas/process.c
index 4625949bf1e..dee0e8cf8ad 100644
--- a/arch/um/os-Linux/skas/process.c
+++ b/arch/um/os-Linux/skas/process.c
@@ -9,23 +9,31 @@
 #include <errno.h>
 #include <string.h>
 #include <sys/mman.h>
+#include <sys/ptrace.h>
 #include <sys/wait.h>
 #include <asm/unistd.h>
-#include <as-layout.h>
-#include <init.h>
-#include <kern_util.h>
-#include <mem.h>
-#include <os.h>
-#include <proc_mm.h>
-#include <ptrace_user.h>
-#include <registers.h>
-#include <skas.h>
-#include <skas_ptrace.h>
-#include <sysdep/stub.h>
+#include "as-layout.h"
+#include "chan_user.h"
+#include "kern_constants.h"
+#include "kern_util.h"
+#include "mem.h"
+#include "os.h"
+#include "process.h"
+#include "proc_mm.h"
+#include "ptrace_user.h"
+#include "registers.h"
+#include "skas.h"
+#include "skas_ptrace.h"
+#include "user.h"
+#include "sysdep/stub.h"
 
 int is_skas_winch(int pid, int fd, void *data)
 {
-        return pid == getpgrp();
+        if (pid != getpgrp())
+                return 0;
+
+        register_winch_irq(-1, fd, -1, data, 0);
+        return 1;
 }
 
 static int ptrace_dump_regs(int pid)
@@ -161,7 +169,7 @@ static void handle_trap(int pid, struct uml_pt_regs *regs,
 
         if (!local_using_sysemu)
         {
-                err = ptrace(PTRACE_POKEUSER, pid, PT_SYSCALL_NR_OFFSET,
+                err = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET,
                              __NR_getpid);
                 if (err < 0) {
                         printk(UM_KERN_ERR "handle_trap - nullifying syscall "
@@ -249,8 +257,8 @@ static int userspace_tramp(void *stack)
 
                 set_sigstack((void *) STUB_DATA, UM_KERN_PAGE_SIZE);
                 sigemptyset(&sa.sa_mask);
-                sa.sa_flags = SA_ONSTACK | SA_NODEFER | SA_SIGINFO;
-                sa.sa_sigaction = (void *) v;
+                sa.sa_flags = SA_ONSTACK | SA_NODEFER;
+                sa.sa_handler = (void *) v;
                 sa.sa_restorer = NULL;
                 if (sigaction(SIGSEGV, &sa, NULL) < 0) {
                         printk(UM_KERN_ERR "userspace_tramp - setting SIGSEGV "
@@ -346,10 +354,6 @@ void userspace(struct uml_pt_regs *regs)
         int err, status, op, pid = userspace_pid[0];
         /* To prevent races if using_sysemu changes under us.*/
         int local_using_sysemu;
-        siginfo_t si;
-
-        /* Handle any immediate reschedules or signals */
-        interrupt_end();
 
         if (getitimer(ITIMER_VIRTUAL, &timer))
                 printk(UM_KERN_ERR "Failed to get itimer, errno = %d\n", errno);
@@ -408,17 +412,13 @@ void userspace(struct uml_pt_regs *regs)
 
                 if (WIFSTOPPED(status)) {
                         int sig = WSTOPSIG(status);
-
-                        ptrace(PTRACE_GETSIGINFO, pid, 0, &si);
-
                         switch (sig) {
                         case SIGSEGV:
                                 if (PTRACE_FULL_FAULTINFO ||
                                     !ptrace_faultinfo) {
                                         get_skas_faultinfo(pid,
                                                            &regs->faultinfo);
-                                        (*sig_info[SIGSEGV])(SIGSEGV, &si,
-                                                             regs);
+                                        (*sig_info[SIGSEGV])(SIGSEGV, regs);
                                 }
                                 else handle_segv(pid, regs);
                                 break;
@@ -426,14 +426,14 @@ void userspace(struct uml_pt_regs *regs)
                                 handle_trap(pid, regs, local_using_sysemu);
                                 break;
                         case SIGTRAP:
-                                relay_signal(SIGTRAP, &si, regs);
+                                relay_signal(SIGTRAP, regs);
                                 break;
                         case SIGVTALRM:
                                 now = os_nsecs();
                                 if (now < nsecs)
                                         break;
                                 block_signals();
-                                (*sig_info[sig])(sig, &si, regs);
+                                (*sig_info[sig])(sig, regs);
                                 unblock_signals();
                                 nsecs = timer.it_value.tv_sec *
                                         UM_NSEC_PER_SEC +
@@ -447,7 +447,7 @@ void userspace(struct uml_pt_regs *regs)
                         case SIGFPE:
                         case SIGWINCH:
                                 block_signals();
-                                (*sig_info[sig])(sig, &si, regs);
+                                (*sig_info[sig])(sig, regs);
                                 unblock_signals();
                                 break;
                         default:
@@ -661,7 +661,8 @@ int start_idle_thread(void *stack, jmp_buf *switch_buf)
 {
         int n;
 
-        set_handler(SIGWINCH);
+        set_handler(SIGWINCH, (__sighandler_t) sig_handler,
+                    SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGVTALRM, -1);
 
         /*
          * Can't use UML_SETJMP or UML_LONGJMP here because they save
diff --git a/arch/um/os-Linux/start_up.c b/arch/um/os-Linux/start_up.c
index da4b9e9999f..02ee9adff54 100644
--- a/arch/um/os-Linux/start_up.c
+++ b/arch/um/os-Linux/start_up.c
@@ -13,16 +13,18 @@
 #include <signal.h>
 #include <string.h>
 #include <sys/mman.h>
+#include <sys/ptrace.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <asm/unistd.h>
-#include <init.h>
-#include <os.h>
-#include <mem_user.h>
-#include <ptrace_user.h>
-#include <registers.h>
-#include <skas.h>
-#include <skas_ptrace.h>
+#include "init.h"
+#include "kern_constants.h"
+#include "os.h"
+#include "mem_user.h"
+#include "ptrace_user.h"
+#include "registers.h"
+#include "skas.h"
+#include "skas_ptrace.h"
 
 static void ptrace_child(void)
 {
@@ -223,7 +225,7 @@ static void __init check_sysemu(void)
                 goto fail;
         }
 
-        n = ptrace(PTRACE_POKEUSER, pid, PT_SYSCALL_RET_OFFSET, os_getpid());
+        n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET, os_getpid());
         if (n < 0) {
                 non_fatal("check_sysemu : failed to modify system call "
                           "return");
@@ -259,7 +261,7 @@ static void __init check_sysemu(void)
                                           "doesn't singlestep");
                                 goto fail;
                         }
-                        n = ptrace(PTRACE_POKEUSER, pid, PT_SYSCALL_RET_OFFSET,
+                        n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET,
                                    os_getpid());
                         if (n < 0)
                                 fatal_perror("check_sysemu : failed to modify "
@@ -315,10 +317,10 @@ static void __init check_ptrace(void)
                         fatal("check_ptrace : expected (SIGTRAP|0x80), "
                                "got status = %d", status);
 
-                syscall = ptrace(PTRACE_PEEKUSER, pid, PT_SYSCALL_NR_OFFSET,
+                syscall = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_NR_OFFSET,
                                  0);
                 if (syscall == __NR_getpid) {
-                        n = ptrace(PTRACE_POKEUSER, pid, PT_SYSCALL_NR_OFFSET,
+                        n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET,
                                    __NR_getppid);
                         if (n < 0)
                                 fatal_perror("check_ptrace : failed to modify "
diff --git a/arch/um/os-Linux/time.c b/arch/um/os-Linux/time.c
index fac388cb464..6e3359d6a83 100644
--- a/arch/um/os-Linux/time.c
+++ b/arch/um/os-Linux/time.c
@@ -8,9 +8,11 @@
 #include <signal.h>
 #include <time.h>
 #include <sys/time.h>
-#include <kern_util.h>
-#include <os.h>
-#include "internal.h"
+#include "kern_constants.h"
+#include "kern_util.h"
+#include "os.h"
+#include "process.h"
+#include "user.h"
 
 int set_interval(void)
 {
@@ -87,7 +89,7 @@ static int after_sleep_interval(struct timespec *ts)
 
 static void deliver_alarm(void)
 {
-        alarm_handler(SIGVTALRM, NULL, NULL);
+        alarm_handler(SIGVTALRM, NULL);
 }
 
 static unsigned long long sleep_time(unsigned long long nsecs)
@@ -114,7 +116,7 @@ static void deliver_alarm(void)
         skew += this_tick - last_tick;
 
         while (skew >= one_tick) {
-                alarm_handler(SIGVTALRM, NULL, NULL);
+                alarm_handler(SIGVTALRM, NULL);
                 skew -= one_tick;
         }
 
diff --git a/arch/um/os-Linux/tty.c b/arch/um/os-Linux/tty.c
index 721d8afa329..b09ff66a77e 100644
--- a/arch/um/os-Linux/tty.c
+++ b/arch/um/os-Linux/tty.c
@@ -7,8 +7,10 @@
 #include <unistd.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <kern_util.h>
-#include <os.h>
+#include "kern_constants.h"
+#include "kern_util.h"
+#include "os.h"
+#include "user.h"
 
 struct grantpt_info {
         int fd;
diff --git a/arch/um/os-Linux/umid.c b/arch/um/os-Linux/umid.c
index c1dc89261f6..a27defb8188 100644
--- a/arch/um/os-Linux/umid.c
+++ b/arch/um/os-Linux/umid.c
@@ -12,8 +12,10 @@
 #include <string.h>
 #include <unistd.h>
 #include <sys/stat.h>
-#include <init.h>
-#include <os.h>
+#include "init.h"
+#include "kern_constants.h"
+#include "os.h"
+#include "user.h"
 
 #define UML_DIR "~/.uml/"
 
diff --git a/arch/um/os-Linux/user_syms.c b/arch/um/os-Linux/user_syms.c
index db4a034aeee..45ffe46871e 100644
--- a/arch/um/os-Linux/user_syms.c
+++ b/arch/um/os-Linux/user_syms.c
@@ -1,5 +1,5 @@
-#include <linux/types.h>
-#include <linux/module.h>
+#include "linux/types.h"
+#include "linux/module.h"
 
 /* Some of this are builtin function (some are not but could in the future),
  * so I *must* declare good prototypes for them and then EXPORT them.
@@ -45,7 +45,7 @@ EXPORT_SYMBOL(readdir64);
 extern void truncate64(void) __attribute__((weak));
 EXPORT_SYMBOL(truncate64);
 
-#ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
+#ifdef SUBARCH_i386
 EXPORT_SYMBOL(vsyscall_ehdr);
 EXPORT_SYMBOL(vsyscall_end);
 #endif
diff --git a/arch/um/os-Linux/util.c b/arch/um/os-Linux/util.c
index 492ef5e6e16..5803b188767 100644
--- a/arch/um/os-Linux/util.c
+++ b/arch/um/os-Linux/util.c
@@ -13,7 +13,9 @@
 #include <wait.h>
 #include <sys/mman.h>
 #include <sys/utsname.h>
-#include <os.h>
+#include "kern_constants.h"
+#include "os.h"
+#include "user.h"
 
 void stack_protections(unsigned long address)
 {