9 files changed, 290 insertions, 17 deletions

diff --git a/arch/um/os-Linux/Makefile b/arch/um/os-Linux/Makefile
index 11e30b13e318..40c7d6b1df68 100644
--- a/arch/um/os-Linux/Makefile
+++ b/arch/um/os-Linux/Makefile
@@ -4,11 +4,13 @@
 #
 
 obj-y = aio.o elf_aux.o file.o helper.o main.o mem.o process.o signal.o \
-        start_up.o time.o tt.o tty.o uaccess.o umid.o user_syms.o drivers/ \
-        sys-$(SUBARCH)/
+        start_up.o time.o trap.o tt.o tty.o uaccess.o umid.o user_syms.o \
+        drivers/ sys-$(SUBARCH)/
+
+obj-$(CONFIG_MODE_SKAS) += skas/
 
 USER_OBJS := aio.o elf_aux.o file.o helper.o main.o mem.o process.o signal.o \
-        start_up.o time.o tt.o tty.o uaccess.o umid.o
+        start_up.o time.o trap.o tt.o tty.o uaccess.o umid.o
 
 elf_aux.o: $(ARCH_DIR)/kernel-offsets.h
 CFLAGS_elf_aux.o += -I$(objtree)/arch/um
diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c
index 23da27d22569..172c8474453c 100644
--- a/arch/um/os-Linux/main.c
+++ b/arch/um/os-Linux/main.c
@@ -16,7 +16,6 @@
 #include "user_util.h"
 #include "kern_util.h"
 #include "mem_user.h"
-#include "signal_user.h"
 #include "time_user.h"
 #include "irq_user.h"
 #include "user.h"
diff --git a/arch/um/os-Linux/process.c b/arch/um/os-Linux/process.c
index d9c52387c4a1..39815c6b5e45 100644
--- a/arch/um/os-Linux/process.c
+++ b/arch/um/os-Linux/process.c
@@ -15,7 +15,6 @@
 #include "os.h"
 #include "user.h"
 #include "user_util.h"
-#include "signal_user.h"
 #include "process.h"
 #include "irq_user.h"
 #include "kern_util.h"
diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c
index c7bfd5ee3925..c1f46a0fef13 100644
--- a/arch/um/os-Linux/signal.c
+++ b/arch/um/os-Linux/signal.c
@@ -4,9 +4,22 @@
  */
 
 #include <signal.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <string.h>
+#include <sys/mman.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "signal_kern.h"
+#include "sysdep/sigcontext.h"
+#include "sysdep/signal.h"
+#include "sigcontext.h"
 #include "time_user.h"
 #include "mode.h"
-#include "sysdep/signal.h"
 
 void sig_handler(ARCH_SIGHDLR_PARAM)
 {
@@ -36,13 +49,138 @@ void alarm_handler(ARCH_SIGHDLR_PARAM)
                 switch_timers(1);
 }
 
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
+void set_sigstack(void *sig_stack, int size)
+{
+        stack_t stack = ((stack_t) { .ss_flags  = 0,
+                                     .ss_sp     = (__ptr_t) sig_stack,
+                                     .ss_size   = size - sizeof(void *) });
+
+        if(sigaltstack(&stack, NULL) != 0)
+                panic("enabling signal stack failed, errno = %d\n", errno);
+}
+
+void remove_sigstack(void)
+{
+        stack_t stack = ((stack_t) { .ss_flags  = SS_DISABLE,
+                                     .ss_sp     = NULL,
+                                     .ss_size   = 0 });
+
+        if(sigaltstack(&stack, NULL) != 0)
+                panic("disabling signal stack failed, errno = %d\n", errno);
+}
+
+void set_handler(int sig, void (*handler)(int), int flags, ...)
+{
+        struct sigaction action;
+        va_list ap;
+        int mask;
+
+        va_start(ap, flags);
+        action.sa_handler = handler;
+        sigemptyset(&action.sa_mask);
+        while((mask = va_arg(ap, int)) != -1){
+                sigaddset(&action.sa_mask, mask);
+        }
+        va_end(ap);
+        action.sa_flags = flags;
+        action.sa_restorer = NULL;
+        if(sigaction(sig, &action, NULL) < 0)
+                panic("sigaction failed");
+}
+
+int change_sig(int signal, int on)
+{
+        sigset_t sigset, old;
+
+        sigemptyset(&sigset);
+        sigaddset(&sigset, signal);
+        sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, &old);
+        return(!sigismember(&old, signal));
+}
+
+/* Both here and in set/get_signal we don't touch SIGPROF, because we must not
+ * disable profiling; it's safe because the profiling code does not interact
+ * with the kernel code at all.*/
+
+static void change_signals(int type)
+{
+        sigset_t mask;
+
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGVTALRM);
+        sigaddset(&mask, SIGALRM);
+        sigaddset(&mask, SIGIO);
+        if(sigprocmask(type, &mask, NULL) < 0)
+                panic("Failed to change signal mask - errno = %d", errno);
+}
+
+void block_signals(void)
+{
+        change_signals(SIG_BLOCK);
+}
+
+void unblock_signals(void)
+{
+        change_signals(SIG_UNBLOCK);
+}
+
+/* These are the asynchronous signals.  SIGVTALRM and SIGARLM are handled
+ * together under SIGVTALRM_BIT.  SIGPROF is excluded because we want to
+ * be able to profile all of UML, not just the non-critical sections.  If
+ * profiling is not thread-safe, then that is not my problem.  We can disable
+ * profiling when SMP is enabled in that case.
  */
