uml: more __init annotations

[linux-2.6-omap-h63xx.git] / arch / um / os-Linux / signal.c

diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c
index 6b81739279d1fe059e3d23310e7b532b363be8a0..18e5c8b67eb8cebbe84db25bed7e64e623522dc9 100644 (file)
--- a/arch/um/os-Linux/signal.c
+++ b/arch/um/os-Linux/signal.c
@@ -11,10 +11,10 @@
 #include <stdarg.h>
 #include <string.h>
 #include <sys/mman.h>
-#include "user_util.h"
 #include "user.h"
 #include "signal_kern.h"
 #include "sysdep/sigcontext.h"
+#include "sysdep/barrier.h"
 #include "sigcontext.h"
 #include "mode.h"
 #include "os.h"
@@ -34,8 +34,12 @@
 #define SIGALRM_BIT 2
 #define SIGALRM_MASK (1 << SIGALRM_BIT)
 
-static int signals_enabled = 1;
-static int pending = 0;
+/* These are used by both the signal handlers and
+ * block/unblock_signals.  I don't want modifications cached in a
+ * register - they must go straight to memory.
+ */
+static volatile int signals_enabled = 1;
+static volatile int pending = 0;
 
 void sig_handler(int sig, struct sigcontext *sc)
 {
@@ -57,15 +61,19 @@ void sig_handler(int sig, struct sigcontext *sc)
 
 static void real_alarm_handler(int sig, struct sigcontext *sc)
 {
+       union uml_pt_regs regs;
+
        if(sig == SIGALRM)
                switch_timers(0);
 
-       CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
-                        sig, sc);
+       if(sc != NULL)
+               copy_sc(&regs, sc);
+       regs.skas.is_user = 0;
+       unblock_signals();
+       timer_handler(sig, &regs);
 
        if(sig == SIGALRM)
                switch_timers(1);
-
 }
 
 void alarm_handler(int sig, struct sigcontext *sc)
@@ -109,6 +117,46 @@ void remove_sigstack(void)
 
 void (*handlers[_NSIG])(int sig, struct sigcontext *sc);
 
+void handle_signal(int sig, struct sigcontext *sc)
+{
+       unsigned long pending = 0;
+
+       do {
+               int nested, bail;
+
+               /*
+                * pending comes back with one bit set for each
+                * interrupt that arrived while setting up the stack,
+                * plus a bit for this interrupt, plus the zero bit is
+                * set if this is a nested interrupt.
+                * If bail is true, then we interrupted another
+                * handler setting up the stack.  In this case, we
+                * have to return, and the upper handler will deal
+                * with this interrupt.
+                */
+               bail = to_irq_stack(sig, &pending);
+               if(bail)
+                       return;
+
+               nested = pending & 1;
+               pending &= ~1;
+
+               while((sig = ffs(pending)) != 0){
+                       sig--;
+                       pending &= ~(1 << sig);
+                       (*handlers[sig])(sig, sc);
+               }
+
+               /* Again, pending comes back with a mask of signals
+                * that arrived while tearing down the stack.  If this
+                * is non-zero, we just go back, set up the stack
+                * again, and handle the new interrupts.
+                */
+               if(!nested)
+                       pending = from_irq_stack(nested);
+       } while(pending);
+}
+
 extern void hard_handler(int sig);
 
 void set_handler(int sig, void (*handler)(int), int flags, ...)
@@ -152,6 +200,12 @@ int change_sig(int signal, int on)
 void block_signals(void)
 {
        signals_enabled = 0;
+       /* This must return with signals disabled, so this barrier
+        * ensures that writes are flushed out before the return.
+        * This might matter if gcc figures out how to inline this and
+        * decides to shuffle this code into the caller.
+        */
+       mb();
 }
 
 void unblock_signals(void)
@@ -171,9 +225,23 @@ void unblock_signals(void)
                 */
                signals_enabled = 1;
 
+               /* Setting signals_enabled and reading pending must
+                * happen in this order.
+                */
+               mb();
+
                save_pending = pending;
-               if(save_pending == 0)
+               if(save_pending == 0){
+                       /* This must return with signals enabled, so
+                        * this barrier ensures that writes are
+                        * flushed out before the return.  This might
+                        * matter if gcc figures out how to inline
+                        * this (unlikely, given its size) and decides
+                        * to shuffle this code into the caller.
+                        */
+                       mb();
                        return;
+               }
 
                pending = 0;
 
@@ -218,8 +286,3 @@ int set_signals(int enable)
 
        return ret;
 }
-
-void os_usr1_signal(int on)
-{
-       change_sig(SIGUSR1, on);
-}