arch/um/os-Linux/signal.c

   1 /*
   2  * Copyright (C) 2004 PathScale, Inc
   3  * Licensed under the GPL
   4  */
   5
   6 #include <signal.h>
   7 #include <stdio.h>
   8 #include <unistd.h>
   9 #include <stdlib.h>
  10 #include <errno.h>
  11 #include <stdarg.h>
  12 #include <string.h>
  13 #include <sys/mman.h>
  14 #include "user_util.h"
  15 #include "user.h"
  16 #include "signal_kern.h"
  17 #include "sysdep/sigcontext.h"
  18 #include "sigcontext.h"
  19 #include "mode.h"
  20 #include "os.h"
  21
  22 /* These are the asynchronous signals.  SIGVTALRM and SIGARLM are handled
  23  * together under SIGVTALRM_BIT.  SIGPROF is excluded because we want to
  24  * be able to profile all of UML, not just the non-critical sections.  If
  25  * profiling is not thread-safe, then that is not my problem.  We can disable
  26  * profiling when SMP is enabled in that case.
  27  */
  28 #define SIGIO_BIT 0
  29 #define SIGIO_MASK (1 << SIGIO_BIT)
  30
  31 #define SIGVTALRM_BIT 1
  32 #define SIGVTALRM_MASK (1 << SIGVTALRM_BIT)
  33
  34 #define SIGALRM_BIT 2
  35 #define SIGALRM_MASK (1 << SIGALRM_BIT)
  36
  37 static int signals_enabled = 1;
  38 static int pending = 0;
  39
  40 void sig_handler(int sig, struct sigcontext *sc)
  41 {
  42         int enabled;
  43
  44         enabled = signals_enabled;
  45         if(!enabled && (sig == SIGIO)){
  46                 pending |= SIGIO_MASK;
  47                 return;
  48         }
  49
  50         block_signals();
  51
  52         CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
  53                          sig, sc);
  54
  55         set_signals(enabled);
  56 }
  57
  58 static void real_alarm_handler(int sig, struct sigcontext *sc)
  59 {
  60         if(sig == SIGALRM)
  61                 switch_timers(0);
  62
  63         CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
  64                          sig, sc);
  65
  66         if(sig == SIGALRM)
  67                 switch_timers(1);
  68
  69 }
  70
  71 void alarm_handler(int sig, struct sigcontext *sc)
  72 {
  73         int enabled;
  74
  75         enabled = signals_enabled;
  76         if(!signals_enabled){
  77                 if(sig == SIGVTALRM)
  78                         pending |= SIGVTALRM_MASK;
  79                 else pending |= SIGALRM_MASK;
  80
  81                 return;
  82         }
  83
  84         block_signals();
  85
  86         real_alarm_handler(sig, sc);
  87         set_signals(enabled);
  88 }
  89
  90 void set_sigstack(void *sig_stack, int size)
  91 {
  92         stack_t stack = ((stack_t) { .ss_flags  = 0,
  93                                      .ss_sp     = (__ptr_t) sig_stack,
  94                                      .ss_size   = size - sizeof(void *) });
  95
  96         if(sigaltstack(&stack, NULL) != 0)
  97                 panic("enabling signal stack failed, errno = %d\n", errno);
  98 }
  99
 100 void remove_sigstack(void)
 101 {
 102         stack_t stack = ((stack_t) { .ss_flags  = SS_DISABLE,
 103                                      .ss_sp     = NULL,
 104                                      .ss_size   = 0 });
 105
 106         if(sigaltstack(&stack, NULL) != 0)
 107                 panic("disabling signal stack failed, errno = %d\n", errno);
 108 }
 109
 110 void (*handlers[_NSIG])(int sig, struct sigcontext *sc);
 111
 112 extern void hard_handler(int sig);
 113
 114 void set_handler(int sig, void (*handler)(int), int flags, ...)
 115 {
 116         struct sigaction action;
 117         va_list ap;
 118         sigset_t sig_mask;
 119         int mask;
 120
 121         handlers[sig] = (void (*)(int, struct sigcontext *)) handler;
 122         action.sa_handler = hard_handler;
 123
 124         sigemptyset(&action.sa_mask);
 125
 126         va_start(ap, flags);
 127         while((mask = va_arg(ap, int)) != -1)
 128                 sigaddset(&action.sa_mask, mask);
 129         va_end(ap);
 130
 131         action.sa_flags = flags;
 132         action.sa_restorer = NULL;
 133         if(sigaction(sig, &action, NULL) < 0)
 134                 panic("sigaction failed - errno = %d\n", errno);
 135
 136         sigemptyset(&sig_mask);
 137         sigaddset(&sig_mask, sig);
 138         if(sigprocmask(SIG_UNBLOCK, &sig_mask, NULL) < 0)
 139                 panic("sigprocmask failed - errno = %d\n", errno);
 140 }
 141
 142 int change_sig(int signal, int on)
 143 {
 144         sigset_t sigset, old;
 145
 146         sigemptyset(&sigset);
 147         sigaddset(&sigset, signal);
 148         sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, &old);
 149         return(!sigismember(&old, signal));
 150 }
 151
 152 void block_signals(void)
 153 {
 154         signals_enabled = 0;
 155 }
 156
 157 void unblock_signals(void)
 158 {
 159         int save_pending;
 160
 161         if(signals_enabled == 1)
 162                 return;
 163
 164         /* We loop because the IRQ handler returns with interrupts off.  So,
 165          * interrupts may have arrived and we need to re-enable them and
 166          * recheck pending.
 167          */
 168         while(1){
 169                 /* Save and reset save_pending after enabling signals.  This
 170                  * way, pending won't be changed while we're reading it.
 171                  */
 172                 signals_enabled = 1;
 173
 174                 save_pending = pending;
 175                 if(save_pending == 0)
 176                         return;
 177
 178                 pending = 0;
 179
 180                 /* We have pending interrupts, so disable signals, as the
 181                  * handlers expect them off when they are called.  They will
 182                  * be enabled again above.
 183                  */
 184
 185                 signals_enabled = 0;
 186
 187                 /* Deal with SIGIO first because the alarm handler might
 188                  * schedule, leaving the pending SIGIO stranded until we come
 189                  * back here.
 190                  */
 191                 if(save_pending & SIGIO_MASK)
 192                         CHOOSE_MODE_PROC(sig_handler_common_tt,
 193                                          sig_handler_common_skas, SIGIO, NULL);
 194
 195                 if(save_pending & SIGALRM_MASK)
 196                         real_alarm_handler(SIGALRM, NULL);
 197
 198                 if(save_pending & SIGVTALRM_MASK)
 199                         real_alarm_handler(SIGVTALRM, NULL);
 200         }
 201 }
 202
 203 int get_signals(void)
 204 {
 205         return signals_enabled;
 206 }
 207
 208 int set_signals(int enable)
 209 {
 210         int ret;
 211         if(signals_enabled == enable)
 212                 return enable;
 213
 214         ret = signals_enabled;
 215         if(enable)
 216                 unblock_signals();
 217         else block_signals();
 218
 219         return ret;
 220 }
 221
 222 void os_usr1_signal(int on)
 223 {
 224         change_sig(SIGUSR1, on);
 225 }