[PATCH] uml: Move signal handlers to arch code
[linux-2.6] / 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 extern int timer_irq_inited;
59
60 static void real_alarm_handler(int sig, struct sigcontext *sc)
61 {
62         if(!timer_irq_inited){
63                 signals_enabled = 1;
64                 return;
65         }
66
67         if(sig == SIGALRM)
68                 switch_timers(0);
69
70         CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
71                          sig, sc);
72
73         if(sig == SIGALRM)
74                 switch_timers(1);
75
76 }
77
78 void alarm_handler(int sig, struct sigcontext *sc)
79 {
80         int enabled;
81
82         enabled = signals_enabled;
83         if(!signals_enabled){
84                 if(sig == SIGVTALRM)
85                         pending |= SIGVTALRM_MASK;
86                 else pending |= SIGALRM_MASK;
87
88                 return;
89         }
90
91         block_signals();
92
93         real_alarm_handler(sig, sc);
94         set_signals(enabled);
95 }
96
97 void set_sigstack(void *sig_stack, int size)
98 {
99         stack_t stack = ((stack_t) { .ss_flags  = 0,
100                                      .ss_sp     = (__ptr_t) sig_stack,
101                                      .ss_size   = size - sizeof(void *) });
102
103         if(sigaltstack(&stack, NULL) != 0)
104                 panic("enabling signal stack failed, errno = %d\n", errno);
105 }
106
107 void remove_sigstack(void)
108 {
109         stack_t stack = ((stack_t) { .ss_flags  = SS_DISABLE,
110                                      .ss_sp     = NULL,
111                                      .ss_size   = 0 });
112
113         if(sigaltstack(&stack, NULL) != 0)
114                 panic("disabling signal stack failed, errno = %d\n", errno);
115 }
116
117 void (*handlers[_NSIG])(int sig, struct sigcontext *sc);
118
119 extern void hard_handler(int sig);
120
121 void set_handler(int sig, void (*handler)(int), int flags, ...)
122 {
123         struct sigaction action;
124         va_list ap;
125         sigset_t sig_mask;
126         int mask;
127
128         handlers[sig] = (void (*)(int, struct sigcontext *)) handler;
129         action.sa_handler = hard_handler;
130
131         sigemptyset(&action.sa_mask);
132
133         va_start(ap, flags);
134         while((mask = va_arg(ap, int)) != -1)
135                 sigaddset(&action.sa_mask, mask);
136         va_end(ap);
137
138         action.sa_flags = flags;
139         action.sa_restorer = NULL;
140         if(sigaction(sig, &action, NULL) < 0)
141                 panic("sigaction failed - errno = %d\n", errno);
142
143         sigemptyset(&sig_mask);
144         sigaddset(&sig_mask, sig);
145         if(sigprocmask(SIG_UNBLOCK, &sig_mask, NULL) < 0)
146                 panic("sigprocmask failed - errno = %d\n", errno);
147 }
148
149 int change_sig(int signal, int on)
150 {
151         sigset_t sigset, old;
152
153         sigemptyset(&sigset);
154         sigaddset(&sigset, signal);
155         sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, &old);
156         return(!sigismember(&old, signal));
157 }
158
159 void block_signals(void)
160 {
161         signals_enabled = 0;
162 }
163
164 void unblock_signals(void)
165 {
166         int save_pending;
167
168         if(signals_enabled == 1)
169                 return;
170
171         /* We loop because the IRQ handler returns with interrupts off.  So,
172          * interrupts may have arrived and we need to re-enable them and
173          * recheck pending.
174          */
175         while(1){
176                 /* Save and reset save_pending after enabling signals.  This
177                  * way, pending won't be changed while we're reading it.
178                  */
179                 signals_enabled = 1;
180
181                 save_pending = pending;
182                 if(save_pending == 0)
183                         return;
184
185                 pending = 0;
186
187                 /* We have pending interrupts, so disable signals, as the
188                  * handlers expect them off when they are called.  They will
189                  * be enabled again above.
190                  */
191
192                 signals_enabled = 0;
193
194                 /* Deal with SIGIO first because the alarm handler might
195                  * schedule, leaving the pending SIGIO stranded until we come
196                  * back here.
197                  */
198                 if(save_pending & SIGIO_MASK)
199                         CHOOSE_MODE_PROC(sig_handler_common_tt,
200                                          sig_handler_common_skas, SIGIO, NULL);
201
202                 if(save_pending & SIGALRM_MASK)
203                         real_alarm_handler(SIGALRM, NULL);
204
205                 if(save_pending & SIGVTALRM_MASK)
206                         real_alarm_handler(SIGVTALRM, NULL);
207         }
208 }
209
210 int get_signals(void)
211 {
212         return signals_enabled;
213 }
214
215 int set_signals(int enable)
216 {
217         int ret;
218         if(signals_enabled == enable)
219                 return enable;
220
221         ret = signals_enabled;
222         if(enable)
223                 unblock_signals();
224         else block_signals();
225
226         return ret;
227 }
228
229 void os_usr1_signal(int on)
230 {
231         change_sig(SIGUSR1, on);
232 }