]> git.ipfire.org Git - thirdparty/qemu.git/blame - linux-user/signal.c
projects / thirdparty / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Reduce variable shadowing, by Stefan Weil.
[thirdparty/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++)
53a5960a 138 d->sig[i] = tswapl(d1.sig[i]);
9231944d
FB		 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++)
53a5960a 171 s1.sig[i] = tswapl(s->sig[i]);
9231944d
FB		 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 424
0aeaa8ce 425 if (sig < 1 || sig > TARGET_NSIG || sig == SIGKILL || sig == SIGSTOP)
66fb9763
FB		 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);
388bb21a
TS		 435#if !defined(TARGET_MIPS)
436 oact->sa_restorer = tswapl(k->sa.sa_restorer);
437#endif
66fb9763
FB		 438 oact->sa_mask = k->sa.sa_mask;
439 }
440 if (act) {
441 k->sa._sa_handler = tswapl(act->_sa_handler);
442 k->sa.sa_flags = tswapl(act->sa_flags);
388bb21a
TS		 443#if !defined(TARGET_MIPS)
444 k->sa.sa_restorer = tswapl(act->sa_restorer);
445#endif
66fb9763 446 k->sa.sa_mask = act->sa_mask;
773b93ee
FB		 447
448 /* we update the host linux signal state */
449 host_sig = target_to_host_signal(sig);
450 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
451 sigfillset(&act1.sa_mask);
452 act1.sa_flags = SA_SIGINFO;
453 if (k->sa.sa_flags & TARGET_SA_RESTART)
454 act1.sa_flags |= SA_RESTART;
455 /* NOTE: it is important to update the host kernel signal
456 ignore state to avoid getting unexpected interrupted
457 syscalls */
458 if (k->sa._sa_handler == TARGET_SIG_IGN) {
459 act1.sa_sigaction = (void *)SIG_IGN;
460 } else if (k->sa._sa_handler == TARGET_SIG_DFL) {
461 act1.sa_sigaction = (void *)SIG_DFL;
462 } else {
463 act1.sa_sigaction = host_signal_handler;
464 }
465 sigaction(host_sig, &act1, NULL);
466 }
66fb9763
FB		 467 }
468 return 0;
469}
470
43fff238
FB		 471#ifndef offsetof
472#define offsetof(type, field) ((size_t) &((type *)0)->field)
473#endif
474
475static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
476 const target_siginfo_t *info)
477{
478 tswap_siginfo(tinfo, info);
479 return 0;
480}
481
66fb9763
FB		 482#ifdef TARGET_I386
483
484/* from the Linux kernel */
485
486struct target_fpreg {
487 uint16_t significand[4];
488 uint16_t exponent;
489};
490
491struct target_fpxreg {
492 uint16_t significand[4];
493 uint16_t exponent;
494 uint16_t padding[3];
495};
496
497struct target_xmmreg {
498 target_ulong element[4];
499};
500
501struct target_fpstate {
502 /* Regular FPU environment */
503 target_ulong cw;
504 target_ulong sw;
505 target_ulong tag;
506 target_ulong ipoff;
507 target_ulong cssel;
508 target_ulong dataoff;
509 target_ulong datasel;
510 struct target_fpreg _st[8];
511 uint16_t status;
512 uint16_t magic; /* 0xffff = regular FPU data only */
513
514 /* FXSR FPU environment */
515 target_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
516 target_ulong mxcsr;
517 target_ulong reserved;
518 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
519 struct target_xmmreg _xmm[8];
520 target_ulong padding[56];
521};
522
523#define X86_FXSR_MAGIC 0x0000
524
525struct target_sigcontext {
526 uint16_t gs, __gsh;
527 uint16_t fs, __fsh;
528 uint16_t es, __esh;
529 uint16_t ds, __dsh;
530 target_ulong edi;
531 target_ulong esi;
532 target_ulong ebp;
533 target_ulong esp;
534 target_ulong ebx;
535 target_ulong edx;
536 target_ulong ecx;
537 target_ulong eax;
538 target_ulong trapno;
539 target_ulong err;
540 target_ulong eip;
541 uint16_t cs, __csh;
542 target_ulong eflags;
543 target_ulong esp_at_signal;
544 uint16_t ss, __ssh;
545 target_ulong fpstate; /* pointer */
546 target_ulong oldmask;
547 target_ulong cr2;
548};
549
550typedef struct target_sigaltstack {
551 target_ulong ss_sp;
552 int ss_flags;
553 target_ulong ss_size;
554} target_stack_t;
555
556struct target_ucontext {
b8076a74
FB		 557 target_ulong tuc_flags;
558 target_ulong tuc_link;
559 target_stack_t tuc_stack;
560 struct target_sigcontext tuc_mcontext;
561 target_sigset_t tuc_sigmask; /* mask last for extensibility */
66fb9763
FB		 562};
563
564struct sigframe
565{
566 target_ulong pretcode;
567 int sig;
568 struct target_sigcontext sc;
569 struct target_fpstate fpstate;
570 target_ulong extramask[TARGET_NSIG_WORDS-1];
571 char retcode[8];
572};
573
574struct rt_sigframe
575{
576 target_ulong pretcode;
577 int sig;
578 target_ulong pinfo;
579 target_ulong puc;
580 struct target_siginfo info;
581 struct target_ucontext uc;
582 struct target_fpstate fpstate;
583 char retcode[8];
584};
585
586/*
587 * Set up a signal frame.
588 */
589
66fb9763
FB		 590/* XXX: save x87 state */
591static int
592setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
593 CPUX86State *env, unsigned long mask)
594{
595 int err = 0;
596
a52c757c
FB		 597 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
598 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
599 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
600 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
66fb9763
FB		 601 err |= __put_user(env->regs[R_EDI], &sc->edi);
602 err |= __put_user(env->regs[R_ESI], &sc->esi);
603 err |= __put_user(env->regs[R_EBP], &sc->ebp);
604 err |= __put_user(env->regs[R_ESP], &sc->esp);
605 err |= __put_user(env->regs[R_EBX], &sc->ebx);
606 err |= __put_user(env->regs[R_EDX], &sc->edx);
607 err |= __put_user(env->regs[R_ECX], &sc->ecx);
608 err |= __put_user(env->regs[R_EAX], &sc->eax);
66099dd9
FB		 609 err |= __put_user(env->exception_index, &sc->trapno);
610 err |= __put_user(env->error_code, &sc->err);
66fb9763 611 err |= __put_user(env->eip, &sc->eip);
a52c757c 612 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
66fb9763
FB		 613 err |= __put_user(env->eflags, &sc->eflags);
614 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
a52c757c 615 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
ed2dcdf6
FB		 616
617 cpu_x86_fsave(env, (void *)fpstate, 1);
618 fpstate->status = fpstate->sw;
619 err |= __put_user(0xffff, &fpstate->magic);
620 err |= __put_user(fpstate, &sc->fpstate);
621
66fb9763
FB		 622 /* non-iBCS2 extensions.. */
623 err |= __put_user(mask, &sc->oldmask);
a52c757c 624 err |= __put_user(env->cr[2], &sc->cr2);
66fb9763 625 return err;
31e31b8a
FB		 626}
627
66fb9763
FB		 628/*
629 * Determine which stack to use..
630 */
31e31b8a 631
66fb9763
FB		 632static inline void *
633get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
31e31b8a 634{
66fb9763
FB		 635 unsigned long esp;
636
637 /* Default to using normal stack */
638 esp = env->regs[R_ESP];
639#if 0
640 /* This is the X/Open sanctioned signal stack switching. */
641 if (ka->sa.sa_flags & SA_ONSTACK) {
642 if (sas_ss_flags(esp) == 0)
643 esp = current->sas_ss_sp + current->sas_ss_size;
644 }
645
646 /* This is the legacy signal stack switching. */
a52c757c 647 else
66fb9763 648#endif
a52c757c
FB		 649 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
650 !(ka->sa.sa_flags & TARGET_SA_RESTORER) &&
651 ka->sa.sa_restorer) {
652 esp = (unsigned long) ka->sa.sa_restorer;
653 }
53a5960a 654 return g2h((esp - frame_size) & -8ul);
66fb9763
FB		 655}
656
66fb9763
FB		 657static void setup_frame(int sig, struct emulated_sigaction *ka,
658 target_sigset_t *set, CPUX86State *env)
659{
660 struct sigframe *frame;
9231944d 661 int i, err = 0;
66fb9763
FB		 662
663 frame = get_sigframe(ka, env, sizeof(*frame));
664
66fb9763
FB		 665 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
666 goto give_sigsegv;
66fb9763
FB		 667 err |= __put_user((/*current->exec_domain
668 && current->exec_domain->signal_invmap
669 && sig < 32
670 ? current->exec_domain->signal_invmap[sig]
671 : */ sig),
672 &frame->sig);
673 if (err)
674 goto give_sigsegv;
675
676 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0]);
677 if (err)
678 goto give_sigsegv;
679
9231944d
FB		 680 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
681 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
682 goto give_sigsegv;
683 }
66fb9763
FB		 684
685 /* Set up to return from userspace. If provided, use a stub
686 already in userspace. */
687 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
688 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
689 } else {
690 err |= __put_user(frame->retcode, &frame->pretcode);
691 /* This is popl %eax ; movl $,%eax ; int $0x80 */
692 err |= __put_user(0xb858, (short *)(frame->retcode+0));
84409ddb
JM		 693#if defined(TARGET_X86_64)
694#warning "Fix this !"
695#else
66fb9763 696 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
84409ddb 697#endif
66fb9763
FB		 698 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
699 }
700
701 if (err)
702 goto give_sigsegv;
703
704 /* Set up registers for signal handler */
53a5960a 705 env->regs[R_ESP] = h2g(frame);
66fb9763
FB		 706 env->eip = (unsigned long) ka->sa._sa_handler;
707
708 cpu_x86_load_seg(env, R_DS, __USER_DS);
709 cpu_x86_load_seg(env, R_ES, __USER_DS);
710 cpu_x86_load_seg(env, R_SS, __USER_DS);
711 cpu_x86_load_seg(env, R_CS, __USER_CS);
712 env->eflags &= ~TF_MASK;
713
714 return;
715
716give_sigsegv:
717 if (sig == TARGET_SIGSEGV)
718 ka->sa._sa_handler = TARGET_SIG_DFL;
719 force_sig(TARGET_SIGSEGV /* , current */);
720}
721
9de5e440
FB		 722static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
723 target_siginfo_t *info,
66fb9763
FB		 724 target_sigset_t *set, CPUX86State *env)
725{
726 struct rt_sigframe *frame;
9231944d 727 int i, err = 0;
66fb9763
FB		 728
729 frame = get_sigframe(ka, env, sizeof(*frame));
730
66fb9763
FB		 731 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
732 goto give_sigsegv;
66fb9763
FB		 733
734 err |= __put_user((/*current->exec_domain
735 && current->exec_domain->signal_invmap
736 && sig < 32
737 ? current->exec_domain->signal_invmap[sig]
738 : */sig),
739 &frame->sig);
740 err |= __put_user((target_ulong)&frame->info, &frame->pinfo);
741 err |= __put_user((target_ulong)&frame->uc, &frame->puc);
742 err |= copy_siginfo_to_user(&frame->info, info);
743 if (err)
744 goto give_sigsegv;
31e31b8a 745
66fb9763 746 /* Create the ucontext. */
b8076a74
FB		 747 err |= __put_user(0, &frame->uc.tuc_flags);
748 err |= __put_user(0, &frame->uc.tuc_link);
749 err |= __put_user(/*current->sas_ss_sp*/ 0,
750 &frame->uc.tuc_stack.ss_sp);
66fb9763 751 err |= __put_user(/* sas_ss_flags(regs->esp) */ 0,
b8076a74
FB		 752 &frame->uc.tuc_stack.ss_flags);
753 err |= __put_user(/* current->sas_ss_size */ 0,
754 &frame->uc.tuc_stack.ss_size);
755 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
66fb9763 756 env, set->sig[0]);
9231944d 757 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 758 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
9231944d
FB		 759 goto give_sigsegv;
760 }
31e31b8a 761
66fb9763
FB		 762 /* Set up to return from userspace. If provided, use a stub
763 already in userspace. */
764 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
765 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
766 } else {
767 err |= __put_user(frame->retcode, &frame->pretcode);
768 /* This is movl $,%eax ; int $0x80 */
769 err |= __put_user(0xb8, (char *)(frame->retcode+0));
770 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
771 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
772 }
773
774 if (err)
775 goto give_sigsegv;
776
777 /* Set up registers for signal handler */
778 env->regs[R_ESP] = (unsigned long) frame;
779 env->eip = (unsigned long) ka->sa._sa_handler;
780
781 cpu_x86_load_seg(env, R_DS, __USER_DS);
782 cpu_x86_load_seg(env, R_ES, __USER_DS);
783 cpu_x86_load_seg(env, R_SS, __USER_DS);
784 cpu_x86_load_seg(env, R_CS, __USER_CS);
785 env->eflags &= ~TF_MASK;
786
787 return;
788
789give_sigsegv:
790 if (sig == TARGET_SIGSEGV)
791 ka->sa._sa_handler = TARGET_SIG_DFL;
792 force_sig(TARGET_SIGSEGV /* , current */);
793}
794
795static int
796restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
797{
798 unsigned int err = 0;
799
66fb9763
FB		 800 cpu_x86_load_seg(env, R_GS, lduw(&sc->gs));
801 cpu_x86_load_seg(env, R_FS, lduw(&sc->fs));
802 cpu_x86_load_seg(env, R_ES, lduw(&sc->es));
803 cpu_x86_load_seg(env, R_DS, lduw(&sc->ds));
804
805 env->regs[R_EDI] = ldl(&sc->edi);
806 env->regs[R_ESI] = ldl(&sc->esi);
807 env->regs[R_EBP] = ldl(&sc->ebp);
808 env->regs[R_ESP] = ldl(&sc->esp);
809 env->regs[R_EBX] = ldl(&sc->ebx);
810 env->regs[R_EDX] = ldl(&sc->edx);
811 env->regs[R_ECX] = ldl(&sc->ecx);
812 env->eip = ldl(&sc->eip);
813
814 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
815 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
816
817 {
818 unsigned int tmpflags;
819 tmpflags = ldl(&sc->eflags);
820 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
821 // regs->orig_eax = -1; /* disable syscall checks */
822 }
823
66fb9763
FB		 824 {
825 struct _fpstate * buf;
ed2dcdf6 826 buf = (void *)ldl(&sc->fpstate);
66fb9763 827 if (buf) {
ed2dcdf6 828#if 0
66fb9763
FB		 829 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
830 goto badframe;
ed2dcdf6
FB		 831#endif
832 cpu_x86_frstor(env, (void *)buf, 1);
66fb9763
FB		 833 }
834 }
ed2dcdf6 835
66fb9763
FB		 836 *peax = ldl(&sc->eax);
837 return err;
838#if 0
839badframe:
840 return 1;
841#endif
842}
843
844long do_sigreturn(CPUX86State *env)
845{
53a5960a 846 struct sigframe *frame = (struct sigframe *)g2h(env->regs[R_ESP] - 8);
66fb9763
FB		 847 target_sigset_t target_set;
848 sigset_t set;
849 int eax, i;
850
447db213
FB		 851#if defined(DEBUG_SIGNAL)
852 fprintf(stderr, "do_sigreturn\n");
853#endif
66fb9763 854 /* set blocked signals */
9231944d
FB		 855 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
856 goto badframe;
857 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
858 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
859 goto badframe;
860 }
66fb9763 861
9231944d 862 target_to_host_sigset_internal(&set, &target_set);
66fb9763
FB		 863 sigprocmask(SIG_SETMASK, &set, NULL);
864
865 /* restore registers */
866 if (restore_sigcontext(env, &frame->sc, &eax))
867 goto badframe;
868 return eax;
869
870badframe:
871 force_sig(TARGET_SIGSEGV);
872 return 0;
873}
874
875long do_rt_sigreturn(CPUX86State *env)
876{
53a5960a 877 struct rt_sigframe *frame = (struct rt_sigframe *)g2h(env->regs[R_ESP] - 4);
66fb9763
FB		 878 sigset_t set;
879 // stack_t st;
880 int eax;
881
882#if 0
883 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
884 goto badframe;
885#endif
b8076a74 886 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
66fb9763
FB		 887 sigprocmask(SIG_SETMASK, &set, NULL);
888
b8076a74 889 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
66fb9763
FB		 890 goto badframe;
891
892#if 0
b8076a74 893 if (__copy_from_user(&st, &frame->uc.tuc_stack, sizeof(st)))
66fb9763
FB		 894 goto badframe;
895 /* It is more difficult to avoid calling this function than to
896 call it and ignore errors. */
897 do_sigaltstack(&st, NULL, regs->esp);
898#endif
899 return eax;
900
901badframe:
902 force_sig(TARGET_SIGSEGV);
903 return 0;
904}
905
43fff238
FB		 906#elif defined(TARGET_ARM)
907
908struct target_sigcontext {
909 target_ulong trap_no;
910 target_ulong error_code;
911 target_ulong oldmask;
912 target_ulong arm_r0;
913 target_ulong arm_r1;
914 target_ulong arm_r2;
915 target_ulong arm_r3;
916 target_ulong arm_r4;
917 target_ulong arm_r5;
918 target_ulong arm_r6;
919 target_ulong arm_r7;
920 target_ulong arm_r8;
921 target_ulong arm_r9;
922 target_ulong arm_r10;
923 target_ulong arm_fp;
924 target_ulong arm_ip;
925 target_ulong arm_sp;
926 target_ulong arm_lr;
927 target_ulong arm_pc;
928 target_ulong arm_cpsr;
929 target_ulong fault_address;
930};
931
932typedef struct target_sigaltstack {
933 target_ulong ss_sp;
934 int ss_flags;
935 target_ulong ss_size;
936} target_stack_t;
937
938struct target_ucontext {
b8076a74
FB		 939 target_ulong tuc_flags;
940 target_ulong tuc_link;
941 target_stack_t tuc_stack;
942 struct target_sigcontext tuc_mcontext;
943 target_sigset_t tuc_sigmask; /* mask last for extensibility */
43fff238
FB		 944};
945
946struct sigframe
947{
948 struct target_sigcontext sc;
949 target_ulong extramask[TARGET_NSIG_WORDS-1];
950 target_ulong retcode;
951};
952
953struct rt_sigframe
954{
955 struct target_siginfo *pinfo;
956 void *puc;
957 struct target_siginfo info;
958 struct target_ucontext uc;
959 target_ulong retcode;
960};
961
962#define TARGET_CONFIG_CPU_32 1
963
964/*
965 * For ARM syscalls, we encode the syscall number into the instruction.
966 */
967#define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
968#define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
969
970/*
971 * For Thumb syscalls, we pass the syscall number via r7. We therefore
972 * need two 16-bit instructions.
973 */
974#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
975#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
976
977static const target_ulong retcodes[4] = {
978 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
979 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
980};
981
982
983#define __put_user_error(x,p,e) __put_user(x, p)
984#define __get_user_error(x,p,e) __get_user(x, p)
985
986static inline int valid_user_regs(CPUState *regs)
987{
988 return 1;
989}
990
991static int
992setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
993 CPUState *env, unsigned long mask)
994{
995 int err = 0;
996
997 __put_user_error(env->regs[0], &sc->arm_r0, err);
998 __put_user_error(env->regs[1], &sc->arm_r1, err);
999 __put_user_error(env->regs[2], &sc->arm_r2, err);
1000 __put_user_error(env->regs[3], &sc->arm_r3, err);
1001 __put_user_error(env->regs[4], &sc->arm_r4, err);
1002 __put_user_error(env->regs[5], &sc->arm_r5, err);
1003 __put_user_error(env->regs[6], &sc->arm_r6, err);
1004 __put_user_error(env->regs[7], &sc->arm_r7, err);
1005 __put_user_error(env->regs[8], &sc->arm_r8, err);
1006 __put_user_error(env->regs[9], &sc->arm_r9, err);
1007 __put_user_error(env->regs[10], &sc->arm_r10, err);
1008 __put_user_error(env->regs[11], &sc->arm_fp, err);
1009 __put_user_error(env->regs[12], &sc->arm_ip, err);
1010 __put_user_error(env->regs[13], &sc->arm_sp, err);
1011 __put_user_error(env->regs[14], &sc->arm_lr, err);
1012 __put_user_error(env->regs[15], &sc->arm_pc, err);
1013#ifdef TARGET_CONFIG_CPU_32
b5ff1b31 1014 __put_user_error(cpsr_read(env), &sc->arm_cpsr, err);
43fff238
FB		 1015#endif
1016
1017 __put_user_error(/* current->thread.trap_no */ 0, &sc->trap_no, err);
1018 __put_user_error(/* current->thread.error_code */ 0, &sc->error_code, err);
1019 __put_user_error(/* current->thread.address */ 0, &sc->fault_address, err);
1020 __put_user_error(mask, &sc->oldmask, err);
1021
1022 return err;
1023}
1024
1025static inline void *
1026get_sigframe(struct emulated_sigaction *ka, CPUState *regs, int framesize)
1027{
1028 unsigned long sp = regs->regs[13];
1029
1030#if 0
1031 /*
1032 * This is the X/Open sanctioned signal stack switching.
1033 */
1034 if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
1035 sp = current->sas_ss_sp + current->sas_ss_size;
1036#endif
1037 /*
1038 * ATPCS B01 mandates 8-byte alignment
1039 */
53a5960a 1040 return g2h((sp - framesize) & ~7);
43fff238
FB		 1041}
1042
1043static int
1044setup_return(CPUState *env, struct emulated_sigaction *ka,
1045 target_ulong *rc, void *frame, int usig)
1046{
1047 target_ulong handler = (target_ulong)ka->sa._sa_handler;
1048 target_ulong retcode;
1049 int thumb = 0;
1050#if defined(TARGET_CONFIG_CPU_32)
b5ff1b31 1051#if 0
43fff238
FB		 1052 target_ulong cpsr = env->cpsr;
1053
43fff238
FB		 1054 /*
1055 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
1056 */
1057 if (ka->sa.sa_flags & SA_THIRTYTWO)
1058 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
1059
1060#ifdef CONFIG_ARM_THUMB
1061 if (elf_hwcap & HWCAP_THUMB) {
1062 /*
1063 * The LSB of the handler determines if we're going to
1064 * be using THUMB or ARM mode for this signal handler.
1065 */
1066 thumb = handler & 1;
1067
1068 if (thumb)
1069 cpsr |= T_BIT;
1070 else
1071 cpsr &= ~T_BIT;
1072 }
1073#endif
1074#endif
1075#endif /* TARGET_CONFIG_CPU_32 */
1076
1077 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
1078 retcode = (target_ulong)ka->sa.sa_restorer;
1079 } else {
1080 unsigned int idx = thumb;
1081
1082 if (ka->sa.sa_flags & TARGET_SA_SIGINFO)
1083 idx += 2;
1084
1085 if (__put_user(retcodes[idx], rc))
1086 return 1;
1087#if 0
1088 flush_icache_range((target_ulong)rc,
1089 (target_ulong)(rc + 1));
1090#endif
1091 retcode = ((target_ulong)rc) + thumb;
1092 }
1093
1094 env->regs[0] = usig;
53a5960a 1095 env->regs[13] = h2g(frame);
43fff238
FB		 1096 env->regs[14] = retcode;
1097 env->regs[15] = handler & (thumb ? ~1 : ~3);
1098
b5ff1b31 1099#if 0
43fff238
FB		 1100#ifdef TARGET_CONFIG_CPU_32
1101 env->cpsr = cpsr;
b5ff1b31 1102#endif
43fff238
FB		 1103#endif
1104
1105 return 0;
1106}
1107
1108static void setup_frame(int usig, struct emulated_sigaction *ka,
1109 target_sigset_t *set, CPUState *regs)
1110{
1111 struct sigframe *frame = get_sigframe(ka, regs, sizeof(*frame));
9231944d 1112 int i, err = 0;
43fff238
FB		 1113
1114 err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]);
1115
9231944d
FB		 1116 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1117 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1118 return;
43fff238
FB		 1119 }
1120
1121 if (err == 0)
1122 err = setup_return(regs, ka, &frame->retcode, frame, usig);
1123 // return err;
1124}
1125
1126static void setup_rt_frame(int usig, struct emulated_sigaction *ka,
1127 target_siginfo_t *info,
1128 target_sigset_t *set, CPUState *env)
1129{
1130 struct rt_sigframe *frame = get_sigframe(ka, env, sizeof(*frame));
9231944d 1131 int i, err = 0;
43fff238 1132
43fff238 1133 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
edf779ff
FB		 1134 return /* 1 */;
1135
43fff238
FB		 1136 __put_user_error(&frame->info, (target_ulong *)&frame->pinfo, err);
1137 __put_user_error(&frame->uc, (target_ulong *)&frame->puc, err);
1138 err |= copy_siginfo_to_user(&frame->info, info);
1139
1140 /* Clear all the bits of the ucontext we don't use. */
53a5960a 1141 memset(&frame->uc, 0, offsetof(struct target_ucontext, tuc_mcontext));
43fff238 1142
b8076a74 1143 err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/
43fff238 1144 env, set->sig[0]);
9231944d 1145 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
b8076a74 1146 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
9231944d
FB		 1147 return;
1148 }
43fff238
FB		 1149
1150 if (err == 0)
1151 err = setup_return(env, ka, &frame->retcode, frame, usig);
1152
1153 if (err == 0) {
1154 /*
1155 * For realtime signals we must also set the second and third
1156 * arguments for the signal handler.
1157 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
1158 */
1159 env->regs[1] = (target_ulong)frame->pinfo;
1160 env->regs[2] = (target_ulong)frame->puc;
1161 }
1162
1163 // return err;
1164}
1165
1166static int
1167restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1168{
1169 int err = 0;
b5ff1b31 1170 uint32_t cpsr;
43fff238
FB		 1171
1172 __get_user_error(env->regs[0], &sc->arm_r0, err);
1173 __get_user_error(env->regs[1], &sc->arm_r1, err);
1174 __get_user_error(env->regs[2], &sc->arm_r2, err);
1175 __get_user_error(env->regs[3], &sc->arm_r3, err);
1176 __get_user_error(env->regs[4], &sc->arm_r4, err);
1177 __get_user_error(env->regs[5], &sc->arm_r5, err);
1178 __get_user_error(env->regs[6], &sc->arm_r6, err);
1179 __get_user_error(env->regs[7], &sc->arm_r7, err);
1180 __get_user_error(env->regs[8], &sc->arm_r8, err);
1181 __get_user_error(env->regs[9], &sc->arm_r9, err);
1182 __get_user_error(env->regs[10], &sc->arm_r10, err);
1183 __get_user_error(env->regs[11], &sc->arm_fp, err);
1184 __get_user_error(env->regs[12], &sc->arm_ip, err);
1185 __get_user_error(env->regs[13], &sc->arm_sp, err);
1186 __get_user_error(env->regs[14], &sc->arm_lr, err);
1187 __get_user_error(env->regs[15], &sc->arm_pc, err);
1188#ifdef TARGET_CONFIG_CPU_32
b5ff1b31
FB		 1189 __get_user_error(cpsr, &sc->arm_cpsr, err);
1190 cpsr_write(env, cpsr, 0xffffffff);
43fff238
FB		 1191#endif
1192
1193 err |= !valid_user_regs(env);
1194
1195 return err;
1196}
1197
1198long do_sigreturn(CPUState *env)
1199{
1200 struct sigframe *frame;
1201 target_sigset_t set;
1202 sigset_t host_set;
9231944d 1203 int i;
43fff238
FB		 1204
1205 /*
1206 * Since we stacked the signal on a 64-bit boundary,
1207 * then 'sp' should be word aligned here. If it's
1208 * not, then the user is trying to mess with us.
1209 */
1210 if (env->regs[13] & 7)
1211 goto badframe;
1212
53a5960a 1213 frame = (struct sigframe *)g2h(env->regs[13]);
43fff238
FB		 1214
1215#if 0
1216 if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1217 goto badframe;
1218#endif
9231944d
FB		 1219 if (__get_user(set.sig[0], &frame->sc.oldmask))
1220 goto badframe;
1221 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1222 if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1223 goto badframe;
1224 }
43fff238 1225
9231944d 1226 target_to_host_sigset_internal(&host_set, &set);
43fff238
FB		 1227 sigprocmask(SIG_SETMASK, &host_set, NULL);
1228
1229 if (restore_sigcontext(env, &frame->sc))
1230 goto badframe;
1231
1232#if 0
1233 /* Send SIGTRAP if we're single-stepping */
1234 if (ptrace_cancel_bpt(current))
1235 send_sig(SIGTRAP, current, 1);
1236#endif
1237 return env->regs[0];
1238
1239badframe:
1240 force_sig(SIGSEGV /* , current */);
1241 return 0;
1242}
1243
1244long do_rt_sigreturn(CPUState *env)
1245{
1246 struct rt_sigframe *frame;
43fff238
FB		 1247 sigset_t host_set;
1248
1249 /*
1250 * Since we stacked the signal on a 64-bit boundary,
1251 * then 'sp' should be word aligned here. If it's
1252 * not, then the user is trying to mess with us.
1253 */
1254 if (env->regs[13] & 7)
1255 goto badframe;
1256
1257 frame = (struct rt_sigframe *)env->regs[13];
1258
1259#if 0
1260 if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1261 goto badframe;
1262#endif
b8076a74 1263 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
43fff238
FB		 1264 sigprocmask(SIG_SETMASK, &host_set, NULL);
1265
b8076a74 1266 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
43fff238
FB		 1267 goto badframe;
1268
1269#if 0
1270 /* Send SIGTRAP if we're single-stepping */
1271 if (ptrace_cancel_bpt(current))
1272 send_sig(SIGTRAP, current, 1);
1273#endif
1274 return env->regs[0];
1275
1276badframe:
1277 force_sig(SIGSEGV /* , current */);
1278 return 0;
1279}
1280
6d5e216d 1281#elif defined(TARGET_SPARC)
80a9d035 1282
6d5e216d
FB		 1283#define __SUNOS_MAXWIN 31
1284
1285/* This is what SunOS does, so shall I. */
1286struct target_sigcontext {
1287 target_ulong sigc_onstack; /* state to restore */
1288
1289 target_ulong sigc_mask; /* sigmask to restore */
1290 target_ulong sigc_sp; /* stack pointer */
1291 target_ulong sigc_pc; /* program counter */
1292 target_ulong sigc_npc; /* next program counter */
1293 target_ulong sigc_psr; /* for condition codes etc */
1294 target_ulong sigc_g1; /* User uses these two registers */
1295 target_ulong sigc_o0; /* within the trampoline code. */
1296
1297 /* Now comes information regarding the users window set
1298 * at the time of the signal.
1299 */
1300 target_ulong sigc_oswins; /* outstanding windows */
1301
1302 /* stack ptrs for each regwin buf */
1303 char *sigc_spbuf[__SUNOS_MAXWIN];
1304
1305 /* Windows to restore after signal */
1306 struct {
1307 target_ulong locals[8];
1308 target_ulong ins[8];
1309 } sigc_wbuf[__SUNOS_MAXWIN];
1310};
1311/* A Sparc stack frame */
1312struct sparc_stackf {
1313 target_ulong locals[8];
1314 target_ulong ins[6];
1315 struct sparc_stackf *fp;
1316 target_ulong callers_pc;
1317 char *structptr;
1318 target_ulong xargs[6];
1319 target_ulong xxargs[1];
1320};
1321
1322typedef struct {
1323 struct {
1324 target_ulong psr;
1325 target_ulong pc;
1326 target_ulong npc;
1327 target_ulong y;
1328 target_ulong u_regs[16]; /* globals and ins */
1329 } si_regs;
1330 int si_mask;
1331} __siginfo_t;
1332
1333typedef struct {
1334 unsigned long si_float_regs [32];
1335 unsigned long si_fsr;
1336 unsigned long si_fpqdepth;
1337 struct {
1338 unsigned long *insn_addr;
1339 unsigned long insn;
1340 } si_fpqueue [16];
74ccb34e 1341} qemu_siginfo_fpu_t;
6d5e216d
FB		 1342
1343
1344struct target_signal_frame {
1345 struct sparc_stackf ss;
1346 __siginfo_t info;
74ccb34e 1347 qemu_siginfo_fpu_t *fpu_save;
6d5e216d
FB		 1348 target_ulong insns[2] __attribute__ ((aligned (8)));
1349 target_ulong extramask[TARGET_NSIG_WORDS - 1];
1350 target_ulong extra_size; /* Should be 0 */
74ccb34e 1351 qemu_siginfo_fpu_t fpu_state;
6d5e216d
FB		 1352};
1353struct target_rt_signal_frame {
1354 struct sparc_stackf ss;
1355 siginfo_t info;
1356 target_ulong regs[20];
1357 sigset_t mask;
74ccb34e 1358 qemu_siginfo_fpu_t *fpu_save;
6d5e216d
FB		 1359 unsigned int insns[2];
1360 stack_t stack;
1361 unsigned int extra_size; /* Should be 0 */
74ccb34e 1362 qemu_siginfo_fpu_t fpu_state;
6d5e216d
FB		 1363};
1364
e80cfcfc
FB		 1365#define UREG_O0 16
1366#define UREG_O6 22
1367#define UREG_I0 0
1368#define UREG_I1 1
1369#define UREG_I2 2
1370#define UREG_I6 6
1371#define UREG_I7 7
1372#define UREG_L0 8
6d5e216d
FB		 1373#define UREG_FP UREG_I6
1374#define UREG_SP UREG_O6
1375
1376static inline void *get_sigframe(struct emulated_sigaction *sa, CPUState *env, unsigned long framesize)
1377{
1378 unsigned long sp;
1379
1380 sp = env->regwptr[UREG_FP];
1381#if 0
1382
1383 /* This is the X/Open sanctioned signal stack switching. */
1384 if (sa->sa_flags & TARGET_SA_ONSTACK) {
1385 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
1386 sp = current->sas_ss_sp + current->sas_ss_size;
1387 }
1388#endif
53a5960a 1389 return g2h(sp - framesize);
6d5e216d
FB		 1390}
1391
1392static int
1393setup___siginfo(__siginfo_t *si, CPUState *env, target_ulong mask)
1394{
1395 int err = 0, i;
1396
6d5e216d 1397 err |= __put_user(env->psr, &si->si_regs.psr);
6d5e216d
FB		 1398 err |= __put_user(env->pc, &si->si_regs.pc);
1399 err |= __put_user(env->npc, &si->si_regs.npc);
1400 err |= __put_user(env->y, &si->si_regs.y);
a315a145 1401 for (i=0; i < 8; i++) {
6d5e216d
FB		 1402 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1403 }
a315a145 1404 for (i=0; i < 8; i++) {
e80cfcfc 1405 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
6d5e216d 1406 }
6d5e216d
FB		 1407 err |= __put_user(mask, &si->si_mask);
1408 return err;
1409}
e80cfcfc 1410
80a9d035 1411#if 0
6d5e216d
FB		 1412static int
1413setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1414 CPUState *env, unsigned long mask)
1415{
1416 int err = 0;
1417
1418 err |= __put_user(mask, &sc->sigc_mask);
1419 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1420 err |= __put_user(env->pc, &sc->sigc_pc);
1421 err |= __put_user(env->npc, &sc->sigc_npc);
1422 err |= __put_user(env->psr, &sc->sigc_psr);
1423 err |= __put_user(env->gregs[1], &sc->sigc_g1);
1424 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1425
1426 return err;
1427}
80a9d035 1428#endif
6d5e216d
FB		 1429#define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1430
1431static void setup_frame(int sig, struct emulated_sigaction *ka,
1432 target_sigset_t *set, CPUState *env)
1433{
1434 struct target_signal_frame *sf;
1435 int sigframe_size, err, i;
1436
1437 /* 1. Make sure everything is clean */
1438 //synchronize_user_stack();
1439
1440 sigframe_size = NF_ALIGNEDSZ;
1441
1442 sf = (struct target_signal_frame *)
1443 get_sigframe(ka, env, sigframe_size);
1444
e80cfcfc 1445 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
6d5e216d
FB		 1446#if 0
1447 if (invalid_frame_pointer(sf, sigframe_size))
1448 goto sigill_and_return;
1449#endif
1450 /* 2. Save the current process state */
1451 err = setup___siginfo(&sf->info, env, set->sig[0]);
1452 err |= __put_user(0, &sf->extra_size);
1453
1454 //err |= save_fpu_state(regs, &sf->fpu_state);
1455 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1456
1457 err |= __put_user(set->sig[0], &sf->info.si_mask);
1458 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1459 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1460 }
1461
a315a145 1462 for (i = 0; i < 8; i++) {
e80cfcfc 1463 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
6d5e216d 1464 }
a315a145 1465 for (i = 0; i < 8; i++) {
e80cfcfc 1466 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
6d5e216d 1467 }
6d5e216d
FB		 1468 if (err)
1469 goto sigsegv;
1470
1471 /* 3. signal handler back-trampoline and parameters */
53a5960a 1472 env->regwptr[UREG_FP] = h2g(sf);
6d5e216d 1473 env->regwptr[UREG_I0] = sig;
53a5960a
PB		 1474 env->regwptr[UREG_I1] = h2g(&sf->info);
1475 env->regwptr[UREG_I2] = h2g(&sf->info);
6d5e216d
FB		 1476
1477 /* 4. signal handler */
1478 env->pc = (unsigned long) ka->sa._sa_handler;
1479 env->npc = (env->pc + 4);
1480 /* 5. return to kernel instructions */
1481 if (ka->sa.sa_restorer)
1482 env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer;
1483 else {
53a5960a 1484 env->regwptr[UREG_I7] = h2g(&(sf->insns[0]) - 2);
6d5e216d
FB		 1485
1486 /* mov __NR_sigreturn, %g1 */
1487 err |= __put_user(0x821020d8, &sf->insns[0]);
1488
1489 /* t 0x10 */
1490 err |= __put_user(0x91d02010, &sf->insns[1]);
1491 if (err)
1492 goto sigsegv;
1493
1494 /* Flush instruction space. */
1495 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
80a9d035 1496 // tb_flush(env);
6d5e216d
FB		 1497 }
1498 return;
1499
80a9d035 1500 //sigill_and_return:
6d5e216d
FB		 1501 force_sig(TARGET_SIGILL);
1502sigsegv:
e80cfcfc 1503 //fprintf(stderr, "force_sig\n");
6d5e216d
FB		 1504 force_sig(TARGET_SIGSEGV);
1505}
1506static inline int
74ccb34e 1507restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
6d5e216d
FB		 1508{
1509 int err;
1510#if 0
1511#ifdef CONFIG_SMP
1512 if (current->flags & PF_USEDFPU)
1513 regs->psr &= ~PSR_EF;
1514#else
1515 if (current == last_task_used_math) {
1516 last_task_used_math = 0;
1517 regs->psr &= ~PSR_EF;
1518 }
1519#endif
1520 current->used_math = 1;
1521 current->flags &= ~PF_USEDFPU;
1522#endif
1523#if 0
1524 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1525 return -EFAULT;
1526#endif
1527
fafffaef
FB		 1528#if 0
1529 /* XXX: incorrect */
6d5e216d
FB		 1530 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1531 (sizeof(unsigned long) * 32));
fafffaef 1532#endif
6d5e216d
FB		 1533 err |= __get_user(env->fsr, &fpu->si_fsr);
1534#if 0
1535 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1536 if (current->thread.fpqdepth != 0)
1537 err |= __copy_from_user(&current->thread.fpqueue[0],
1538 &fpu->si_fpqueue[0],
1539 ((sizeof(unsigned long) +
1540 (sizeof(unsigned long *)))*16));
1541#endif
1542 return err;
1543}
1544
1545
1546static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1547 target_siginfo_t *info,
1548 target_sigset_t *set, CPUState *env)
1549{
1550 fprintf(stderr, "setup_rt_frame: not implemented\n");
1551}
1552
1553long do_sigreturn(CPUState *env)
1554{
1555 struct target_signal_frame *sf;
e80cfcfc 1556 uint32_t up_psr, pc, npc;
6d5e216d 1557 target_sigset_t set;
e80cfcfc 1558 sigset_t host_set;
80a9d035 1559 target_ulong fpu_save;
e80cfcfc 1560 int err, i;
6d5e216d 1561
53a5960a 1562 sf = (struct target_signal_frame *)g2h(env->regwptr[UREG_FP]);
80a9d035 1563#if 0
e80cfcfc
FB		 1564 fprintf(stderr, "sigreturn\n");
1565 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
80a9d035 1566#endif
e80cfcfc 1567 //cpu_dump_state(env, stderr, fprintf, 0);
6d5e216d
FB		 1568
1569 /* 1. Make sure we are not getting garbage from the user */
1570#if 0
1571 if (verify_area (VERIFY_READ, sf, sizeof (*sf)))
1572 goto segv_and_exit;
1573#endif
1574
1575 if (((uint) sf) & 3)
1576 goto segv_and_exit;
1577
1578 err = __get_user(pc, &sf->info.si_regs.pc);
1579 err |= __get_user(npc, &sf->info.si_regs.npc);
1580
6d5e216d
FB		 1581 if ((pc | npc) & 3)
1582 goto segv_and_exit;
1583
1584 /* 2. Restore the state */
e80cfcfc
FB		 1585 err |= __get_user(up_psr, &sf->info.si_regs.psr);
1586
6d5e216d 1587 /* User can only change condition codes and FPU enabling in %psr. */
a315a145
FB		 1588 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1589 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1590
1591 env->pc = pc;
1592 env->npc = npc;
e80cfcfc 1593 err |= __get_user(env->y, &sf->info.si_regs.y);
a315a145 1594 for (i=0; i < 8; i++) {
e80cfcfc
FB		 1595 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1596 }
a315a145 1597 for (i=0; i < 8; i++) {
e80cfcfc
FB		 1598 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1599 }
6d5e216d 1600
80a9d035 1601 err |= __get_user(fpu_save, (target_ulong *)&sf->fpu_save);
6d5e216d 1602
e80cfcfc
FB		 1603 //if (fpu_save)
1604 // err |= restore_fpu_state(env, fpu_save);
6d5e216d
FB		 1605
1606 /* This is pretty much atomic, no amount locking would prevent
1607 * the races which exist anyways.
1608 */
1609 err |= __get_user(set.sig[0], &sf->info.si_mask);
e80cfcfc
FB		 1610 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1611 err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1612 }
1613
1614 target_to_host_sigset_internal(&host_set, &set);
1615 sigprocmask(SIG_SETMASK, &host_set, NULL);
6d5e216d
FB		 1616
1617 if (err)
1618 goto segv_and_exit;
1619
6d5e216d
FB		 1620 return env->regwptr[0];
1621
1622segv_and_exit:
1623 force_sig(TARGET_SIGSEGV);
1624}
1625
1626long do_rt_sigreturn(CPUState *env)
1627{
1628 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1629 return -ENOSYS;
1630}
1631
106ec879
FB		 1632#elif defined(TARGET_MIPS)
1633
1634struct target_sigcontext {
1635 uint32_t sc_regmask; /* Unused */
1636 uint32_t sc_status;
1637 uint64_t sc_pc;
1638 uint64_t sc_regs[32];
1639 uint64_t sc_fpregs[32];
1640 uint32_t sc_ownedfp; /* Unused */
1641 uint32_t sc_fpc_csr;
1642 uint32_t sc_fpc_eir; /* Unused */
1643 uint32_t sc_used_math;
1644 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
1645 uint64_t sc_mdhi;
1646 uint64_t sc_mdlo;
1647 target_ulong sc_hi1; /* Was sc_cause */
1648 target_ulong sc_lo1; /* Was sc_badvaddr */
1649 target_ulong sc_hi2; /* Was sc_sigset[4] */
1650 target_ulong sc_lo2;
1651 target_ulong sc_hi3;
1652 target_ulong sc_lo3;
1653};
1654
1655struct sigframe {
1656 uint32_t sf_ass[4]; /* argument save space for o32 */
1657 uint32_t sf_code[2]; /* signal trampoline */
1658 struct target_sigcontext sf_sc;
1659 target_sigset_t sf_mask;
1660};
1661
1662/* Install trampoline to jump back from signal handler */
1663static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
1664{
1665 int err;
1666
1667 /*
1668 * Set up the return code ...
1669 *
1670 * li v0, __NR__foo_sigreturn
1671 * syscall
1672 */
1673
1674 err = __put_user(0x24020000 + syscall, tramp + 0);
1675 err |= __put_user(0x0000000c , tramp + 1);
1676 /* flush_cache_sigtramp((unsigned long) tramp); */
1677 return err;
1678}
1679
1680static inline int
1681setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
1682{
1683 int err = 0;
1684
1685 err |= __put_user(regs->PC, &sc->sc_pc);
1686
388bb21a
TS		 1687#define save_gp_reg(i) do { \
1688 err |= __put_user(regs->gpr[i], &sc->sc_regs[i]); \
106ec879
FB		 1689 } while(0)
1690 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
1691 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
1692 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
1693 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
1694 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
1695 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
1696 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
1697 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
1698 save_gp_reg(31);
388bb21a 1699#undef save_gp_reg
106ec879
FB		 1700
1701 err |= __put_user(regs->HI, &sc->sc_mdhi);
1702 err |= __put_user(regs->LO, &sc->sc_mdlo);
1703
1704 /* Not used yet, but might be useful if we ever have DSP suppport */
1705#if 0
1706 if (cpu_has_dsp) {
1707 err |= __put_user(mfhi1(), &sc->sc_hi1);
1708 err |= __put_user(mflo1(), &sc->sc_lo1);
1709 err |= __put_user(mfhi2(), &sc->sc_hi2);
1710 err |= __put_user(mflo2(), &sc->sc_lo2);
1711 err |= __put_user(mfhi3(), &sc->sc_hi3);
1712 err |= __put_user(mflo3(), &sc->sc_lo3);
1713 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
1714 }
1715 /* same with 64 bit */
388bb21a 1716#ifdef CONFIG_64BIT
106ec879
FB		 1717 err |= __put_user(regs->hi, &sc->sc_hi[0]);
1718 err |= __put_user(regs->lo, &sc->sc_lo[0]);
1719 if (cpu_has_dsp) {
1720 err |= __put_user(mfhi1(), &sc->sc_hi[1]);
1721 err |= __put_user(mflo1(), &sc->sc_lo[1]);
1722 err |= __put_user(mfhi2(), &sc->sc_hi[2]);
1723 err |= __put_user(mflo2(), &sc->sc_lo[2]);
1724 err |= __put_user(mfhi3(), &sc->sc_hi[3]);
1725 err |= __put_user(mflo3(), &sc->sc_lo[3]);
1726 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
1727 }
388bb21a
TS		 1728#endif
1729#endif
106ec879 1730
388bb21a 1731#if 0
106ec879
FB		 1732 err |= __put_user(!!used_math(), &sc->sc_used_math);
1733
1734 if (!used_math())
1735 goto out;
1736
1737 /*
1738 * Save FPU state to signal context. Signal handler will "inherit"
1739 * current FPU state.
1740 */
1741 preempt_disable();
1742
1743 if (!is_fpu_owner()) {
1744 own_fpu();
1745 restore_fp(current);
1746 }
1747 err |= save_fp_context(sc);
1748
1749 preempt_enable();
1750 out:
1751#endif
1752 return err;
1753}
1754
1755static inline int
1756restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
1757{
1758 int err = 0;
1759
1760 err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
1761
1762 err |= __get_user(regs->HI, &sc->sc_mdhi);
1763 err |= __get_user(regs->LO, &sc->sc_mdlo);
1764
388bb21a 1765#define restore_gp_reg(i) do { \
106ec879
FB		 1766 err |= __get_user(regs->gpr[i], &sc->sc_regs[i]); \
1767 } while(0)
1768 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
1769 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
1770 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
1771 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
1772 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
1773 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
1774 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
1775 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
1776 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
1777 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
1778 restore_gp_reg(31);
388bb21a 1779#undef restore_gp_reg
106ec879
FB		 1780
1781#if 0
1782 if (cpu_has_dsp) {
1783 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
1784 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
1785 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
1786 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
1787 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
1788 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
1789 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
1790 }
388bb21a 1791#ifdef CONFIG_64BIT
106ec879
FB		 1792 err |= __get_user(regs->hi, &sc->sc_hi[0]);
1793 err |= __get_user(regs->lo, &sc->sc_lo[0]);
1794 if (cpu_has_dsp) {
1795 err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
1796 err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
1797 err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
1798 err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
1799 err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
1800 err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
1801 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
1802 }
388bb21a 1803#endif
106ec879
FB		 1804
1805 err |= __get_user(used_math, &sc->sc_used_math);
1806 conditional_used_math(used_math);
1807
1808 preempt_disable();
1809
1810 if (used_math()) {
1811 /* restore fpu context if we have used it before */
1812 own_fpu();
1813 err |= restore_fp_context(sc);
1814 } else {
1815 /* signal handler may have used FPU. Give it up. */
1816 lose_fpu();
1817 }
1818
1819 preempt_enable();
1820#endif
1821 return err;
1822}
1823/*
1824 * Determine which stack to use..
1825 */
1826static inline void *
1827get_sigframe(struct emulated_sigaction *ka, CPUState *regs, size_t frame_size)
1828{
1829 unsigned long sp;
1830
1831 /* Default to using normal stack */
1832 sp = regs->gpr[29];
1833
1834 /*
1835 * FPU emulator may have it's own trampoline active just
1836 * above the user stack, 16-bytes before the next lowest
1837 * 16 byte boundary. Try to avoid trashing it.
1838 */
1839 sp -= 32;
1840
1841#if 0
1842 /* This is the X/Open sanctioned signal stack switching. */
1843 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
1844 sp = current->sas_ss_sp + current->sas_ss_size;
1845#endif
1846
1847 return g2h((sp - frame_size) & ~7);
1848}
1849
1850static void setup_frame(int sig, struct emulated_sigaction * ka,
1851 target_sigset_t *set, CPUState *regs)
1852{
1853 struct sigframe *frame;
1854 int i;
1855
1856 frame = get_sigframe(ka, regs, sizeof(*frame));
1857 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
1858 goto give_sigsegv;
1859
1860 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
1861
1862 if(setup_sigcontext(regs, &frame->sf_sc))
1863 goto give_sigsegv;
1864
1865 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1866 if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
1867 goto give_sigsegv;
1868 }
1869
1870 /*
1871 * Arguments to signal handler:
1872 *
1873 * a0 = signal number
1874 * a1 = 0 (should be cause)
1875 * a2 = pointer to struct sigcontext
1876 *
1877 * $25 and PC point to the signal handler, $29 points to the
1878 * struct sigframe.
1879 */
1880 regs->gpr[ 4] = sig;
1881 regs->gpr[ 5] = 0;
1882 regs->gpr[ 6] = h2g(&frame->sf_sc);
1883 regs->gpr[29] = h2g(frame);
1884 regs->gpr[31] = h2g(frame->sf_code);
1885 /* The original kernel code sets CP0_EPC to the handler
1886 * since it returns to userland using eret
1887 * we cannot do this here, and we must set PC directly */
1888 regs->PC = regs->gpr[25] = ka->sa._sa_handler;
1889 return;
1890
1891give_sigsegv:
1892 force_sig(TARGET_SIGSEGV/*, current*/);
1893 return;
1894}
1895
1896long do_sigreturn(CPUState *regs)
1897{
388bb21a
TS		 1898 struct sigframe *frame;
1899 sigset_t blocked;
1900 target_sigset_t target_set;
1901 int i;
106ec879
FB		 1902
1903#if defined(DEBUG_SIGNAL)
388bb21a 1904 fprintf(stderr, "do_sigreturn\n");
106ec879 1905#endif
388bb21a
TS		 1906 frame = (struct sigframe *) regs->gpr[29];
1907 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
106ec879
FB		 1908 goto badframe;
1909
388bb21a 1910 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
106ec879
FB		 1911 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
1912 goto badframe;
388bb21a 1913 }
106ec879 1914
388bb21a
TS		 1915 target_to_host_sigset_internal(&blocked, &target_set);
1916 sigprocmask(SIG_SETMASK, &blocked, NULL);
106ec879 1917
388bb21a 1918 if (restore_sigcontext(regs, &frame->sf_sc))
106ec879
FB		 1919 goto badframe;
1920
1921#if 0
388bb21a
TS		 1922 /*
1923 * Don't let your children do this ...
1924 */
1925 __asm__ __volatile__(
106ec879
FB		 1926 "move\t$29, %0\n\t"
1927 "j\tsyscall_exit"
1928 :/* no outputs */
1929 :"r" (&regs));
388bb21a 1930 /* Unreached */
106ec879
FB		 1931#endif
1932
1933 regs->PC = regs->CP0_EPC;
388bb21a 1934 /* I am not sure this is right, but it seems to work
106ec879
FB		 1935 * maybe a problem with nested signals ? */
1936 regs->CP0_EPC = 0;
1937 return 0;
1938
1939badframe:
388bb21a
TS		 1940 force_sig(TARGET_SIGSEGV/*, current*/);
1941 return 0;
106ec879
FB		 1942}
1943
1944static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1945 target_siginfo_t *info,
1946 target_sigset_t *set, CPUState *env)
1947{
1948 fprintf(stderr, "setup_rt_frame: not implemented\n");
1949}
1950
1951long do_rt_sigreturn(CPUState *env)
1952{
1953 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1954 return -ENOSYS;
1955}
6d5e216d 1956
b346ff46
FB		 1957#else
1958
1959static void setup_frame(int sig, struct emulated_sigaction *ka,
1960 target_sigset_t *set, CPUState *env)
1961{
1962 fprintf(stderr, "setup_frame: not implemented\n");
1963}
1964
1965static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1966 target_siginfo_t *info,
1967 target_sigset_t *set, CPUState *env)
1968{
1969 fprintf(stderr, "setup_rt_frame: not implemented\n");
1970}
1971
1972long do_sigreturn(CPUState *env)
1973{
1974 fprintf(stderr, "do_sigreturn: not implemented\n");
1975 return -ENOSYS;
1976}
1977
1978long do_rt_sigreturn(CPUState *env)
1979{
1980 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1981 return -ENOSYS;
1982}
1983
66fb9763
FB		 1984#endif
1985
1986void process_pending_signals(void *cpu_env)
1987{
1988 int sig;
1989 target_ulong handler;
9de5e440
FB		 1990 sigset_t set, old_set;
1991 target_sigset_t target_old_set;
66fb9763
FB		 1992 struct emulated_sigaction *k;
1993 struct sigqueue *q;
1994
31e31b8a
FB		 1995 if (!signal_pending)
1996 return;
1997
66fb9763
FB		 1998 k = sigact_table;
1999 for(sig = 1; sig <= TARGET_NSIG; sig++) {
2000 if (k->pending)
31e31b8a 2001 goto handle_signal;
66fb9763 2002 k++;
31e31b8a
FB		 2003 }
2004 /* if no signal is pending, just return */
2005 signal_pending = 0;
2006 return;
66fb9763 2007
31e31b8a 2008 handle_signal:
66fb9763 2009#ifdef DEBUG_SIGNAL
bc8a22cc 2010 fprintf(stderr, "qemu: process signal %d\n", sig);
66fb9763
FB		 2011#endif
2012 /* dequeue signal */
2013 q = k->first;
2014 k->first = q->next;
2015 if (!k->first)
2016 k->pending = 0;
1fddef4b
FB		 2017
2018 sig = gdb_handlesig (cpu_env, sig);
2019 if (!sig) {
2020 fprintf (stderr, "Lost signal\n");
2021 abort();
2022 }
66fb9763
FB		 2023
2024 handler = k->sa._sa_handler;
2025 if (handler == TARGET_SIG_DFL) {
2026 /* default handler : ignore some signal. The other are fatal */
2027 if (sig != TARGET_SIGCHLD &&
2028 sig != TARGET_SIGURG &&
2029 sig != TARGET_SIGWINCH) {
2030 force_sig(sig);
2031 }
2032 } else if (handler == TARGET_SIG_IGN) {
2033 /* ignore sig */
2034 } else if (handler == TARGET_SIG_ERR) {
2035 force_sig(sig);
2036 } else {
9de5e440
FB		 2037 /* compute the blocked signals during the handler execution */
2038 target_to_host_sigset(&set, &k->sa.sa_mask);
2039 /* SA_NODEFER indicates that the current signal should not be
2040 blocked during the handler */
2041 if (!(k->sa.sa_flags & TARGET_SA_NODEFER))
2042 sigaddset(&set, target_to_host_signal(sig));
2043
2044 /* block signals in the handler using Linux */
2045 sigprocmask(SIG_BLOCK, &set, &old_set);
2046 /* save the previous blocked signal state to restore it at the
2047 end of the signal execution (see do_sigreturn) */
9231944d 2048 host_to_target_sigset_internal(&target_old_set, &old_set);
9de5e440 2049
bc8a22cc 2050 /* if the CPU is in VM86 mode, we restore the 32 bit values */
84409ddb 2051#if defined(TARGET_I386) && !defined(TARGET_X86_64)
bc8a22cc
FB		 2052 {
2053 CPUX86State *env = cpu_env;
2054 if (env->eflags & VM_MASK)
2055 save_v86_state(env);
2056 }
2057#endif
9de5e440 2058 /* prepare the stack frame of the virtual CPU */
66fb9763 2059 if (k->sa.sa_flags & TARGET_SA_SIGINFO)
9de5e440 2060 setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env);
66fb9763 2061 else
9de5e440 2062 setup_frame(sig, k, &target_old_set, cpu_env);
66fb9763
FB		 2063 if (k->sa.sa_flags & TARGET_SA_RESETHAND)
2064 k->sa._sa_handler = TARGET_SIG_DFL;
31e31b8a 2065 }
66fb9763
FB		 2066 if (q != &k->info)
2067 free_sigqueue(q);
2068}
Mirror of https://git.qemu.org/git/qemu.git