2 * Emulation of Linux signals
4 * Copyright (c) 2003 Fabrice Bellard
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
28 #include <sys/ucontext.h>
40 #include "qemu-common.h"
44 #define MAX_SIGQUEUE_SIZE 1024
47 struct sigqueue *next;
48 target_siginfo_t info;
51 struct emulated_sigaction {
52 struct target_sigaction sa;
53 int pending; /* true if signal is pending */
54 struct sigqueue *first;
55 struct sigqueue info; /* in order to always have memory for the
56 first signal, we put it here */
59 static struct sigaltstack target_sigaltstack_used = {
63 static struct emulated_sigaction sigact_table[NSIG];
64 static struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
65 static struct sigqueue *first_free; /* first free siginfo queue entry */
66 static int signal_pending; /* non zero if a signal may be pending */
68 static void host_signal_handler(int host_signum, siginfo_t *info,
72 static inline int host_to_target_signal(int sig)
77 static inline int target_to_host_signal(int sig)
82 /* siginfo conversion */
86 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
91 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
96 void signal_init(void)
101 /* set all host signal handlers. ALL signals are blocked during
102 the handlers to serialize them. */
103 sigfillset(&act.sa_mask);
104 act.sa_flags = SA_SIGINFO;
105 act.sa_sigaction = host_signal_handler;
106 for(i = 1; i < NSIG; i++) {
107 sigaction(i, &act, NULL);
110 memset(sigact_table, 0, sizeof(sigact_table));
112 first_free = &sigqueue_table[0];
113 for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++)
114 sigqueue_table[i].next = &sigqueue_table[i + 1];
115 sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;
118 /* signal queue handling */
120 static inline struct sigqueue *alloc_sigqueue(void)
122 struct sigqueue *q = first_free;
125 first_free = q->next;
129 static inline void free_sigqueue(struct sigqueue *q)
131 q->next = first_free;
135 /* abort execution with signal */
136 void QEMU_NORETURN force_sig(int sig)
139 host_sig = target_to_host_signal(sig);
140 fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
141 sig, strsignal(host_sig));
145 /* queue a signal so that it will be send to the virtual CPU as soon
147 int queue_signal(int sig, target_siginfo_t *info)
149 struct emulated_sigaction *k;
150 struct sigqueue *q, **pq;
151 target_ulong handler;
153 #if defined(DEBUG_SIGNAL)
154 fprintf(stderr, "queue_signal: sig=%d\n",
157 k = &sigact_table[sig - 1];
158 handler = (target_ulong)k->sa.sa_handler;
159 if (handler == SIG_DFL) {
160 /* default handler : ignore some signal. The other are fatal */
161 if (sig != SIGCHLD &&
166 return 0; /* indicate ignored */
168 } else if (handler == host_to_target_signal(SIG_IGN)) {
171 } else if (handler == host_to_target_signal(SIG_ERR)) {
179 q = alloc_sigqueue();
189 /* signal that a new signal is pending */
191 return 1; /* indicates that the signal was queued */
195 static void host_signal_handler(int host_signum, siginfo_t *info,
199 target_siginfo_t tinfo;
201 /* the CPU emulator uses some host signals to detect exceptions,
202 we we forward to it some signals */
203 if (host_signum == SIGSEGV || host_signum == SIGBUS) {
204 if (cpu_signal_handler(host_signum, (void*)info, puc))
208 /* get target signal number */
209 sig = host_to_target_signal(host_signum);
210 if (sig < 1 || sig > NSIG)
213 #if defined(DEBUG_SIGNAL)
214 fprintf(stderr, "qemu: got signal %d\n", sig);
216 if (queue_signal(sig, &tinfo) == 1) {
217 /* interrupt the virtual CPU as soon as possible */
218 cpu_exit(global_env);
222 int do_sigaltstack(const struct sigaltstack *ss, struct sigaltstack *oss)
224 /* XXX: test errors */
227 oss->ss_sp = tswap32(target_sigaltstack_used.ss_sp);
228 oss->ss_size = tswap32(target_sigaltstack_used.ss_size);
229 oss->ss_flags = tswap32(target_sigaltstack_used.ss_flags);
233 target_sigaltstack_used.ss_sp = tswap32(ss->ss_sp);
234 target_sigaltstack_used.ss_size = tswap32(ss->ss_size);
235 target_sigaltstack_used.ss_flags = tswap32(ss->ss_flags);
240 int do_sigaction(int sig, const struct sigaction *act,
241 struct sigaction *oact)
243 struct emulated_sigaction *k;
244 struct sigaction act1;
247 if (sig < 1 || sig > NSIG)
250 k = &sigact_table[sig - 1];
251 #if defined(DEBUG_SIGNAL)
252 fprintf(stderr, "sigaction 1 sig=%d act=0x%08x, oact=0x%08x\n",
253 sig, (int)act, (int)oact);
256 #if defined(DEBUG_SIGNAL)
257 fprintf(stderr, "sigaction 1 sig=%d act=0x%08x, oact=0x%08x\n",
258 sig, (int)act, (int)oact);
261 oact->sa_handler = tswapl(k->sa.sa_handler);
262 oact->sa_flags = tswapl(k->sa.sa_flags);
263 oact->sa_mask = tswapl(k->sa.sa_mask);
266 #if defined(DEBUG_SIGNAL)
267 fprintf(stderr, "sigaction handler 0x%x flag 0x%x mask 0x%x\n",
268 act->sa_handler, act->sa_flags, act->sa_mask);
271 k->sa.sa_handler = tswapl(act->sa_handler);
272 k->sa.sa_flags = tswapl(act->sa_flags);
273 k->sa.sa_mask = tswapl(act->sa_mask);
274 /* we update the host signal state */
275 host_sig = target_to_host_signal(sig);
276 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
277 #if defined(DEBUG_SIGNAL)
278 fprintf(stderr, "sigaction handler going to call sigaction\n",
279 act->sa_handler, act->sa_flags, act->sa_mask);
282 sigfillset(&act1.sa_mask);
283 act1.sa_flags = SA_SIGINFO;
284 if (k->sa.sa_flags & SA_RESTART)
285 act1.sa_flags |= SA_RESTART;
286 /* NOTE: it is important to update the host kernel signal
287 ignore state to avoid getting unexpected interrupted
289 if (k->sa.sa_handler == SIG_IGN) {
290 act1.sa_sigaction = (void *)SIG_IGN;
291 } else if (k->sa.sa_handler == SIG_DFL) {
292 act1.sa_sigaction = (void *)SIG_DFL;
294 act1.sa_sigaction = host_signal_handler;
296 sigaction(host_sig, &act1, NULL);
306 get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
309 if(target_sigaltstack_used.ss_flags & SA_DISABLE)
312 /* Default to using normal stack */
313 esp = env->regs[R_ESP];
315 return (void *)((esp - frame_size) & -8ul);
319 return target_sigaltstack_used.ss_sp;
323 static void setup_frame(int sig, struct emulated_sigaction *ka,
324 void *set, CPUState *env)
329 fprintf(stderr, "setup_frame %d\n", sig);
330 frame = get_sigframe(ka, env, sizeof(*frame));
332 /* Set up registers for signal handler */
333 env->regs[R_ESP] = (unsigned long) frame;
334 env->eip = (unsigned long) ka->sa.sa_handler;
336 env->eflags &= ~TF_MASK;
342 ka->sa.sa_handler = SIG_DFL;
343 force_sig(SIGSEGV /* , current */);
346 long do_sigreturn(CPUState *env, int num)
349 struct target_sigcontext *scp = get_int_arg(&i, env);
350 /* XXX Get current signal number */
351 /* XXX Adjust accordin to sc_onstack, sc_mask */
352 if(tswapl(scp->sc_onstack) & 0x1)
353 target_sigaltstack_used.ss_flags |= ~SA_DISABLE;
355 target_sigaltstack_used.ss_flags &= SA_DISABLE;
356 int set = tswapl(scp->sc_eax);
357 sigprocmask(SIG_SETMASK, &set, NULL);
359 fprintf(stderr, "do_sigreturn: partially implemented %x EAX:%x EBX:%x\n", scp->sc_mask, tswapl(scp->sc_eax), tswapl(scp->sc_ebx));
360 fprintf(stderr, "ECX:%x EDX:%x EDI:%x\n", scp->sc_ecx, tswapl(scp->sc_edx), tswapl(scp->sc_edi));
361 fprintf(stderr, "EIP:%x\n", tswapl(scp->sc_eip));
363 env->regs[R_EAX] = tswapl(scp->sc_eax);
364 env->regs[R_EBX] = tswapl(scp->sc_ebx);
365 env->regs[R_ECX] = tswapl(scp->sc_ecx);
366 env->regs[R_EDX] = tswapl(scp->sc_edx);
367 env->regs[R_EDI] = tswapl(scp->sc_edi);
368 env->regs[R_ESI] = tswapl(scp->sc_esi);
369 env->regs[R_EBP] = tswapl(scp->sc_ebp);
370 env->regs[R_ESP] = tswapl(scp->sc_esp);
371 env->segs[R_SS].selector = (void*)tswapl(scp->sc_ss);
372 env->eflags = tswapl(scp->sc_eflags);
373 env->eip = tswapl(scp->sc_eip);
374 env->segs[R_CS].selector = (void*)tswapl(scp->sc_cs);
375 env->segs[R_DS].selector = (void*)tswapl(scp->sc_ds);
376 env->segs[R_ES].selector = (void*)tswapl(scp->sc_es);
377 env->segs[R_FS].selector = (void*)tswapl(scp->sc_fs);
378 env->segs[R_GS].selector = (void*)tswapl(scp->sc_gs);
380 /* Again, because our caller's caller will reset EAX */
381 return env->regs[R_EAX];
386 static void setup_frame(int sig, struct emulated_sigaction *ka,
387 void *set, CPUState *env)
389 fprintf(stderr, "setup_frame: not implemented\n");
392 long do_sigreturn(CPUState *env, int num)
395 struct target_sigcontext *scp = get_int_arg(&i, env);
396 fprintf(stderr, "do_sigreturn: not implemented\n");
402 void process_pending_signals(void *cpu_env)
404 struct emulated_sigaction *k;
406 target_ulong handler;
414 for(sig = 1; sig <= NSIG; sig++) {
420 /* if no signal is pending, just return */
425 fprintf(stderr, "qemu: process signal %d\n", sig);
433 sig = gdb_handlesig (cpu_env, sig);
435 fprintf (stderr, "Lost signal\n");
439 handler = k->sa.sa_handler;
440 if (handler == SIG_DFL) {
441 /* default handler : ignore some signal. The other are fatal */
442 if (sig != SIGCHLD &&
447 } else if (handler == SIG_IGN) {
449 } else if (handler == SIG_ERR) {
453 setup_frame(sig, k, 0, cpu_env);
454 if (k->sa.sa_flags & SA_RESETHAND)
455 k->sa.sa_handler = SIG_DFL;