]> Git Repo - qemu.git/blame - linux-user/signal.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
windows support for kqemu (Filip Navara)
[qemu.git] / linux-user / signal.c
CommitLineData
31e31b8a 1/*
66fb9763 2 * Emulation of Linux signals
31e31b8a
FB		 3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
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.
10 *
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.
15 *
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., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20#include <stdlib.h>
21#include <stdio.h>
66fb9763 22#include <string.h>
31e31b8a 23#include <stdarg.h>
2677e107 24#include <unistd.h>
31e31b8a 25#include <signal.h>
66fb9763 26#include <errno.h>
31e31b8a
FB		 27#include <sys/ucontext.h>
28
3ef693a0 29#include "qemu.h"
66fb9763
FB		 30
31//#define DEBUG_SIGNAL
32
33#define MAX_SIGQUEUE_SIZE 1024
34
35struct sigqueue {
36 struct sigqueue *next;
9de5e440 37 target_siginfo_t info;
66fb9763 38};
31e31b8a
FB		 39
40struct emulated_sigaction {
41 struct target_sigaction sa;
66fb9763
FB		 42 int pending; /* true if signal is pending */
43 struct sigqueue *first;
44 struct sigqueue info; /* in order to always have memory for the
45 first signal, we put it here */
31e31b8a
FB		 46};
47
66fb9763
FB		 48static struct emulated_sigaction sigact_table[TARGET_NSIG];
49static struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
50static struct sigqueue *first_free; /* first free siginfo queue entry */
51static int signal_pending; /* non zero if a signal may be pending */
31e31b8a 52
66fb9763
FB		 53static void host_signal_handler(int host_signum, siginfo_t *info,
54 void *puc);
55
9e5f5284
FB		 56static uint8_t host_to_target_signal_table[65] = {
57 [SIGHUP] = TARGET_SIGHUP,
58 [SIGINT] = TARGET_SIGINT,
59 [SIGQUIT] = TARGET_SIGQUIT,
60 [SIGILL] = TARGET_SIGILL,
61 [SIGTRAP] = TARGET_SIGTRAP,
62 [SIGABRT] = TARGET_SIGABRT,
01e3b763 63/* [SIGIOT] = TARGET_SIGIOT,*/
9e5f5284
FB		 64 [SIGBUS] = TARGET_SIGBUS,
65 [SIGFPE] = TARGET_SIGFPE,
66 [SIGKILL] = TARGET_SIGKILL,
67 [SIGUSR1] = TARGET_SIGUSR1,
68 [SIGSEGV] = TARGET_SIGSEGV,
69 [SIGUSR2] = TARGET_SIGUSR2,
70 [SIGPIPE] = TARGET_SIGPIPE,
71 [SIGALRM] = TARGET_SIGALRM,
72 [SIGTERM] = TARGET_SIGTERM,
73#ifdef SIGSTKFLT
74 [SIGSTKFLT] = TARGET_SIGSTKFLT,
75#endif
76 [SIGCHLD] = TARGET_SIGCHLD,
77 [SIGCONT] = TARGET_SIGCONT,
78 [SIGSTOP] = TARGET_SIGSTOP,
79 [SIGTSTP] = TARGET_SIGTSTP,
80 [SIGTTIN] = TARGET_SIGTTIN,
81 [SIGTTOU] = TARGET_SIGTTOU,
82 [SIGURG] = TARGET_SIGURG,
83 [SIGXCPU] = TARGET_SIGXCPU,
84 [SIGXFSZ] = TARGET_SIGXFSZ,
85 [SIGVTALRM] = TARGET_SIGVTALRM,
86 [SIGPROF] = TARGET_SIGPROF,
87 [SIGWINCH] = TARGET_SIGWINCH,
88 [SIGIO] = TARGET_SIGIO,
89 [SIGPWR] = TARGET_SIGPWR,
90 [SIGSYS] = TARGET_SIGSYS,
91 /* next signals stay the same */
92};
93static uint8_t target_to_host_signal_table[65];
94
31e31b8a
FB		 95static inline int host_to_target_signal(int sig)
96{
9e5f5284 97 return host_to_target_signal_table[sig];
31e31b8a
FB		 98}
99
100static inline int target_to_host_signal(int sig)
101{
9e5f5284 102 return target_to_host_signal_table[sig];
31e31b8a
FB		 103}
104
9231944d
FB		 105static void host_to_target_sigset_internal(target_sigset_t *d,
106 const sigset_t *s)
66fb9763
FB		 107{
108 int i;
9e5f5284
FB		 109 unsigned long sigmask;
110 uint32_t target_sigmask;
111
112 sigmask = ((unsigned long *)s)[0];
113 target_sigmask = 0;
114 for(i = 0; i < 32; i++) {
115 if (sigmask & (1 << i))
116 target_sigmask |= 1 << (host_to_target_signal(i + 1) - 1);
117 }
118#if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
9231944d 119 d->sig[0] = target_sigmask;
9e5f5284 120 for(i = 1;i < TARGET_NSIG_WORDS; i++) {
9231944d 121 d->sig[i] = ((unsigned long *)s)[i];
66fb9763 122 }
9e5f5284 123#elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
9231944d
FB		 124 d->sig[0] = target_sigmask;
125 d->sig[1] = sigmask >> 32;
9e5f5284 126#else
a315a145 127#warning host_to_target_sigset
9e5f5284 128#endif
66fb9763
FB		 129}
130
9231944d
FB		 131void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
132{
133 target_sigset_t d1;
134 int i;
135
136 host_to_target_sigset_internal(&d1, s);
137 for(i = 0;i < TARGET_NSIG_WORDS; i++)
138 __put_user(d1.sig[i], &d->sig[i]);
139}
140
141void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s)
66fb9763
FB		 142{
143 int i;
9e5f5284
FB		 144 unsigned long sigmask;
145 target_ulong target_sigmask;
146
9231944d 147 target_sigmask = s->sig[0];
9e5f5284
FB		 148 sigmask = 0;
149 for(i = 0; i < 32; i++) {
150 if (target_sigmask & (1 << i))
151 sigmask |= 1 << (target_to_host_signal(i + 1) - 1);
152 }
153#if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
154 ((unsigned long *)d)[0] = sigmask;
155 for(i = 1;i < TARGET_NSIG_WORDS; i++) {
9231944d 156 ((unsigned long *)d)[i] = s->sig[i];
66fb9763 157 }
9e5f5284 158#elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
9231944d 159 ((unsigned long *)d)[0] = sigmask | ((unsigned long)(s->sig[1]) << 32);
9e5f5284 160#else
a315a145 161#warning target_to_host_sigset
9e5f5284 162#endif /* TARGET_LONG_BITS */
66fb9763
FB		 163}
164
9231944d
FB		 165void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
166{
167 target_sigset_t s1;
168 int i;
169
170 for(i = 0;i < TARGET_NSIG_WORDS; i++)
171 __get_user(s1.sig[i], &s->sig[i]);
172 target_to_host_sigset_internal(d, &s1);
173}
174
66fb9763
FB		 175void host_to_target_old_sigset(target_ulong *old_sigset,
176 const sigset_t *sigset)
177{
9e5f5284
FB		 178 target_sigset_t d;
179 host_to_target_sigset(&d, sigset);
180 *old_sigset = d.sig[0];
66fb9763
FB		 181}
182
183void target_to_host_old_sigset(sigset_t *sigset,
184 const target_ulong *old_sigset)
185{
9e5f5284
FB		 186 target_sigset_t d;
187 int i;
188
189 d.sig[0] = *old_sigset;
190 for(i = 1;i < TARGET_NSIG_WORDS; i++)
191 d.sig[i] = 0;
192 target_to_host_sigset(sigset, &d);
66fb9763
FB		 193}
194
9de5e440
FB		 195/* siginfo conversion */
196
197static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
198 const siginfo_t *info)
66fb9763 199{
9de5e440
FB		 200 int sig;
201 sig = host_to_target_signal(info->si_signo);
202 tinfo->si_signo = sig;
203 tinfo->si_errno = 0;
204 tinfo->si_code = 0;
447db213
FB		 205 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
206 sig == SIGBUS || sig == SIGTRAP) {
9de5e440
FB		 207 /* should never come here, but who knows. The information for
208 the target is irrelevant */
209 tinfo->_sifields._sigfault._addr = 0;
210 } else if (sig >= TARGET_SIGRTMIN) {
211 tinfo->_sifields._rt._pid = info->si_pid;
212 tinfo->_sifields._rt._uid = info->si_uid;
213 /* XXX: potential problem if 64 bit */
214 tinfo->_sifields._rt._sigval.sival_ptr =
215 (target_ulong)info->si_value.sival_ptr;
216 }
217}
218
219static void tswap_siginfo(target_siginfo_t *tinfo,
220 const target_siginfo_t *info)
221{
222 int sig;
223 sig = info->si_signo;
224 tinfo->si_signo = tswap32(sig);
66fb9763
FB		 225 tinfo->si_errno = tswap32(info->si_errno);
226 tinfo->si_code = tswap32(info->si_code);
447db213
FB		 227 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
228 sig == SIGBUS || sig == SIGTRAP) {
9de5e440
FB		 229 tinfo->_sifields._sigfault._addr =
230 tswapl(info->_sifields._sigfault._addr);
231 } else if (sig >= TARGET_SIGRTMIN) {
232 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
233 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
234 tinfo->_sifields._rt._sigval.sival_ptr =
235 tswapl(info->_sifields._rt._sigval.sival_ptr);
236 }
237}
238
239
240void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
241{
242 host_to_target_siginfo_noswap(tinfo, info);
243 tswap_siginfo(tinfo, tinfo);
66fb9763
FB		 244}
245
9de5e440
FB		 246/* XXX: we support only POSIX RT signals are used. */
247/* XXX: find a solution for 64 bit (additionnal malloced data is needed) */
248void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
66fb9763
FB		 249{
250 info->si_signo = tswap32(tinfo->si_signo);
251 info->si_errno = tswap32(tinfo->si_errno);
252 info->si_code = tswap32(tinfo->si_code);
9de5e440
FB		 253 info->si_pid = tswap32(tinfo->_sifields._rt._pid);
254 info->si_uid = tswap32(tinfo->_sifields._rt._uid);
255 info->si_value.sival_ptr =
256 (void *)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
66fb9763
FB		 257}
258
31e31b8a
FB		 259void signal_init(void)
260{
261 struct sigaction act;
9e5f5284 262 int i, j;
31e31b8a 263
9e5f5284
FB		 264 /* generate signal conversion tables */
265 for(i = 1; i <= 64; i++) {
266 if (host_to_target_signal_table[i] == 0)
267 host_to_target_signal_table[i] = i;
268 }
269 for(i = 1; i <= 64; i++) {
270 j = host_to_target_signal_table[i];
271 target_to_host_signal_table[j] = i;
272 }
273
9de5e440
FB		 274 /* set all host signal handlers. ALL signals are blocked during
275 the handlers to serialize them. */
276 sigfillset(&act.sa_mask);
31e31b8a
FB		 277 act.sa_flags = SA_SIGINFO;
278 act.sa_sigaction = host_signal_handler;
279 for(i = 1; i < NSIG; i++) {
c9087c2a 280 sigaction(i, &act, NULL);
31e31b8a
FB		 281 }
282
283 memset(sigact_table, 0, sizeof(sigact_table));
66fb9763
FB		 284
285 first_free = &sigqueue_table[0];
286 for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++)
287 sigqueue_table[i].next = &sigqueue_table[i + 1];
288 sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;
289}
290
291/* signal queue handling */
292
293static inline struct sigqueue *alloc_sigqueue(void)
294{
295 struct sigqueue *q = first_free;
296 if (!q)
297 return NULL;
298 first_free = q->next;
299 return q;
31e31b8a
FB		 300}
301
66fb9763
FB		 302static inline void free_sigqueue(struct sigqueue *q)
303{
304 q->next = first_free;
305 first_free = q;
306}
307
9de5e440
FB		 308/* abort execution with signal */
309void __attribute((noreturn)) force_sig(int sig)
66fb9763
FB		 310{
311 int host_sig;
66fb9763 312 host_sig = target_to_host_signal(sig);
bc8a22cc 313 fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
66fb9763 314 sig, strsignal(host_sig));
9de5e440 315#if 1
66fb9763 316 _exit(-host_sig);
9de5e440
FB		 317#else
318 {
319 struct sigaction act;
320 sigemptyset(&act.sa_mask);
321 act.sa_flags = SA_SIGINFO;
322 act.sa_sigaction = SIG_DFL;
323 sigaction(SIGABRT, &act, NULL);
324 abort();
325 }
326#endif
66fb9763
FB		 327}
328
9de5e440
FB		 329/* queue a signal so that it will be send to the virtual CPU as soon
330 as possible */
331int queue_signal(int sig, target_siginfo_t *info)
31e31b8a 332{
66fb9763 333 struct emulated_sigaction *k;
9de5e440 334 struct sigqueue *q, **pq;
66fb9763
FB		 335 target_ulong handler;
336
9de5e440 337#if defined(DEBUG_SIGNAL)
bc8a22cc 338 fprintf(stderr, "queue_signal: sig=%d\n",
9de5e440 339 sig);
66fb9763 340#endif
9de5e440 341 k = &sigact_table[sig - 1];
66fb9763
FB		 342 handler = k->sa._sa_handler;
343 if (handler == TARGET_SIG_DFL) {
344 /* default handler : ignore some signal. The other are fatal */
345 if (sig != TARGET_SIGCHLD &&
346 sig != TARGET_SIGURG &&
347 sig != TARGET_SIGWINCH) {
348 force_sig(sig);
9de5e440
FB		 349 } else {
350 return 0; /* indicate ignored */
66fb9763
FB		 351 }
352 } else if (handler == TARGET_SIG_IGN) {
353 /* ignore signal */
9de5e440 354 return 0;
66fb9763
FB		 355 } else if (handler == TARGET_SIG_ERR) {
356 force_sig(sig);
357 } else {
9de5e440
FB		 358 pq = &k->first;
359 if (sig < TARGET_SIGRTMIN) {
360 /* if non real time signal, we queue exactly one signal */
361 if (!k->pending)
362 q = &k->info;
363 else
364 return 0;
365 } else {
366 if (!k->pending) {
367 /* first signal */
368 q = &k->info;
369 } else {
370 q = alloc_sigqueue();
371 if (!q)
372 return -EAGAIN;
373 while (*pq != NULL)
374 pq = &(*pq)->next;
375 }
376 }
377 *pq = q;
378 q->info = *info;
379 q->next = NULL;
380 k->pending = 1;
381 /* signal that a new signal is pending */
382 signal_pending = 1;
383 return 1; /* indicates that the signal was queued */
384 }
385}
386
9de5e440
FB		 387static void host_signal_handler(int host_signum, siginfo_t *info,
388 void *puc)
389{
390 int sig;
391 target_siginfo_t tinfo;
392
393 /* the CPU emulator uses some host signals to detect exceptions,
394 we we forward to it some signals */
58fe2f10
FB		 395 if (host_signum == SIGSEGV || host_signum == SIGBUS
396#if defined(TARGET_I386) && defined(USE_CODE_COPY)
397 || host_signum == SIGFPE
398#endif
399 ) {
b346ff46 400 if (cpu_signal_handler(host_signum, info, puc))
9de5e440
FB		 401 return;
402 }
403
404 /* get target signal number */
405 sig = host_to_target_signal(host_signum);
406 if (sig < 1 || sig > TARGET_NSIG)
407 return;
408#if defined(DEBUG_SIGNAL)
bc8a22cc 409 fprintf(stderr, "qemu: got signal %d\n", sig);
9de5e440
FB		 410#endif
411 host_to_target_siginfo_noswap(&tinfo, info);
412 if (queue_signal(sig, &tinfo) == 1) {
413 /* interrupt the virtual CPU as soon as possible */
68a79315 414 cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
66fb9763
FB		 415 }
416}
417
418int do_sigaction(int sig, const struct target_sigaction *act,
419 struct target_sigaction *oact)
420{
421 struct emulated_sigaction *k;
773b93ee
FB		 422 struct sigaction act1;
423 int host_sig;
66fb9763
FB		 424
425 if (sig < 1 || sig > TARGET_NSIG)
426 return -EINVAL;
427 k = &sigact_table[sig - 1];
773b93ee 428#if defined(DEBUG_SIGNAL)
66fb9763
FB		 429 fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
430 sig, (int)act, (int)oact);
431#endif
432 if (oact) {
433 oact->_sa_handler = tswapl(k->sa._sa_handler);
434 oact->sa_flags = tswapl(k->sa.sa_flags);
435 oact->sa_restorer = tswapl(k->sa.sa_restorer);
436 oact->sa_mask = k->sa.sa_mask;
437 }
438 if (act) {
439 k->sa._sa_handler = tswapl(act->_sa_handler);
440 k->sa.sa_flags = tswapl(act->sa_flags);
441 k->sa.sa_restorer = tswapl(act->sa_restorer);
442 k->sa.sa_mask = act->sa_mask;
773b93ee
FB		 443
444 /* we update the host linux signal state */
445 host_sig = target_to_host_signal(sig);
446 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
447 sigfillset(&act1.sa_mask);
448 act1.sa_flags = SA_SIGINFO;
449 if (k->sa.sa_flags & TARGET_SA_RESTART)
450 act1.sa_flags |= SA_RESTART;
451 /* NOTE: it is important to update the host kernel signal
452 ignore state to avoid getting unexpected interrupted
453 syscalls */
454 if (k->sa._sa_handler == TARGET_SIG_IGN) {
455 act1.sa_sigaction = (void *)SIG_IGN;
456 } else if (k->sa._sa_handler == TARGET_SIG_DFL) {
457 act1.sa_sigaction = (void *)SIG_DFL;
458 } else {
459 act1.sa_sigaction = host_signal_handler;
460 }
461 sigaction(host_sig, &act1, NULL);
462 }
66fb9763
FB		 463 }
464 return 0;
465}
466
43fff238
FB		 467#ifndef offsetof
468#define offsetof(type, field) ((size_t) &((type *)0)->field)
469#endif
470
471static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
472 const target_siginfo_t *info)
473{
474 tswap_siginfo(tinfo, info);
475 return 0;
476}
477
66fb9763
FB		 478#ifdef TARGET_I386
479
480/* from the Linux kernel */
481
482struct target_fpreg {
483 uint16_t significand[4];
484 uint16_t exponent;
485};
486
487struct target_fpxreg {
488 uint16_t significand[4];
489 uint16_t exponent;
490 uint16_t padding[3];
491};
492
493struct target_xmmreg {
494 target_ulong element[4];
495};
496
497struct target_fpstate {
498 /* Regular FPU environment */
499 target_ulong cw;
500 target_ulong sw;
501 target_ulong tag;
502 target_ulong ipoff;
503 target_ulong cssel;
504 target_ulong dataoff;
505 target_ulong datasel;
506 struct target_fpreg _st[8];
507 uint16_t status;
508 uint16_t magic; /* 0xffff = regular FPU data only */
509
510 /* FXSR FPU environment */
511 target_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
512 target_ulong mxcsr;
513 target_ulong reserved;
514 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
515 struct target_xmmreg _xmm[8];
516 target_ulong padding[56];
517};
518
519#define X86_FXSR_MAGIC 0x0000
520
521struct target_sigcontext {
522 uint16_t gs, __gsh;
523 uint16_t fs, __fsh;
524 uint16_t es, __esh;
525 uint16_t ds, __dsh;
526 target_ulong edi;
527 target_ulong esi;
528 target_ulong ebp;
529 target_ulong esp;
530 target_ulong ebx;
531 target_ulong edx;
532 target_ulong ecx;
533 target_ulong eax;
534 target_ulong trapno;
535 target_ulong err;
536 target_ulong eip;
537 uint16_t cs, __csh;
538 target_ulong eflags;
539 target_ulong esp_at_signal;
540 uint16_t ss, __ssh;
541 target_ulong fpstate; /* pointer */
542 target_ulong oldmask;
543 target_ulong cr2;
544};
545
546typedef struct target_sigaltstack {
547 target_ulong ss_sp;
548 int ss_flags;
549 target_ulong ss_size;
550} target_stack_t;
551
552struct target_ucontext {
b8076a74
FB		 553 target_ulong tuc_flags;
554 target_ulong tuc_link;
555 target_stack_t tuc_stack;
556 struct target_sigcontext tuc_mcontext;
557 target_sigset_t tuc_sigmask; /* mask last for extensibility */
66fb9763
FB		 558};
559
560struct sigframe
561{
562 target_ulong pretcode;
563 int sig;
564 struct target_sigcontext sc;
565 struct target_fpstate fpstate;
566 target_ulong extramask[TARGET_NSIG_WORDS-1];
567 char retcode[8];
568};
569
570struct rt_sigframe
571{
572 target_ulong pretcode;
573 int sig;
574 target_ulong pinfo;
575 target_ulong puc;
576 struct target_siginfo info;
577 struct target_ucontext uc;
578 struct target_fpstate fpstate;
579 char retcode[8];
580};
581
582/*
583 * Set up a signal frame.
584 */
585
66fb9763
FB		 586/* XXX: save x87 state */
587static int
588setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
589 CPUX86State *env, unsigned long mask)
590{
591 int err = 0;
592
a52c757c
FB		 593 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
594 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
595 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
596 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
66fb9763
FB		 597 err |= __put_user(env->regs[R_EDI], &sc->edi);
598 err |= __put_user(env->regs[R_ESI], &sc->esi);
599 err |= __put_user(env->regs[R_EBP], &sc->ebp);
600 err |= __put_user(env->regs[R_ESP], &sc->esp);
601 err |= __put_user(env->regs[R_EBX], &sc->ebx);
602 err |= __put_user(env->regs[R_EDX], &sc->edx);
603 err |= __put_user(env->regs[R_ECX], &sc->ecx);
604 err |= __put_user(env->regs[R_EAX], &sc->eax);
66099dd9
FB		 605 err |= __put_user(env->exception_index, &sc->trapno);
606 err |= __put_user(env->error_code, &sc->err);
66fb9763 607 err |= __put_user(env->eip, &sc->eip);
a52c757c 608 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
66fb9763
FB		 609 err |= __put_user(env->eflags, &sc->eflags);
610 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
a52c757c 611 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
ed2dcdf6
FB		 612
613 cpu_x86_fsave(env, (void *)fpstate, 1);
614 fpstate->status = fpstate->sw;
615 err |= __put_user(0xffff, &fpstate->magic);
616 err |= __put_user(fpstate, &sc->fpstate);
617
66fb9763
FB		 618 /* non-iBCS2 extensions.. */
619 err |= __put_user(mask, &sc->oldmask);
a52c757c 620 err |= __put_user(env->cr[2], &sc->cr2);
66fb9763 621 return err;
31e31b8a
FB		 622}
623
66fb9763
FB		 624/*
625 * Determine which stack to use..
626 */
31e31b8a 627
66fb9763
FB		 628static inline void *
629get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
31e31b8a 630{
66fb9763
FB		 631 unsigned long esp;
632
633 /* Default to using normal stack */
634 esp = env->regs[R_ESP];
635#if 0
636 /* This is the X/Open sanctioned signal stack switching. */
637 if (ka->sa.sa_flags & SA_ONSTACK) {
638 if (sas_ss_flags(esp) == 0)
639 esp = current->sas_ss_sp + current->sas_ss_size;
640 }
641
642 /* This is the legacy signal stack switching. */
a52c757c 643 else
66fb9763 644#endif
a52c757c
FB		 645 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
646 !(ka->sa.sa_flags & TARGET_SA_RESTORER) &&
647 ka->sa.sa_restorer) {
648 esp = (unsigned long) ka->sa.sa_restorer;
649 }
650 return (void *)((esp - frame_size) & -8ul);
66fb9763
FB		 651}
652
66fb9763
FB		 653static void setup_frame(int sig, struct emulated_sigaction *ka,
654 target_sigset_t *set, CPUX86State *env)
655{
656 struct sigframe *frame;
9231944d 657 int i, err = 0;
66fb9763
FB		 658
659 frame = get_sigframe(ka, env, sizeof(*frame));
660
66fb9763
FB		 661 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
662 goto give_sigsegv;
66fb9763
FB		 663 err |= __put_user((/*current->exec_domain
664 && current->exec_domain->signal_invmap
665 && sig < 32
666 ? current->exec_domain->signal_invmap[sig]
667 : */ sig),
668 &frame->sig);
669 if (err)
670 goto give_sigsegv;
671
672 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0]);
673 if (err)
674 goto give_sigsegv;
675
9231944d
FB		 676 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
677 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
678 goto give_sigsegv;
679 }
66fb9763
FB		 680
681 /* Set up to return from userspace. If provided, use a stub
682 already in userspace. */
683 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
684 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
685 } else {
686 err |= __put_user(frame->retcode, &frame->pretcode);
687 /* This is popl %eax ; movl $,%eax ; int $0x80 */
688 err |= __put_user(0xb858, (short *)(frame->retcode+0));
689 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
690 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
691 }
692
693 if (err)
694 goto give_sigsegv;
695
696 /* Set up registers for signal handler */
697 env->regs[R_ESP] = (unsigned long) frame;
698 env->eip = (unsigned long) ka->sa._sa_handler;
699
700 cpu_x86_load_seg(env, R_DS, __USER_DS);
701 cpu_x86_load_seg(env, R_ES, __USER_DS);
702 cpu_x86_load_seg(env, R_SS, __USER_DS);
703 cpu_x86_load_seg(env, R_CS, __USER_CS);
704 env->eflags &= ~TF_MASK;
705
706 return;
707
708give_sigsegv:
709 if (sig == TARGET_SIGSEGV)
710 ka->sa._sa_handler = TARGET_SIG_DFL;
711 force_sig(TARGET_SIGSEGV /* , current */);
712}
713
9de5e440
FB		 714static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
715 target_siginfo_t *info,
66fb9763
FB		 716 target_sigset_t *set, CPUX86State *env)
717{
718 struct rt_sigframe *frame;
9231944d 719 int i, err = 0;
66fb9763
FB		 720
721 frame = get_sigframe(ka, env, sizeof(*frame));
722
66fb9763
FB		 723 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
724 goto give_sigsegv;
66fb9763
FB		 725
726 err |= __put_user((/*current->exec_domain
727 && current->exec_domain->signal_invmap
728 && sig < 32
729 ? current->exec_domain->signal_invmap[sig]
730 : */sig),
731 &frame->sig);
732 err |= __put_user((target_ulong)&frame->info, &frame->pinfo);
733 err |= __put_user((target_ulong)&frame->uc, &frame->puc);
734 err |= copy_siginfo_to_user(&frame->info, info);
735 if (err)
736 goto give_sigsegv;
31e31b8a 737
66fb9763 738 /* Create the ucontext. */
b8076a74
FB		 739 err |= __put_user(0, &frame->uc.tuc_flags);
740 err |= __put_user(0, &frame->uc.tuc_link);
741 err |= __put_user(/*current->sas_ss_sp*/ 0,
742 &frame->uc.tuc_stack.ss_sp);
66fb9763 743 err |= __put_user(/* sas_ss_flags(regs->esp) */ 0,
b8076a74
FB		 744 &frame->uc.tuc_stack.ss_flags);
745 err |= __put_user(/* current->sas_ss_size */ 0,
746 &frame->uc.tuc_stack.ss_size);
747 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
66fb9763 748 env, set->sig[0]);
9231944d 749 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 750 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
9231944d
FB		 751 goto give_sigsegv;
752 }
31e31b8a 753
66fb9763
FB		 754 /* Set up to return from userspace. If provided, use a stub
755 already in userspace. */
756 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
757 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
758 } else {
759 err |= __put_user(frame->retcode, &frame->pretcode);
760 /* This is movl $,%eax ; int $0x80 */
761 err |= __put_user(0xb8, (char *)(frame->retcode+0));
762 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
763 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
764 }
765
766 if (err)
767 goto give_sigsegv;
768
769 /* Set up registers for signal handler */
770 env->regs[R_ESP] = (unsigned long) frame;
771 env->eip = (unsigned long) ka->sa._sa_handler;
772
773 cpu_x86_load_seg(env, R_DS, __USER_DS);
774 cpu_x86_load_seg(env, R_ES, __USER_DS);
775 cpu_x86_load_seg(env, R_SS, __USER_DS);
776 cpu_x86_load_seg(env, R_CS, __USER_CS);
777 env->eflags &= ~TF_MASK;
778
779 return;
780
781give_sigsegv:
782 if (sig == TARGET_SIGSEGV)
783 ka->sa._sa_handler = TARGET_SIG_DFL;
784 force_sig(TARGET_SIGSEGV /* , current */);
785}
786
787static int
788restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
789{
790 unsigned int err = 0;
791
66fb9763
FB		 792 cpu_x86_load_seg(env, R_GS, lduw(&sc->gs));
793 cpu_x86_load_seg(env, R_FS, lduw(&sc->fs));
794 cpu_x86_load_seg(env, R_ES, lduw(&sc->es));
795 cpu_x86_load_seg(env, R_DS, lduw(&sc->ds));
796
797 env->regs[R_EDI] = ldl(&sc->edi);
798 env->regs[R_ESI] = ldl(&sc->esi);
799 env->regs[R_EBP] = ldl(&sc->ebp);
800 env->regs[R_ESP] = ldl(&sc->esp);
801 env->regs[R_EBX] = ldl(&sc->ebx);
802 env->regs[R_EDX] = ldl(&sc->edx);
803 env->regs[R_ECX] = ldl(&sc->ecx);
804 env->eip = ldl(&sc->eip);
805
806 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
807 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
808
809 {
810 unsigned int tmpflags;
811 tmpflags = ldl(&sc->eflags);
812 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
813 // regs->orig_eax = -1; /* disable syscall checks */
814 }
815
66fb9763
FB		 816 {
817 struct _fpstate * buf;
ed2dcdf6 818 buf = (void *)ldl(&sc->fpstate);
66fb9763 819 if (buf) {
ed2dcdf6 820#if 0
66fb9763
FB		 821 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
822 goto badframe;
ed2dcdf6
FB		 823#endif
824 cpu_x86_frstor(env, (void *)buf, 1);
66fb9763
FB		 825 }
826 }
ed2dcdf6 827
66fb9763
FB		 828 *peax = ldl(&sc->eax);
829 return err;
830#if 0
831badframe:
832 return 1;
833#endif
834}
835
836long do_sigreturn(CPUX86State *env)
837{
838 struct sigframe *frame = (struct sigframe *)(env->regs[R_ESP] - 8);
839 target_sigset_t target_set;
840 sigset_t set;
841 int eax, i;
842
447db213
FB		 843#if defined(DEBUG_SIGNAL)
844 fprintf(stderr, "do_sigreturn\n");
845#endif
66fb9763 846 /* set blocked signals */
9231944d
FB		 847 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
848 goto badframe;
849 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
850 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
851 goto badframe;
852 }
66fb9763 853
9231944d 854 target_to_host_sigset_internal(&set, &target_set);
66fb9763
FB		 855 sigprocmask(SIG_SETMASK, &set, NULL);
856
857 /* restore registers */
858 if (restore_sigcontext(env, &frame->sc, &eax))
859 goto badframe;
860 return eax;
861
862badframe:
863 force_sig(TARGET_SIGSEGV);
864 return 0;
865}
866
867long do_rt_sigreturn(CPUX86State *env)
868{
869 struct rt_sigframe *frame = (struct rt_sigframe *)(env->regs[R_ESP] - 4);
66fb9763
FB		 870 sigset_t set;
871 // stack_t st;
872 int eax;
873
874#if 0
875 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
876 goto badframe;
877#endif
b8076a74 878 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
66fb9763
FB		 879 sigprocmask(SIG_SETMASK, &set, NULL);
880
b8076a74 881 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
66fb9763
FB		 882 goto badframe;
883
884#if 0
b8076a74 885 if (__copy_from_user(&st, &frame->uc.tuc_stack, sizeof(st)))
66fb9763
FB		 886 goto badframe;
887 /* It is more difficult to avoid calling this function than to
888 call it and ignore errors. */
889 do_sigaltstack(&st, NULL, regs->esp);
890#endif
891 return eax;
892
893badframe:
894 force_sig(TARGET_SIGSEGV);
895 return 0;
896}
897
43fff238
FB		 898#elif defined(TARGET_ARM)
899
900struct target_sigcontext {
901 target_ulong trap_no;
902 target_ulong error_code;
903 target_ulong oldmask;
904 target_ulong arm_r0;
905 target_ulong arm_r1;
906 target_ulong arm_r2;
907 target_ulong arm_r3;
908 target_ulong arm_r4;
909 target_ulong arm_r5;
910 target_ulong arm_r6;
911 target_ulong arm_r7;
912 target_ulong arm_r8;
913 target_ulong arm_r9;
914 target_ulong arm_r10;
915 target_ulong arm_fp;
916 target_ulong arm_ip;
917 target_ulong arm_sp;
918 target_ulong arm_lr;
919 target_ulong arm_pc;
920 target_ulong arm_cpsr;
921 target_ulong fault_address;
922};
923
924typedef struct target_sigaltstack {
925 target_ulong ss_sp;
926 int ss_flags;
927 target_ulong ss_size;
928} target_stack_t;
929
930struct target_ucontext {
b8076a74
FB		 931 target_ulong tuc_flags;
932 target_ulong tuc_link;
933 target_stack_t tuc_stack;
934 struct target_sigcontext tuc_mcontext;
935 target_sigset_t tuc_sigmask; /* mask last for extensibility */
43fff238
FB		 936};
937
938struct sigframe
939{
940 struct target_sigcontext sc;
941 target_ulong extramask[TARGET_NSIG_WORDS-1];
942 target_ulong retcode;
943};
944
945struct rt_sigframe
946{
947 struct target_siginfo *pinfo;
948 void *puc;
949 struct target_siginfo info;
950 struct target_ucontext uc;
951 target_ulong retcode;
952};
953
954#define TARGET_CONFIG_CPU_32 1
955
956/*
957 * For ARM syscalls, we encode the syscall number into the instruction.
958 */
959#define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
960#define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
961
962/*
963 * For Thumb syscalls, we pass the syscall number via r7. We therefore
964 * need two 16-bit instructions.
965 */
966#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
967#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
968
969static const target_ulong retcodes[4] = {
970 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
971 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
972};
973
974
975#define __put_user_error(x,p,e) __put_user(x, p)
976#define __get_user_error(x,p,e) __get_user(x, p)
977
978static inline int valid_user_regs(CPUState *regs)
979{
980 return 1;
981}
982
983static int
984setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
985 CPUState *env, unsigned long mask)
986{
987 int err = 0;
988
989 __put_user_error(env->regs[0], &sc->arm_r0, err);
990 __put_user_error(env->regs[1], &sc->arm_r1, err);
991 __put_user_error(env->regs[2], &sc->arm_r2, err);
992 __put_user_error(env->regs[3], &sc->arm_r3, err);
993 __put_user_error(env->regs[4], &sc->arm_r4, err);
994 __put_user_error(env->regs[5], &sc->arm_r5, err);
995 __put_user_error(env->regs[6], &sc->arm_r6, err);
996 __put_user_error(env->regs[7], &sc->arm_r7, err);
997 __put_user_error(env->regs[8], &sc->arm_r8, err);
998 __put_user_error(env->regs[9], &sc->arm_r9, err);
999 __put_user_error(env->regs[10], &sc->arm_r10, err);
1000 __put_user_error(env->regs[11], &sc->arm_fp, err);
1001 __put_user_error(env->regs[12], &sc->arm_ip, err);
1002 __put_user_error(env->regs[13], &sc->arm_sp, err);
1003 __put_user_error(env->regs[14], &sc->arm_lr, err);
1004 __put_user_error(env->regs[15], &sc->arm_pc, err);
1005#ifdef TARGET_CONFIG_CPU_32
1006 __put_user_error(env->cpsr, &sc->arm_cpsr, err);
1007#endif
1008
1009 __put_user_error(/* current->thread.trap_no */ 0, &sc->trap_no, err);
1010 __put_user_error(/* current->thread.error_code */ 0, &sc->error_code, err);
1011 __put_user_error(/* current->thread.address */ 0, &sc->fault_address, err);
1012 __put_user_error(mask, &sc->oldmask, err);
1013
1014 return err;
1015}
1016
1017static inline void *
1018get_sigframe(struct emulated_sigaction *ka, CPUState *regs, int framesize)
1019{
1020 unsigned long sp = regs->regs[13];
1021
1022#if 0
1023 /*
1024 * This is the X/Open sanctioned signal stack switching.
1025 */
1026 if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
1027 sp = current->sas_ss_sp + current->sas_ss_size;
1028#endif
1029 /*
1030 * ATPCS B01 mandates 8-byte alignment
1031 */
1032 return (void *)((sp - framesize) & ~7);
1033}
1034
1035static int
1036setup_return(CPUState *env, struct emulated_sigaction *ka,
1037 target_ulong *rc, void *frame, int usig)
1038{
1039 target_ulong handler = (target_ulong)ka->sa._sa_handler;
1040 target_ulong retcode;
1041 int thumb = 0;
1042#if defined(TARGET_CONFIG_CPU_32)
1043 target_ulong cpsr = env->cpsr;
1044
1045#if 0
1046 /*
1047 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
1048 */
1049 if (ka->sa.sa_flags & SA_THIRTYTWO)
1050 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
1051
1052#ifdef CONFIG_ARM_THUMB
1053 if (elf_hwcap & HWCAP_THUMB) {
1054 /*
1055 * The LSB of the handler determines if we're going to
1056 * be using THUMB or ARM mode for this signal handler.
1057 */
1058 thumb = handler & 1;
1059
1060 if (thumb)
1061 cpsr |= T_BIT;
1062 else
1063 cpsr &= ~T_BIT;
1064 }
1065#endif
1066#endif
1067#endif /* TARGET_CONFIG_CPU_32 */
1068
1069 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
1070 retcode = (target_ulong)ka->sa.sa_restorer;
1071 } else {
1072 unsigned int idx = thumb;
1073
1074 if (ka->sa.sa_flags & TARGET_SA_SIGINFO)
1075 idx += 2;
1076
1077 if (__put_user(retcodes[idx], rc))
1078 return 1;
1079#if 0
1080 flush_icache_range((target_ulong)rc,
1081 (target_ulong)(rc + 1));
1082#endif
1083 retcode = ((target_ulong)rc) + thumb;
1084 }
1085
1086 env->regs[0] = usig;
1087 env->regs[13] = (target_ulong)frame;
1088 env->regs[14] = retcode;
1089 env->regs[15] = handler & (thumb ? ~1 : ~3);
1090
1091#ifdef TARGET_CONFIG_CPU_32
1092 env->cpsr = cpsr;
1093#endif
1094
1095 return 0;
1096}
1097
1098static void setup_frame(int usig, struct emulated_sigaction *ka,
1099 target_sigset_t *set, CPUState *regs)
1100{
1101 struct sigframe *frame = get_sigframe(ka, regs, sizeof(*frame));
9231944d 1102 int i, err = 0;
43fff238
FB		 1103
1104 err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]);
1105
9231944d
FB		 1106 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1107 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1108 return;
43fff238
FB		 1109 }
1110
1111 if (err == 0)
1112 err = setup_return(regs, ka, &frame->retcode, frame, usig);
1113 // return err;
1114}
1115
1116static void setup_rt_frame(int usig, struct emulated_sigaction *ka,
1117 target_siginfo_t *info,
1118 target_sigset_t *set, CPUState *env)
1119{
1120 struct rt_sigframe *frame = get_sigframe(ka, env, sizeof(*frame));
9231944d 1121 int i, err = 0;
43fff238 1122
43fff238 1123 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
edf779ff
FB		 1124 return /* 1 */;
1125
43fff238
FB		 1126 __put_user_error(&frame->info, (target_ulong *)&frame->pinfo, err);
1127 __put_user_error(&frame->uc, (target_ulong *)&frame->puc, err);
1128 err |= copy_siginfo_to_user(&frame->info, info);
1129
1130 /* Clear all the bits of the ucontext we don't use. */
1131 err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
1132
b8076a74 1133 err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/
43fff238 1134 env, set->sig[0]);
9231944d 1135 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 1136 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
9231944d
FB		 1137 return;
1138 }
43fff238
FB		 1139
1140 if (err == 0)
1141 err = setup_return(env, ka, &frame->retcode, frame, usig);
1142
1143 if (err == 0) {
1144 /*
1145 * For realtime signals we must also set the second and third
1146 * arguments for the signal handler.
1147 * -- Peter Maydell <[email protected]> 2000-12-06
1148 */
1149 env->regs[1] = (target_ulong)frame->pinfo;
1150 env->regs[2] = (target_ulong)frame->puc;
1151 }
1152
1153 // return err;
1154}
1155
1156static int
1157restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1158{
1159 int err = 0;
1160
1161 __get_user_error(env->regs[0], &sc->arm_r0, err);
1162 __get_user_error(env->regs[1], &sc->arm_r1, err);
1163 __get_user_error(env->regs[2], &sc->arm_r2, err);
1164 __get_user_error(env->regs[3], &sc->arm_r3, err);
1165 __get_user_error(env->regs[4], &sc->arm_r4, err);
1166 __get_user_error(env->regs[5], &sc->arm_r5, err);
1167 __get_user_error(env->regs[6], &sc->arm_r6, err);
1168 __get_user_error(env->regs[7], &sc->arm_r7, err);
1169 __get_user_error(env->regs[8], &sc->arm_r8, err);
1170 __get_user_error(env->regs[9], &sc->arm_r9, err);
1171 __get_user_error(env->regs[10], &sc->arm_r10, err);
1172 __get_user_error(env->regs[11], &sc->arm_fp, err);
1173 __get_user_error(env->regs[12], &sc->arm_ip, err);
1174 __get_user_error(env->regs[13], &sc->arm_sp, err);
1175 __get_user_error(env->regs[14], &sc->arm_lr, err);
1176 __get_user_error(env->regs[15], &sc->arm_pc, err);
1177#ifdef TARGET_CONFIG_CPU_32
1178 __get_user_error(env->cpsr, &sc->arm_cpsr, err);
1179#endif
1180
1181 err |= !valid_user_regs(env);
1182
1183 return err;
1184}
1185
1186long do_sigreturn(CPUState *env)
1187{
1188 struct sigframe *frame;
1189 target_sigset_t set;
1190 sigset_t host_set;
9231944d 1191 int i;
43fff238
FB		 1192
1193 /*
1194 * Since we stacked the signal on a 64-bit boundary,
1195 * then 'sp' should be word aligned here. If it's
1196 * not, then the user is trying to mess with us.
1197 */
1198 if (env->regs[13] & 7)
1199 goto badframe;
1200
1201 frame = (struct sigframe *)env->regs[13];
1202
1203#if 0
1204 if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1205 goto badframe;
1206#endif
9231944d
FB		 1207 if (__get_user(set.sig[0], &frame->sc.oldmask))
1208 goto badframe;
1209 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1210 if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1211 goto badframe;
1212 }
43fff238 1213
9231944d 1214 target_to_host_sigset_internal(&host_set, &set);
43fff238
FB		 1215 sigprocmask(SIG_SETMASK, &host_set, NULL);
1216
1217 if (restore_sigcontext(env, &frame->sc))
1218 goto badframe;
1219
1220#if 0
1221 /* Send SIGTRAP if we're single-stepping */
1222 if (ptrace_cancel_bpt(current))
1223 send_sig(SIGTRAP, current, 1);
1224#endif
1225 return env->regs[0];
1226
1227badframe:
1228 force_sig(SIGSEGV /* , current */);
1229 return 0;
1230}
1231
1232long do_rt_sigreturn(CPUState *env)
1233{
1234 struct rt_sigframe *frame;
43fff238
FB		 1235 sigset_t host_set;
1236
1237 /*
1238 * Since we stacked the signal on a 64-bit boundary,
1239 * then 'sp' should be word aligned here. If it's
1240 * not, then the user is trying to mess with us.
1241 */
1242 if (env->regs[13] & 7)
1243 goto badframe;
1244
1245 frame = (struct rt_sigframe *)env->regs[13];
1246
1247#if 0
1248 if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1249 goto badframe;
1250#endif
b8076a74 1251 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
43fff238
FB		 1252 sigprocmask(SIG_SETMASK, &host_set, NULL);
1253
b8076a74 1254 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
43fff238
FB		 1255 goto badframe;
1256
1257#if 0
1258 /* Send SIGTRAP if we're single-stepping */
1259 if (ptrace_cancel_bpt(current))
1260 send_sig(SIGTRAP, current, 1);
1261#endif
1262 return env->regs[0];
1263
1264badframe:
1265 force_sig(SIGSEGV /* , current */);
1266 return 0;
1267}
1268
6d5e216d 1269#elif defined(TARGET_SPARC)
80a9d035 1270
6d5e216d
FB		 1271#define __SUNOS_MAXWIN 31
1272
1273/* This is what SunOS does, so shall I. */
1274struct target_sigcontext {
1275 target_ulong sigc_onstack; /* state to restore */
1276
1277 target_ulong sigc_mask; /* sigmask to restore */
1278 target_ulong sigc_sp; /* stack pointer */
1279 target_ulong sigc_pc; /* program counter */
1280 target_ulong sigc_npc; /* next program counter */
1281 target_ulong sigc_psr; /* for condition codes etc */
1282 target_ulong sigc_g1; /* User uses these two registers */
1283 target_ulong sigc_o0; /* within the trampoline code. */
1284
1285 /* Now comes information regarding the users window set
1286 * at the time of the signal.
1287 */
1288 target_ulong sigc_oswins; /* outstanding windows */
1289
1290 /* stack ptrs for each regwin buf */
1291 char *sigc_spbuf[__SUNOS_MAXWIN];
1292
1293 /* Windows to restore after signal */
1294 struct {
1295 target_ulong locals[8];
1296 target_ulong ins[8];
1297 } sigc_wbuf[__SUNOS_MAXWIN];
1298};
1299/* A Sparc stack frame */
1300struct sparc_stackf {
1301 target_ulong locals[8];
1302 target_ulong ins[6];
1303 struct sparc_stackf *fp;
1304 target_ulong callers_pc;
1305 char *structptr;
1306 target_ulong xargs[6];
1307 target_ulong xxargs[1];
1308};
1309
1310typedef struct {
1311 struct {
1312 target_ulong psr;
1313 target_ulong pc;
1314 target_ulong npc;
1315 target_ulong y;
1316 target_ulong u_regs[16]; /* globals and ins */
1317 } si_regs;
1318 int si_mask;
1319} __siginfo_t;
1320
1321typedef struct {
1322 unsigned long si_float_regs [32];
1323 unsigned long si_fsr;
1324 unsigned long si_fpqdepth;
1325 struct {
1326 unsigned long *insn_addr;
1327 unsigned long insn;
1328 } si_fpqueue [16];
1329} __siginfo_fpu_t;
1330
1331
1332struct target_signal_frame {
1333 struct sparc_stackf ss;
1334 __siginfo_t info;
1335 __siginfo_fpu_t *fpu_save;
1336 target_ulong insns[2] __attribute__ ((aligned (8)));
1337 target_ulong extramask[TARGET_NSIG_WORDS - 1];
1338 target_ulong extra_size; /* Should be 0 */
1339 __siginfo_fpu_t fpu_state;
1340};
1341struct target_rt_signal_frame {
1342 struct sparc_stackf ss;
1343 siginfo_t info;
1344 target_ulong regs[20];
1345 sigset_t mask;
1346 __siginfo_fpu_t *fpu_save;
1347 unsigned int insns[2];
1348 stack_t stack;
1349 unsigned int extra_size; /* Should be 0 */
1350 __siginfo_fpu_t fpu_state;
1351};
1352
e80cfcfc
FB		 1353#define UREG_O0 16
1354#define UREG_O6 22
1355#define UREG_I0 0
1356#define UREG_I1 1
1357#define UREG_I2 2
1358#define UREG_I6 6
1359#define UREG_I7 7
1360#define UREG_L0 8
6d5e216d
FB		 1361#define UREG_FP UREG_I6
1362#define UREG_SP UREG_O6
1363
1364static inline void *get_sigframe(struct emulated_sigaction *sa, CPUState *env, unsigned long framesize)
1365{
1366 unsigned long sp;
1367
1368 sp = env->regwptr[UREG_FP];
1369#if 0
1370
1371 /* This is the X/Open sanctioned signal stack switching. */
1372 if (sa->sa_flags & TARGET_SA_ONSTACK) {
1373 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
1374 sp = current->sas_ss_sp + current->sas_ss_size;
1375 }
1376#endif
1377 return (void *)(sp - framesize);
1378}
1379
1380static int
1381setup___siginfo(__siginfo_t *si, CPUState *env, target_ulong mask)
1382{
1383 int err = 0, i;
1384
6d5e216d 1385 err |= __put_user(env->psr, &si->si_regs.psr);
6d5e216d
FB		 1386 err |= __put_user(env->pc, &si->si_regs.pc);
1387 err |= __put_user(env->npc, &si->si_regs.npc);
1388 err |= __put_user(env->y, &si->si_regs.y);
a315a145 1389 for (i=0; i < 8; i++) {
6d5e216d
FB		 1390 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1391 }
a315a145 1392 for (i=0; i < 8; i++) {
e80cfcfc 1393 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
6d5e216d 1394 }
6d5e216d
FB		 1395 err |= __put_user(mask, &si->si_mask);
1396 return err;
1397}
e80cfcfc 1398
80a9d035 1399#if 0
6d5e216d
FB		 1400static int
1401setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1402 CPUState *env, unsigned long mask)
1403{
1404 int err = 0;
1405
1406 err |= __put_user(mask, &sc->sigc_mask);
1407 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1408 err |= __put_user(env->pc, &sc->sigc_pc);
1409 err |= __put_user(env->npc, &sc->sigc_npc);
1410 err |= __put_user(env->psr, &sc->sigc_psr);
1411 err |= __put_user(env->gregs[1], &sc->sigc_g1);
1412 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1413
1414 return err;
1415}
80a9d035 1416#endif
6d5e216d
FB		 1417#define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1418
1419static void setup_frame(int sig, struct emulated_sigaction *ka,
1420 target_sigset_t *set, CPUState *env)
1421{
1422 struct target_signal_frame *sf;
1423 int sigframe_size, err, i;
1424
1425 /* 1. Make sure everything is clean */
1426 //synchronize_user_stack();
1427
1428 sigframe_size = NF_ALIGNEDSZ;
1429
1430 sf = (struct target_signal_frame *)
1431 get_sigframe(ka, env, sigframe_size);
1432
e80cfcfc 1433 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
6d5e216d
FB		 1434#if 0
1435 if (invalid_frame_pointer(sf, sigframe_size))
1436 goto sigill_and_return;
1437#endif
1438 /* 2. Save the current process state */
1439 err = setup___siginfo(&sf->info, env, set->sig[0]);
1440 err |= __put_user(0, &sf->extra_size);
1441
1442 //err |= save_fpu_state(regs, &sf->fpu_state);
1443 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1444
1445 err |= __put_user(set->sig[0], &sf->info.si_mask);
1446 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1447 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1448 }
1449
a315a145 1450 for (i = 0; i < 8; i++) {
e80cfcfc 1451 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
6d5e216d 1452 }
a315a145 1453 for (i = 0; i < 8; i++) {
e80cfcfc 1454 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
6d5e216d 1455 }
6d5e216d
FB		 1456 if (err)
1457 goto sigsegv;
1458
1459 /* 3. signal handler back-trampoline and parameters */
1460 env->regwptr[UREG_FP] = (target_ulong) sf;
1461 env->regwptr[UREG_I0] = sig;
1462 env->regwptr[UREG_I1] = (target_ulong) &sf->info;
1463 env->regwptr[UREG_I2] = (target_ulong) &sf->info;
1464
1465 /* 4. signal handler */
1466 env->pc = (unsigned long) ka->sa._sa_handler;
1467 env->npc = (env->pc + 4);
1468 /* 5. return to kernel instructions */
1469 if (ka->sa.sa_restorer)
1470 env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer;
1471 else {
1472 env->regwptr[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
1473
1474 /* mov __NR_sigreturn, %g1 */
1475 err |= __put_user(0x821020d8, &sf->insns[0]);
1476
1477 /* t 0x10 */
1478 err |= __put_user(0x91d02010, &sf->insns[1]);
1479 if (err)
1480 goto sigsegv;
1481
1482 /* Flush instruction space. */
1483 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
80a9d035 1484 // tb_flush(env);
6d5e216d
FB		 1485 }
1486 return;
1487
80a9d035 1488 //sigill_and_return:
6d5e216d
FB		 1489 force_sig(TARGET_SIGILL);
1490sigsegv:
e80cfcfc 1491 //fprintf(stderr, "force_sig\n");
6d5e216d
FB		 1492 force_sig(TARGET_SIGSEGV);
1493}
1494static inline int
1495restore_fpu_state(CPUState *env, __siginfo_fpu_t *fpu)
1496{
1497 int err;
1498#if 0
1499#ifdef CONFIG_SMP
1500 if (current->flags & PF_USEDFPU)
1501 regs->psr &= ~PSR_EF;
1502#else
1503 if (current == last_task_used_math) {
1504 last_task_used_math = 0;
1505 regs->psr &= ~PSR_EF;
1506 }
1507#endif
1508 current->used_math = 1;
1509 current->flags &= ~PF_USEDFPU;
1510#endif
1511#if 0
1512 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1513 return -EFAULT;
1514#endif
1515
1516 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1517 (sizeof(unsigned long) * 32));
1518 err |= __get_user(env->fsr, &fpu->si_fsr);
1519#if 0
1520 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1521 if (current->thread.fpqdepth != 0)
1522 err |= __copy_from_user(&current->thread.fpqueue[0],
1523 &fpu->si_fpqueue[0],
1524 ((sizeof(unsigned long) +
1525 (sizeof(unsigned long *)))*16));
1526#endif
1527 return err;
1528}
1529
1530
1531static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1532 target_siginfo_t *info,
1533 target_sigset_t *set, CPUState *env)
1534{
1535 fprintf(stderr, "setup_rt_frame: not implemented\n");
1536}
1537
1538long do_sigreturn(CPUState *env)
1539{
1540 struct target_signal_frame *sf;
e80cfcfc 1541 uint32_t up_psr, pc, npc;
6d5e216d 1542 target_sigset_t set;
e80cfcfc 1543 sigset_t host_set;
80a9d035 1544 target_ulong fpu_save;
e80cfcfc 1545 int err, i;
6d5e216d 1546
e80cfcfc 1547 sf = (struct target_signal_frame *) env->regwptr[UREG_FP];
80a9d035 1548#if 0
e80cfcfc
FB		 1549 fprintf(stderr, "sigreturn\n");
1550 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
80a9d035 1551#endif
e80cfcfc 1552 //cpu_dump_state(env, stderr, fprintf, 0);
6d5e216d
FB		 1553
1554 /* 1. Make sure we are not getting garbage from the user */
1555#if 0
1556 if (verify_area (VERIFY_READ, sf, sizeof (*sf)))
1557 goto segv_and_exit;
1558#endif
1559
1560 if (((uint) sf) & 3)
1561 goto segv_and_exit;
1562
1563 err = __get_user(pc, &sf->info.si_regs.pc);
1564 err |= __get_user(npc, &sf->info.si_regs.npc);
1565
6d5e216d
FB		 1566 if ((pc | npc) & 3)
1567 goto segv_and_exit;
1568
1569 /* 2. Restore the state */
e80cfcfc
FB		 1570 err |= __get_user(up_psr, &sf->info.si_regs.psr);
1571
6d5e216d 1572 /* User can only change condition codes and FPU enabling in %psr. */
a315a145
FB		 1573 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1574 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1575
1576 env->pc = pc;
1577 env->npc = npc;
e80cfcfc 1578 err |= __get_user(env->y, &sf->info.si_regs.y);
a315a145 1579 for (i=0; i < 8; i++) {
e80cfcfc
FB		 1580 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1581 }
a315a145 1582 for (i=0; i < 8; i++) {
e80cfcfc
FB		 1583 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1584 }
6d5e216d 1585
80a9d035 1586 err |= __get_user(fpu_save, (target_ulong *)&sf->fpu_save);
6d5e216d 1587
e80cfcfc
FB		 1588 //if (fpu_save)
1589 // err |= restore_fpu_state(env, fpu_save);
6d5e216d
FB		 1590
1591 /* This is pretty much atomic, no amount locking would prevent
1592 * the races which exist anyways.
1593 */
1594 err |= __get_user(set.sig[0], &sf->info.si_mask);
e80cfcfc
FB		 1595 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1596 err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1597 }
1598
1599 target_to_host_sigset_internal(&host_set, &set);
1600 sigprocmask(SIG_SETMASK, &host_set, NULL);
6d5e216d
FB		 1601
1602 if (err)
1603 goto segv_and_exit;
1604
6d5e216d
FB		 1605 return env->regwptr[0];
1606
1607segv_and_exit:
1608 force_sig(TARGET_SIGSEGV);
1609}
1610
1611long do_rt_sigreturn(CPUState *env)
1612{
1613 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1614 return -ENOSYS;
1615}
1616
1617
b346ff46
FB		 1618#else
1619
1620static void setup_frame(int sig, struct emulated_sigaction *ka,
1621 target_sigset_t *set, CPUState *env)
1622{
1623 fprintf(stderr, "setup_frame: not implemented\n");
1624}
1625
1626static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1627 target_siginfo_t *info,
1628 target_sigset_t *set, CPUState *env)
1629{
1630 fprintf(stderr, "setup_rt_frame: not implemented\n");
1631}
1632
1633long do_sigreturn(CPUState *env)
1634{
1635 fprintf(stderr, "do_sigreturn: not implemented\n");
1636 return -ENOSYS;
1637}
1638
1639long do_rt_sigreturn(CPUState *env)
1640{
1641 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1642 return -ENOSYS;
1643}
1644
66fb9763
FB		 1645#endif
1646
1647void process_pending_signals(void *cpu_env)
1648{
1649 int sig;
1650 target_ulong handler;
9de5e440
FB		 1651 sigset_t set, old_set;
1652 target_sigset_t target_old_set;
66fb9763
FB		 1653 struct emulated_sigaction *k;
1654 struct sigqueue *q;
1655
31e31b8a
FB		 1656 if (!signal_pending)
1657 return;
1658
66fb9763
FB		 1659 k = sigact_table;
1660 for(sig = 1; sig <= TARGET_NSIG; sig++) {
1661 if (k->pending)
31e31b8a 1662 goto handle_signal;
66fb9763 1663 k++;
31e31b8a
FB		 1664 }
1665 /* if no signal is pending, just return */
1666 signal_pending = 0;
1667 return;
66fb9763 1668
31e31b8a 1669 handle_signal:
66fb9763 1670#ifdef DEBUG_SIGNAL
bc8a22cc 1671 fprintf(stderr, "qemu: process signal %d\n", sig);
66fb9763
FB		 1672#endif
1673 /* dequeue signal */
1674 q = k->first;
1675 k->first = q->next;
1676 if (!k->first)
1677 k->pending = 0;
1678
1679 handler = k->sa._sa_handler;
1680 if (handler == TARGET_SIG_DFL) {
1681 /* default handler : ignore some signal. The other are fatal */
1682 if (sig != TARGET_SIGCHLD &&
1683 sig != TARGET_SIGURG &&
1684 sig != TARGET_SIGWINCH) {
1685 force_sig(sig);
1686 }
1687 } else if (handler == TARGET_SIG_IGN) {
1688 /* ignore sig */
1689 } else if (handler == TARGET_SIG_ERR) {
1690 force_sig(sig);
1691 } else {
9de5e440
FB		 1692 /* compute the blocked signals during the handler execution */
1693 target_to_host_sigset(&set, &k->sa.sa_mask);
1694 /* SA_NODEFER indicates that the current signal should not be
1695 blocked during the handler */
1696 if (!(k->sa.sa_flags & TARGET_SA_NODEFER))
1697 sigaddset(&set, target_to_host_signal(sig));
1698
1699 /* block signals in the handler using Linux */
1700 sigprocmask(SIG_BLOCK, &set, &old_set);
1701 /* save the previous blocked signal state to restore it at the
1702 end of the signal execution (see do_sigreturn) */
9231944d 1703 host_to_target_sigset_internal(&target_old_set, &old_set);
9de5e440 1704
bc8a22cc
FB		 1705 /* if the CPU is in VM86 mode, we restore the 32 bit values */
1706#ifdef TARGET_I386
1707 {
1708 CPUX86State *env = cpu_env;
1709 if (env->eflags & VM_MASK)
1710 save_v86_state(env);
1711 }
1712#endif
9de5e440 1713 /* prepare the stack frame of the virtual CPU */
66fb9763 1714 if (k->sa.sa_flags & TARGET_SA_SIGINFO)
9de5e440 1715 setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env);
66fb9763 1716 else
9de5e440 1717 setup_frame(sig, k, &target_old_set, cpu_env);
66fb9763
FB		 1718 if (k->sa.sa_flags & TARGET_SA_RESETHAND)
1719 k->sa._sa_handler = TARGET_SIG_DFL;
31e31b8a 1720 }
66fb9763
FB		 1721 if (q != &k->info)
1722 free_sigqueue(q);
1723}
31e31b8a
FB		 1724
1725
Empty description
This page took 0.341683 seconds and 4 git commands to generate.