+#define SIGIO_BIT 0
+#define SIGVTALRM_BIT 1
+
+static int enable_mask(sigset_t *mask)
+{
+        int sigs;
+
+        sigs = sigismember(mask, SIGIO) ? 0 : 1 << SIGIO_BIT;
+        sigs |= sigismember(mask, SIGVTALRM) ? 0 : 1 << SIGVTALRM_BIT;
+        sigs |= sigismember(mask, SIGALRM) ? 0 : 1 << SIGVTALRM_BIT;
+        return(sigs);
+}
+
+int get_signals(void)
+{
+        sigset_t mask;
+
+        if(sigprocmask(SIG_SETMASK, NULL, &mask) < 0)
+                panic("Failed to get signal mask");
+        return(enable_mask(&mask));
+}
+
+int set_signals(int enable)
+{
+        sigset_t mask;
+        int ret;
+
+        sigemptyset(&mask);
+        if(enable & (1 << SIGIO_BIT))
+                sigaddset(&mask, SIGIO);
+        if(enable & (1 << SIGVTALRM_BIT)){
+                sigaddset(&mask, SIGVTALRM);
+                sigaddset(&mask, SIGALRM);
+        }
+
+        /* This is safe - sigprocmask is guaranteed to copy locally the
+         * value of new_set, do his work and then, at the end, write to
+         * old_set.
+         */
+        if(sigprocmask(SIG_UNBLOCK, &mask, &mask) < 0)
+                panic("Failed to enable signals");
+        ret = enable_mask(&mask);
+        sigemptyset(&mask);
+        if((enable & (1 << SIGIO_BIT)) == 0)
+                sigaddset(&mask, SIGIO);
+        if((enable & (1 << SIGVTALRM_BIT)) == 0){
+                sigaddset(&mask, SIGVTALRM);
+                sigaddset(&mask, SIGALRM);
+        }
+        if(sigprocmask(SIG_BLOCK, &mask, NULL) < 0)
+                panic("Failed to block signals");
+
+        return(ret);
+}
diff --git a/arch/um/os-Linux/skas/Makefile b/arch/um/os-Linux/skas/Makefile
new file mode 100644
index 000000000000..eab5386d60a7
--- /dev/null
+++ b/arch/um/os-Linux/skas/Makefile
@@ -0,0 +1,10 @@
+#
+# Copyright (C) 2002 - 2004 Jeff Dike (jdike@addtoit.com)
+# Licensed under the GPL
+#
+
+obj-y := trap.o
+
+USER_OBJS := trap.o
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/os-Linux/skas/trap.c b/arch/um/os-Linux/skas/trap.c
new file mode 100644
index 000000000000..9ad5fbec4593
--- /dev/null
+++ b/arch/um/os-Linux/skas/trap.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include <signal.h>
+#include <errno.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "task.h"
+#include "sigcontext.h"
+#include "skas.h"
+#include "ptrace_user.h"
+#include "sysdep/ptrace.h"
+#include "sysdep/ptrace_user.h"
+#include "os.h"
+
+void sig_handler_common_skas(int sig, void *sc_ptr)
+{
+        struct sigcontext *sc = sc_ptr;
+        struct skas_regs *r;
+        void (*handler)(int, union uml_pt_regs *);
+        int save_errno = errno;
+        int save_user;
+
+        /* This is done because to allow SIGSEGV to be delivered inside a SEGV
+         * handler.  This can happen in copy_user, and if SEGV is disabled,
+         * the process will die.
+         * XXX Figure out why this is better than SA_NODEFER
+         */
+        if(sig == SIGSEGV)
+                change_sig(SIGSEGV, 1);
+
+        r = &TASK_REGS(get_current())->skas;
+        save_user = r->is_user;
+        r->is_user = 0;
+        if ( sig == SIGFPE || sig == SIGSEGV ||
+             sig == SIGBUS || sig == SIGILL ||
+             sig == SIGTRAP ) {
+                GET_FAULTINFO_FROM_SC(r->faultinfo, sc);
+        }
+
+        change_sig(SIGUSR1, 1);
+
+        handler = sig_info[sig];
+
+        /* unblock SIGALRM, SIGVTALRM, SIGIO if sig isn't IRQ signal */
+        if (sig != SIGIO && sig != SIGWINCH &&
+            sig != SIGVTALRM && sig != SIGALRM)
+                unblock_signals();
+
+        handler(sig, (union uml_pt_regs *) r);
+
+        errno = save_errno;
+        r->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();
+}
diff --git a/arch/um/os-Linux/start_up.c b/arch/um/os-Linux/start_up.c
index 29a9e3f43763..b47e5e71d1a5 100644
--- a/arch/um/os-Linux/start_up.c
+++ b/arch/um/os-Linux/start_up.c
@@ -24,7 +24,6 @@
 #include "kern_util.h"
 #include "user.h"
 #include "signal_kern.h"
