2 * Copyright (C) 2004 PathScale, Inc
3 * Copyright (C) 2004 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
4 * Licensed under the GPL
12 #include "as-layout.h"
13 #include "kern_util.h"
16 #include "sysdep/barrier.h"
17 #include "sysdep/mcontext.h"
19 void (*sig_info
[NSIG
])(int, struct uml_pt_regs
*) = {
20 [SIGTRAP
] = relay_signal
,
21 [SIGFPE
] = relay_signal
,
22 [SIGILL
] = relay_signal
,
24 [SIGBUS
] = bus_handler
,
25 [SIGSEGV
] = segv_handler
,
26 [SIGIO
] = sigio_handler
,
27 [SIGVTALRM
] = timer_handler
};
29 static void sig_handler_common(int sig
, mcontext_t
*mc
)
32 int save_errno
= errno
;
36 /* For segfaults, we want the data from the sigcontext. */
37 get_regs_from_mc(&r
, mc
);
38 GET_FAULTINFO_FROM_MC(r
.faultinfo
, mc
);
41 /* enable signals if sig isn't IRQ signal */
42 if ((sig
!= SIGIO
) && (sig
!= SIGWINCH
) && (sig
!= SIGVTALRM
))
45 (*sig_info
[sig
])(sig
, &r
);
51 * These are the asynchronous signals. SIGPROF is excluded because we want to
52 * be able to profile all of UML, not just the non-critical sections. If
53 * profiling is not thread-safe, then that is not my problem. We can disable
54 * profiling when SMP is enabled in that case.
57 #define SIGIO_MASK (1 << SIGIO_BIT)
59 #define SIGVTALRM_BIT 1
60 #define SIGVTALRM_MASK (1 << SIGVTALRM_BIT)
62 static int signals_enabled
;
63 static unsigned int signals_pending
;
65 void sig_handler(int sig
, mcontext_t
*mc
)
69 enabled
= signals_enabled
;
70 if (!enabled
&& (sig
== SIGIO
)) {
71 signals_pending
|= SIGIO_MASK
;
77 sig_handler_common(sig
, mc
);
82 static void real_alarm_handler(mcontext_t
*mc
)
84 struct uml_pt_regs regs
;
87 get_regs_from_mc(®s
, mc
);
90 timer_handler(SIGVTALRM
, ®s
);
93 void alarm_handler(int sig
, mcontext_t
*mc
)
97 enabled
= signals_enabled
;
98 if (!signals_enabled
) {
99 signals_pending
|= SIGVTALRM_MASK
;
105 real_alarm_handler(mc
);
106 set_signals(enabled
);
109 void timer_init(void)
111 set_handler(SIGVTALRM
);
114 void set_sigstack(void *sig_stack
, int size
)
116 stack_t stack
= ((stack_t
) { .ss_flags
= 0,
117 .ss_sp
= (__ptr_t
) sig_stack
,
118 .ss_size
= size
- sizeof(void *) });
120 if (sigaltstack(&stack
, NULL
) != 0)
121 panic("enabling signal stack failed, errno = %d\n", errno
);
124 static void (*handlers
[_NSIG
])(int sig
, mcontext_t
*mc
) = {
125 [SIGSEGV
] = sig_handler
,
126 [SIGBUS
] = sig_handler
,
127 [SIGILL
] = sig_handler
,
128 [SIGFPE
] = sig_handler
,
129 [SIGTRAP
] = sig_handler
,
131 [SIGIO
] = sig_handler
,
132 [SIGWINCH
] = sig_handler
,
133 [SIGVTALRM
] = alarm_handler
137 static void hard_handler(int sig
, siginfo_t
*info
, void *p
)
139 struct ucontext
*uc
= p
;
140 mcontext_t
*mc
= &uc
->uc_mcontext
;
141 unsigned long pending
= 1UL << sig
;
147 * pending comes back with one bit set for each
148 * interrupt that arrived while setting up the stack,
149 * plus a bit for this interrupt, plus the zero bit is
150 * set if this is a nested interrupt.
151 * If bail is true, then we interrupted another
152 * handler setting up the stack. In this case, we
153 * have to return, and the upper handler will deal
154 * with this interrupt.
156 bail
= to_irq_stack(&pending
);
160 nested
= pending
& 1;
163 while ((sig
= ffs(pending
)) != 0){
165 pending
&= ~(1 << sig
);
166 (*handlers
[sig
])(sig
, mc
);
170 * Again, pending comes back with a mask of signals
171 * that arrived while tearing down the stack. If this
172 * is non-zero, we just go back, set up the stack
173 * again, and handle the new interrupts.
176 pending
= from_irq_stack(nested
);
180 void set_handler(int sig
)
182 struct sigaction action
;
183 int flags
= SA_SIGINFO
| SA_ONSTACK
;
186 action
.sa_sigaction
= hard_handler
;
189 sigemptyset(&action
.sa_mask
);
190 sigaddset(&action
.sa_mask
, SIGVTALRM
);
191 sigaddset(&action
.sa_mask
, SIGIO
);
192 sigaddset(&action
.sa_mask
, SIGWINCH
);
197 if (sigismember(&action
.sa_mask
, sig
))
198 flags
|= SA_RESTART
; /* if it's an irq signal */
200 action
.sa_flags
= flags
;
201 action
.sa_restorer
= NULL
;
202 if (sigaction(sig
, &action
, NULL
) < 0)
203 panic("sigaction failed - errno = %d\n", errno
);
205 sigemptyset(&sig_mask
);
206 sigaddset(&sig_mask
, sig
);
207 if (sigprocmask(SIG_UNBLOCK
, &sig_mask
, NULL
) < 0)
208 panic("sigprocmask failed - errno = %d\n", errno
);
211 int change_sig(int signal
, int on
)
215 sigemptyset(&sigset
);
216 sigaddset(&sigset
, signal
);
217 if (sigprocmask(on
? SIG_UNBLOCK
: SIG_BLOCK
, &sigset
, NULL
) < 0)
223 void block_signals(void)
227 * This must return with signals disabled, so this barrier
228 * ensures that writes are flushed out before the return.
229 * This might matter if gcc figures out how to inline this and
230 * decides to shuffle this code into the caller.
235 void unblock_signals(void)
239 if (signals_enabled
== 1)
243 * We loop because the IRQ handler returns with interrupts off. So,
244 * interrupts may have arrived and we need to re-enable them and
245 * recheck signals_pending.
249 * Save and reset save_pending after enabling signals. This
250 * way, signals_pending won't be changed while we're reading it.
255 * Setting signals_enabled and reading signals_pending must
256 * happen in this order.
260 save_pending
= signals_pending
;
261 if (save_pending
== 0)
267 * We have pending interrupts, so disable signals, as the
268 * handlers expect them off when they are called. They will
269 * be enabled again above.
275 * Deal with SIGIO first because the alarm handler might
276 * schedule, leaving the pending SIGIO stranded until we come
279 if (save_pending
& SIGIO_MASK
)
280 sig_handler_common(SIGIO
, NULL
);
282 if (save_pending
& SIGVTALRM_MASK
)
283 real_alarm_handler(NULL
);
287 int get_signals(void)
289 return signals_enabled
;
292 int set_signals(int enable
)
295 if (signals_enabled
== enable
)
298 ret
= signals_enabled
;
301 else block_signals();