1 files changed, 51 insertions, 45 deletions

diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c
index 583424b9797d..49c113b576b7 100644
--- a/arch/um/os-Linux/signal.c
+++ b/arch/um/os-Linux/signal.c
@@ -1,24 +1,21 @@
 /*
  * Copyright (C) 2004 PathScale, Inc
+ * Copyright (C) 2004 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#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.h"
-#include "signal_kern.h"
-#include "sysdep/sigcontext.h"
-#include "sysdep/barrier.h"
-#include "sigcontext.h"
+#include <errno.h>
+#include <signal.h>
+#include <strings.h>
 #include "os.h"
+#include "sysdep/barrier.h"
+#include "sysdep/sigcontext.h"
+#include "user.h"
 
-/* These are the asynchronous signals.  SIGVTALRM and SIGARLM are handled
+/*
+ * 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
@@ -33,7 +30,8 @@
 #define SIGALRM_BIT 2
 #define SIGALRM_MASK (1 << SIGALRM_BIT)
 
-/* These are used by both the signal handlers and
+/*
+ * 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.
  */
@@ -45,7 +43,7 @@ void sig_handler(int sig, struct sigcontext *sc)
         int enabled;
 
         enabled = signals_enabled;
-        if(!enabled && (sig == SIGIO)){
+        if (!enabled && (sig == SIGIO)) {
                 pending |= SIGIO_MASK;
                 return;
         }
@@ -61,16 +59,16 @@ static void real_alarm_handler(int sig, struct sigcontext *sc)
 {
         struct uml_pt_regs regs;
 
-        if(sig == SIGALRM)
+        if (sig == SIGALRM)
                 switch_timers(0);
 
-        if(sc != NULL)
+        if (sc != NULL)
                 copy_sc(&regs, sc);
         regs.is_user = 0;
         unblock_signals();
         timer_handler(sig, &regs);
 
-        if(sig == SIGALRM)
+        if (sig == SIGALRM)
                 switch_timers(1);
 }
 
@@ -79,8 +77,8 @@ void alarm_handler(int sig, struct sigcontext *sc)
         int enabled;
 
         enabled = signals_enabled;
-        if(!signals_enabled){
-                if(sig == SIGVTALRM)
+        if (!signals_enabled) {
+                if (sig == SIGVTALRM)
                         pending |= SIGVTALRM_MASK;
                 else pending |= SIGALRM_MASK;
 
@@ -99,7 +97,7 @@ void set_sigstack(void *sig_stack, int size)
                                      .ss_sp     = (__ptr_t) sig_stack,
                                      .ss_size   = size - sizeof(void *) });
 
-        if(sigaltstack(&stack, NULL) != 0)
+        if (sigaltstack(&stack, NULL) != 0)
                 panic("enabling signal stack failed, errno = %d\n", errno);
 }
 
@@ -109,7 +107,7 @@ void remove_sigstack(void)
                                      .ss_sp     = NULL,
                                      .ss_size   = 0 });
 
-        if(sigaltstack(&stack, NULL) != 0)
+        if (sigaltstack(&stack, NULL) != 0)
                 panic("disabling signal stack failed, errno = %d\n", errno);
 }
 
@@ -133,26 +131,27 @@ void handle_signal(int sig, struct sigcontext *sc)
                  * with this interrupt.
                  */
                 bail = to_irq_stack(&pending);
-                if(bail)
+                if (bail)
                         return;
 
                 nested = pending & 1;
                 pending &= ~1;
 
-                while((sig = ffs(pending)) != 0){
+                while ((sig = ffs(pending)) != 0){
                         sig--;
                         pending &= ~(1 << sig);
                         (*handlers[sig])(sig, sc);
                 }
 
-                /* Again, pending comes back with a mask of signals
+                /*
+                 * 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)
+                if (!nested)
                         pending = from_irq_stack(nested);
-        } while(pending);
+        } while (pending);
 }
 
 extern void hard_handler(int sig);
@@ -170,18 +169,18 @@ void set_handler(int sig, void (*handler)(int), int flags, ...)
         sigemptyset(&action.sa_mask);
 
         va_start(ap, flags);
-        while((mask = va_arg(ap, int)) != -1)
+        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)
+        if (sigaction(sig, &action, NULL) < 0)
                 panic("sigaction failed - errno = %d\n", errno);
 
         sigemptyset(&sig_mask);
         sigaddset(&sig_mask, sig);
-        if(sigprocmask(SIG_UNBLOCK, &sig_mask, NULL) < 0)
+        if (sigprocmask(SIG_UNBLOCK, &sig_mask, NULL) < 0)
                 panic("sigprocmask failed - errno = %d\n", errno);
 }
 
@@ -192,13 +191,14 @@ int change_sig(int signal, int on)
         sigemptyset(&sigset);
         sigaddset(&sigset, signal);
         sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, &old);
-        return(!sigismember(&old, signal));
+        return !sigismember(&old, signal);
 }
 
 void block_signals(void)
 {
         signals_enabled = 0;
-        /* This must return with signals disabled, so this barrier
+        /*
+         * 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.
@@ -210,27 +210,31 @@ void unblock_signals(void)
 {
         int save_pending;
 
-        if(signals_enabled == 1)
+        if (signals_enabled == 1)
                 return;
 
-        /* We loop because the IRQ handler returns with interrupts off.  So,
+        /*
+         * We loop because the IRQ handler returns with interrupts off.  So,
          * interrupts may have arrived and we need to re-enable them and
          * recheck pending.
          */
-        while(1){
-                /* Save and reset save_pending after enabling signals.  This
+        while(1) {
+                /*
+                 * Save and reset save_pending after enabling signals.  This
                  * way, pending won't be changed while we're reading it.
                  */
                 signals_enabled = 1;
 
-                /* Setting signals_enabled and reading pending must
+                /*
+                 * Setting signals_enabled and reading pending must
                  * happen in this order.
                  */
                 mb();
 
                 save_pending = pending;
-                if(save_pending == 0){
-                        /* This must return with signals enabled, so
+                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
@@ -243,24 +247,26 @@ void unblock_signals(void)
 
                 pending = 0;
 
-                /* We have pending interrupts, so disable signals, as the
+                /*
+                 * We have pending interrupts, so disable signals, as the
                  * handlers expect them off when they are called.  They will
                  * be enabled again above.
                  */
 
                 signals_enabled = 0;
 
-                /* Deal with SIGIO first because the alarm handler might
+                /*
+                 * Deal with SIGIO first because the alarm handler might
                  * schedule, leaving the pending SIGIO stranded until we come
                  * back here.
                  */
-                if(save_pending & SIGIO_MASK)
+                if (save_pending & SIGIO_MASK)
                         sig_handler_common_skas(SIGIO, NULL);
 
-                if(save_pending & SIGALRM_MASK)
+                if (save_pending & SIGALRM_MASK)
                         real_alarm_handler(SIGALRM, NULL);
 
-                if(save_pending & SIGVTALRM_MASK)
+                if (save_pending & SIGVTALRM_MASK)
                         real_alarm_handler(SIGVTALRM, NULL);
         }
 }
@@ -273,11 +279,11 @@ int get_signals(void)
 int set_signals(int enable)
 {
         int ret;
-        if(signals_enabled == enable)
+        if (signals_enabled == enable)
                 return enable;
 
         ret = signals_enabled;
-        if(enable)
+        if (enable)
                 unblock_signals();
         else block_signals();