-#include "signal_user.h"
 #include "sysdep/ptrace.h"
 #include "sysdep/sigcontext.h"
 #include "irq_user.h"
diff --git a/arch/um/os-Linux/trap.c b/arch/um/os-Linux/trap.c
new file mode 100644
index 000000000000..321e1c8e227d
--- /dev/null
+++ b/arch/um/os-Linux/trap.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <signal.h>
+#include <setjmp.h>
+#include "kern_util.h"
+#include "user_util.h"
+#include "os.h"
+#include "mode.h"
+
+void usr2_handler(int sig, union uml_pt_regs *regs)
+{
+        CHOOSE_MODE(syscall_handler_tt(sig, regs), (void) 0);
+}
+
+void (*sig_info[NSIG])(int, union uml_pt_regs *);
+
+void os_fill_handlinfo(struct kern_handlers h)
+{
+        sig_info[SIGTRAP] = h.relay_signal;
+        sig_info[SIGFPE] = h.relay_signal;
+        sig_info[SIGILL] = h.relay_signal;
+        sig_info[SIGWINCH] = h.winch;
+        sig_info[SIGBUS] = h.bus_handler;
+        sig_info[SIGSEGV] = h.page_fault;
+        sig_info[SIGIO] = h.sigio_handler;
+        sig_info[SIGVTALRM] = h.timer_handler;
+        sig_info[SIGALRM] = h.timer_handler;
+        sig_info[SIGUSR2] = usr2_handler;
+}
+
+void do_longjmp(void *b, int val)
+{
+        sigjmp_buf *buf = b;
+
+        siglongjmp(*buf, val);
+}
diff --git a/arch/um/os-Linux/tt.c b/arch/um/os-Linux/tt.c
index a6db8877931a..cb2648b79d0f 100644
--- a/arch/um/os-Linux/tt.c
+++ b/arch/um/os-Linux/tt.c
@@ -23,7 +23,6 @@
 #include "kern_util.h"
 #include "user.h"
 #include "signal_kern.h"
-#include "signal_user.h"
 #include "sysdep/ptrace.h"
 #include "sysdep/sigcontext.h"
 #include "irq_user.h"
@@ -50,6 +49,20 @@ int protect_memory(unsigned long addr, unsigned long len, int r, int w, int x,
         return(0);
 }
 
+void kill_child_dead(int pid)
+{
+        kill(pid, SIGKILL);
+        kill(pid, SIGCONT);
+        do {
+                int n;
+                CATCH_EINTR(n = waitpid(pid, NULL, 0));
+                if (n > 0)
+                        kill(pid, SIGCONT);
+                else
+                        break;
+        } while(1);
+}
+
 /*
  *-------------------------
  * only for tt mode (will be deleted in future...)