?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Clarify -soundhw documentation as to avoid hda confusion
[qemu/mini2440.git] / linux-user / signal.c
blobe0f6aaf7332018c183726e745af4ad0553f51462
1 /*
2 * Emulation of Linux signals
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>
22 #include <string.h>
23 #include <stdarg.h>
24 #include <unistd.h>
25 #include <signal.h>
26 #include <errno.h>
27 #include <sys/ucontext.h>
28
29 #include "qemu.h"
30 #include "target_signal.h"
31
32 //#define DEBUG_SIGNAL
33
34 static struct target_sigaltstack target_sigaltstack_used = {
35 .ss_sp = 0,
36 .ss_size = 0,
37 .ss_flags = TARGET_SS_DISABLE,
38 };
39
40 static struct target_sigaction sigact_table[TARGET_NSIG];
41
42 static void host_signal_handler(int host_signum, siginfo_t *info,
43 void *puc);
44
45 static uint8_t host_to_target_signal_table[65] = {
46 [SIGHUP] = TARGET_SIGHUP,
47 [SIGINT] = TARGET_SIGINT,
48 [SIGQUIT] = TARGET_SIGQUIT,
49 [SIGILL] = TARGET_SIGILL,
50 [SIGTRAP] = TARGET_SIGTRAP,
51 [SIGABRT] = TARGET_SIGABRT,
52 /* [SIGIOT] = TARGET_SIGIOT,*/
53 [SIGBUS] = TARGET_SIGBUS,
54 [SIGFPE] = TARGET_SIGFPE,
55 [SIGKILL] = TARGET_SIGKILL,
56 [SIGUSR1] = TARGET_SIGUSR1,
57 [SIGSEGV] = TARGET_SIGSEGV,
58 [SIGUSR2] = TARGET_SIGUSR2,
59 [SIGPIPE] = TARGET_SIGPIPE,
60 [SIGALRM] = TARGET_SIGALRM,
61 [SIGTERM] = TARGET_SIGTERM,
62 #ifdef SIGSTKFLT
63 [SIGSTKFLT] = TARGET_SIGSTKFLT,
64 #endif
65 [SIGCHLD] = TARGET_SIGCHLD,
66 [SIGCONT] = TARGET_SIGCONT,
67 [SIGSTOP] = TARGET_SIGSTOP,
68 [SIGTSTP] = TARGET_SIGTSTP,
69 [SIGTTIN] = TARGET_SIGTTIN,
70 [SIGTTOU] = TARGET_SIGTTOU,
71 [SIGURG] = TARGET_SIGURG,
72 [SIGXCPU] = TARGET_SIGXCPU,
73 [SIGXFSZ] = TARGET_SIGXFSZ,
74 [SIGVTALRM] = TARGET_SIGVTALRM,
75 [SIGPROF] = TARGET_SIGPROF,
76 [SIGWINCH] = TARGET_SIGWINCH,
77 [SIGIO] = TARGET_SIGIO,
78 [SIGPWR] = TARGET_SIGPWR,
79 [SIGSYS] = TARGET_SIGSYS,
80 /* next signals stay the same */
81 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
82 host libpthread signals. This assumes noone actually uses SIGRTMAX :-/
83 To fix this properly we need to do manual signal delivery multiplexed
84 over a single host signal. */
85 [__SIGRTMIN] = __SIGRTMAX,
86 [__SIGRTMAX] = __SIGRTMIN,
87 };
88 static uint8_t target_to_host_signal_table[65];
89
90 static inline int on_sig_stack(unsigned long sp)
91 {
92 return (sp - target_sigaltstack_used.ss_sp
93 < target_sigaltstack_used.ss_size);
94 }
95
96 static inline int sas_ss_flags(unsigned long sp)
97 {
98 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
99 : on_sig_stack(sp) ? SS_ONSTACK : 0);
100 }
101
102 static inline int host_to_target_signal(int sig)
103 {
104 if (sig > 64)
105 return sig;
106 return host_to_target_signal_table[sig];
107 }
108
109 int target_to_host_signal(int sig)
110 {
111 if (sig > 64)
112 return sig;
113 return target_to_host_signal_table[sig];
114 }
115
116 static inline void target_sigemptyset(target_sigset_t *set)
117 {
118 memset(set, 0, sizeof(*set));
119 }
120
121 static inline void target_sigaddset(target_sigset_t *set, int signum)
122 {
123 signum--;
124 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
125 set->sig[signum / TARGET_NSIG_BPW] |= mask;
126 }
127
128 static inline int target_sigismember(const target_sigset_t *set, int signum)
129 {
130 signum--;
131 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
132 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
133 }
134
135 static void host_to_target_sigset_internal(target_sigset_t *d,
136 const sigset_t *s)
137 {
138 int i;
139 target_sigemptyset(d);
140 for (i = 1; i <= TARGET_NSIG; i++) {
141 if (sigismember(s, i)) {
142 target_sigaddset(d, host_to_target_signal(i));
143 }
144 }
145 }
146
147 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
148 {
149 target_sigset_t d1;
150 int i;
151
152 host_to_target_sigset_internal(&d1, s);
153 for(i = 0;i < TARGET_NSIG_WORDS; i++)
154 d->sig[i] = tswapl(d1.sig[i]);
155 }
156
157 static void target_to_host_sigset_internal(sigset_t *d,
158 const target_sigset_t *s)
159 {
160 int i;
161 sigemptyset(d);
162 for (i = 1; i <= TARGET_NSIG; i++) {
163 if (target_sigismember(s, i)) {
164 sigaddset(d, target_to_host_signal(i));
165 }
166 }
167 }
168
169 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
170 {
171 target_sigset_t s1;
172 int i;
173
174 for(i = 0;i < TARGET_NSIG_WORDS; i++)
175 s1.sig[i] = tswapl(s->sig[i]);
176 target_to_host_sigset_internal(d, &s1);
177 }
178
179 void host_to_target_old_sigset(abi_ulong *old_sigset,
180 const sigset_t *sigset)
181 {
182 target_sigset_t d;
183 host_to_target_sigset(&d, sigset);
184 *old_sigset = d.sig[0];
185 }
186
187 void target_to_host_old_sigset(sigset_t *sigset,
188 const abi_ulong *old_sigset)
189 {
190 target_sigset_t d;
191 int i;
192
193 d.sig[0] = *old_sigset;
194 for(i = 1;i < TARGET_NSIG_WORDS; i++)
195 d.sig[i] = 0;
196 target_to_host_sigset(sigset, &d);
197 }
198
199 /* siginfo conversion */
200
201 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
202 const siginfo_t *info)
203 {
204 int sig;
205 sig = host_to_target_signal(info->si_signo);
206 tinfo->si_signo = sig;
207 tinfo->si_errno = 0;
208 tinfo->si_code = info->si_code;
209 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
210 sig == SIGBUS || sig == SIGTRAP) {
211 /* should never come here, but who knows. The information for
212 the target is irrelevant */
213 tinfo->_sifields._sigfault._addr = 0;
214 } else if (sig == SIGIO) {
215 tinfo->_sifields._sigpoll._fd = info->si_fd;
216 } else if (sig >= TARGET_SIGRTMIN) {
217 tinfo->_sifields._rt._pid = info->si_pid;
218 tinfo->_sifields._rt._uid = info->si_uid;
219 /* XXX: potential problem if 64 bit */
220 tinfo->_sifields._rt._sigval.sival_ptr =
221 (abi_ulong)(unsigned long)info->si_value.sival_ptr;
222 }
223 }
224
225 static void tswap_siginfo(target_siginfo_t *tinfo,
226 const target_siginfo_t *info)
227 {
228 int sig;
229 sig = info->si_signo;
230 tinfo->si_signo = tswap32(sig);
231 tinfo->si_errno = tswap32(info->si_errno);
232 tinfo->si_code = tswap32(info->si_code);
233 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
234 sig == SIGBUS || sig == SIGTRAP) {
235 tinfo->_sifields._sigfault._addr =
236 tswapl(info->_sifields._sigfault._addr);
237 } else if (sig == SIGIO) {
238 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
239 } else if (sig >= TARGET_SIGRTMIN) {
240 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
241 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
242 tinfo->_sifields._rt._sigval.sival_ptr =
243 tswapl(info->_sifields._rt._sigval.sival_ptr);
244 }
245 }
246
247
248 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
249 {
250 host_to_target_siginfo_noswap(tinfo, info);
251 tswap_siginfo(tinfo, tinfo);
252 }
253
254 /* XXX: we support only POSIX RT signals are used. */
255 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
256 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
257 {
258 info->si_signo = tswap32(tinfo->si_signo);
259 info->si_errno = tswap32(tinfo->si_errno);
260 info->si_code = tswap32(tinfo->si_code);
261 info->si_pid = tswap32(tinfo->_sifields._rt._pid);
262 info->si_uid = tswap32(tinfo->_sifields._rt._uid);
263 info->si_value.sival_ptr =
264 (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
265 }
266
267 void signal_init(void)
268 {
269 struct sigaction act;
270 struct sigaction oact;
271 int i, j;
272 int host_sig;
273
274 /* generate signal conversion tables */
275 for(i = 1; i <= 64; i++) {
276 if (host_to_target_signal_table[i] == 0)
277 host_to_target_signal_table[i] = i;
278 }
279 for(i = 1; i <= 64; i++) {
280 j = host_to_target_signal_table[i];
281 target_to_host_signal_table[j] = i;
282 }
283
284 /* set all host signal handlers. ALL signals are blocked during
285 the handlers to serialize them. */
286 memset(sigact_table, 0, sizeof(sigact_table));
287
288 sigfillset(&act.sa_mask);
289 act.sa_flags = SA_SIGINFO;
290 act.sa_sigaction = host_signal_handler;
291 for(i = 1; i <= TARGET_NSIG; i++) {
292 host_sig = target_to_host_signal(i);
293 sigaction(host_sig, NULL, &oact);
294 if (oact.sa_sigaction == (void *)SIG_IGN) {
295 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
296 } else if (oact.sa_sigaction == (void *)SIG_DFL) {
297 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
298 }
299 /* If there's already a handler installed then something has
300 gone horribly wrong, so don't even try to handle that case. */
301 /* Install some handlers for our own use. */
302 if (host_sig == SIGSEGV || host_sig == SIGBUS) {
303 sigaction(host_sig, &act, NULL);
304 }
305 }
306 }
307
308 /* signal queue handling */
309
310 static inline struct sigqueue *alloc_sigqueue(CPUState *env)
311 {
312 TaskState *ts = env->opaque;
313 struct sigqueue *q = ts->first_free;
314 if (!q)
315 return NULL;
316 ts->first_free = q->next;
317 return q;
318 }
319
320 static inline void free_sigqueue(CPUState *env, struct sigqueue *q)
321 {
322 TaskState *ts = env->opaque;
323 q->next = ts->first_free;
324 ts->first_free = q;
325 }
326
327 /* abort execution with signal */
328 static void __attribute((noreturn)) force_sig(int sig)
329 {
330 int host_sig;
331 host_sig = target_to_host_signal(sig);
332 fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
333 sig, strsignal(host_sig));
334 #if 1
335 _exit(-host_sig);
336 #else
337 {
338 struct sigaction act;
339 sigemptyset(&act.sa_mask);
340 act.sa_flags = SA_SIGINFO;
341 act.sa_sigaction = SIG_DFL;
342 sigaction(SIGABRT, &act, NULL);
343 abort();
344 }
345 #endif
346 }
347
348 /* queue a signal so that it will be send to the virtual CPU as soon
349 as possible */
350 int queue_signal(CPUState *env, int sig, target_siginfo_t *info)
351 {
352 TaskState *ts = env->opaque;
353 struct emulated_sigtable *k;
354 struct sigqueue *q, **pq;
355 abi_ulong handler;
356
357 #if defined(DEBUG_SIGNAL)
358 fprintf(stderr, "queue_signal: sig=%d\n",
359 sig);
360 #endif
361 k = &ts->sigtab[sig - 1];
362 handler = sigact_table[sig - 1]._sa_handler;
363 if (handler == TARGET_SIG_DFL) {
364 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
365 kill(getpid(),SIGSTOP);
366 return 0;
367 } else
368 /* default handler : ignore some signal. The other are fatal */
369 if (sig != TARGET_SIGCHLD &&
370 sig != TARGET_SIGURG &&
371 sig != TARGET_SIGWINCH &&
372 sig != TARGET_SIGCONT) {
373 force_sig(sig);
374 } else {
375 return 0; /* indicate ignored */
376 }
377 } else if (handler == TARGET_SIG_IGN) {
378 /* ignore signal */
379 return 0;
380 } else if (handler == TARGET_SIG_ERR) {
381 force_sig(sig);
382 } else {
383 pq = &k->first;
384 if (sig < TARGET_SIGRTMIN) {
385 /* if non real time signal, we queue exactly one signal */
386 if (!k->pending)
387 q = &k->info;
388 else
389 return 0;
390 } else {
391 if (!k->pending) {
392 /* first signal */
393 q = &k->info;
394 } else {
395 q = alloc_sigqueue(env);
396 if (!q)
397 return -EAGAIN;
398 while (*pq != NULL)
399 pq = &(*pq)->next;
400 }
401 }
402 *pq = q;
403 q->info = *info;
404 q->next = NULL;
405 k->pending = 1;
406 /* signal that a new signal is pending */
407 ts->signal_pending = 1;
408 return 1; /* indicates that the signal was queued */
409 }
410 }
411
412 static void host_signal_handler(int host_signum, siginfo_t *info,
413 void *puc)
414 {
415 int sig;
416 target_siginfo_t tinfo;
417
418 /* the CPU emulator uses some host signals to detect exceptions,
419 we we forward to it some signals */
420 if (host_signum == SIGSEGV || host_signum == SIGBUS) {
421 if (cpu_signal_handler(host_signum, info, puc))
422 return;
423 }
424
425 /* get target signal number */
426 sig = host_to_target_signal(host_signum);
427 if (sig < 1 || sig > TARGET_NSIG)
428 return;
429 #if defined(DEBUG_SIGNAL)
430 fprintf(stderr, "qemu: got signal %d\n", sig);
431 #endif
432 host_to_target_siginfo_noswap(&tinfo, info);
433 if (queue_signal(thread_env, sig, &tinfo) == 1) {
434 /* interrupt the virtual CPU as soon as possible */
435 cpu_interrupt(thread_env, CPU_INTERRUPT_EXIT);
436 }
437 }
438
439 /* do_sigaltstack() returns target values and errnos. */
440 /* compare linux/kernel/signal.c:do_sigaltstack() */
441 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
442 {
443 int ret;
444 struct target_sigaltstack oss;
445
446 /* XXX: test errors */
447 if(uoss_addr)
448 {
449 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
450 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
451 __put_user(sas_ss_flags(sp), &oss.ss_flags);
452 }
453
454 if(uss_addr)
455 {
456 struct target_sigaltstack *uss;
457 struct target_sigaltstack ss;
458
459 ret = -TARGET_EFAULT;
460 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)
461 || __get_user(ss.ss_sp, &uss->ss_sp)
462 || __get_user(ss.ss_size, &uss->ss_size)
463 || __get_user(ss.ss_flags, &uss->ss_flags))
464 goto out;
465 unlock_user_struct(uss, uss_addr, 0);
466
467 ret = -TARGET_EPERM;
468 if (on_sig_stack(sp))
469 goto out;
470
471 ret = -TARGET_EINVAL;
472 if (ss.ss_flags != TARGET_SS_DISABLE
473 && ss.ss_flags != TARGET_SS_ONSTACK
474 && ss.ss_flags != 0)
475 goto out;
476
477 if (ss.ss_flags == TARGET_SS_DISABLE) {
478 ss.ss_size = 0;
479 ss.ss_sp = 0;
480 } else {
481 ret = -TARGET_ENOMEM;
482 if (ss.ss_size < MINSIGSTKSZ)
483 goto out;
484 }
485
486 target_sigaltstack_used.ss_sp = ss.ss_sp;
487 target_sigaltstack_used.ss_size = ss.ss_size;
488 }
489
490 if (uoss_addr) {
491 ret = -TARGET_EFAULT;
492 if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
493 goto out;
494 }
495
496 ret = 0;
497 out:
498 return ret;
499 }
500
501 /* do_sigaction() return host values and errnos */
502 int do_sigaction(int sig, const struct target_sigaction *act,
503 struct target_sigaction *oact)
504 {
505 struct target_sigaction *k;
506 struct sigaction act1;
507 int host_sig;
508 int ret = 0;
509
510 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
511 return -EINVAL;
512 k = &sigact_table[sig - 1];
513 #if defined(DEBUG_SIGNAL)
514 fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
515 sig, (int)act, (int)oact);
516 #endif
517 if (oact) {
518 oact->_sa_handler = tswapl(k->_sa_handler);
519 oact->sa_flags = tswapl(k->sa_flags);
520 #if !defined(TARGET_MIPS)
521 oact->sa_restorer = tswapl(k->sa_restorer);
522 #endif
523 oact->sa_mask = k->sa_mask;
524 }
525 if (act) {
526 /* FIXME: This is not threadsafe. */
527 k->_sa_handler = tswapl(act->_sa_handler);
528 k->sa_flags = tswapl(act->sa_flags);
529 #if !defined(TARGET_MIPS)
530 k->sa_restorer = tswapl(act->sa_restorer);
531 #endif
532 k->sa_mask = act->sa_mask;
533
534 /* we update the host linux signal state */
535 host_sig = target_to_host_signal(sig);
536 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
537 sigfillset(&act1.sa_mask);
538 act1.sa_flags = SA_SIGINFO;
539 if (k->sa_flags & TARGET_SA_RESTART)
540 act1.sa_flags |= SA_RESTART;
541 /* NOTE: it is important to update the host kernel signal
542 ignore state to avoid getting unexpected interrupted
543 syscalls */
544 if (k->_sa_handler == TARGET_SIG_IGN) {
545 act1.sa_sigaction = (void *)SIG_IGN;
546 } else if (k->_sa_handler == TARGET_SIG_DFL) {
547 act1.sa_sigaction = (void *)SIG_DFL;
548 } else {
549 act1.sa_sigaction = host_signal_handler;
550 }
551 ret = sigaction(host_sig, &act1, NULL);
552 }
553 }
554 return ret;
555 }
556
557 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
558 const target_siginfo_t *info)
559 {
560 tswap_siginfo(tinfo, info);
561 return 0;
562 }
563
564 static inline int current_exec_domain_sig(int sig)
565 {
566 return /* current->exec_domain && current->exec_domain->signal_invmap
567 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig;
568 }
569
570 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
571
572 /* from the Linux kernel */
573
574 struct target_fpreg {
575 uint16_t significand[4];
576 uint16_t exponent;
577 };
578
579 struct target_fpxreg {
580 uint16_t significand[4];
581 uint16_t exponent;
582 uint16_t padding[3];
583 };
584
585 struct target_xmmreg {
586 abi_ulong element[4];
587 };
588
589 struct target_fpstate {
590 /* Regular FPU environment */
591 abi_ulong cw;
592 abi_ulong sw;
593 abi_ulong tag;
594 abi_ulong ipoff;
595 abi_ulong cssel;
596 abi_ulong dataoff;
597 abi_ulong datasel;
598 struct target_fpreg _st[8];
599 uint16_t status;
600 uint16_t magic; /* 0xffff = regular FPU data only */
601
602 /* FXSR FPU environment */
603 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
604 abi_ulong mxcsr;
605 abi_ulong reserved;
606 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
607 struct target_xmmreg _xmm[8];
608 abi_ulong padding[56];
609 };
610
611 #define X86_FXSR_MAGIC 0x0000
612
613 struct target_sigcontext {
614 uint16_t gs, __gsh;
615 uint16_t fs, __fsh;
616 uint16_t es, __esh;
617 uint16_t ds, __dsh;
618 abi_ulong edi;
619 abi_ulong esi;
620 abi_ulong ebp;
621 abi_ulong esp;
622 abi_ulong ebx;
623 abi_ulong edx;
624 abi_ulong ecx;
625 abi_ulong eax;
626 abi_ulong trapno;
627 abi_ulong err;
628 abi_ulong eip;
629 uint16_t cs, __csh;
630 abi_ulong eflags;
631 abi_ulong esp_at_signal;
632 uint16_t ss, __ssh;
633 abi_ulong fpstate; /* pointer */
634 abi_ulong oldmask;
635 abi_ulong cr2;
636 };
637
638 struct target_ucontext {
639 abi_ulong tuc_flags;
640 abi_ulong tuc_link;
641 target_stack_t tuc_stack;
642 struct target_sigcontext tuc_mcontext;
643 target_sigset_t tuc_sigmask; /* mask last for extensibility */
644 };
645
646 struct sigframe
647 {
648 abi_ulong pretcode;
649 int sig;
650 struct target_sigcontext sc;
651 struct target_fpstate fpstate;
652 abi_ulong extramask[TARGET_NSIG_WORDS-1];
653 char retcode[8];
654 };
655
656 struct rt_sigframe
657 {
658 abi_ulong pretcode;
659 int sig;
660 abi_ulong pinfo;
661 abi_ulong puc;
662 struct target_siginfo info;
663 struct target_ucontext uc;
664 struct target_fpstate fpstate;
665 char retcode[8];
666 };
667
668 /*
669 * Set up a signal frame.
670 */
671
672 /* XXX: save x87 state */
673 static int
674 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
675 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr)
676 {
677 int err = 0;
678 uint16_t magic;
679
680 /* already locked in setup_frame() */
681 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
682 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
683 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
684 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
685 err |= __put_user(env->regs[R_EDI], &sc->edi);
686 err |= __put_user(env->regs[R_ESI], &sc->esi);
687 err |= __put_user(env->regs[R_EBP], &sc->ebp);
688 err |= __put_user(env->regs[R_ESP], &sc->esp);
689 err |= __put_user(env->regs[R_EBX], &sc->ebx);
690 err |= __put_user(env->regs[R_EDX], &sc->edx);
691 err |= __put_user(env->regs[R_ECX], &sc->ecx);
692 err |= __put_user(env->regs[R_EAX], &sc->eax);
693 err |= __put_user(env->exception_index, &sc->trapno);
694 err |= __put_user(env->error_code, &sc->err);
695 err |= __put_user(env->eip, &sc->eip);
696 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
697 err |= __put_user(env->eflags, &sc->eflags);
698 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
699 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
700
701 cpu_x86_fsave(env, fpstate_addr, 1);
702 fpstate->status = fpstate->sw;
703 magic = 0xffff;
704 err |= __put_user(magic, &fpstate->magic);
705 err |= __put_user(fpstate_addr, &sc->fpstate);
706
707 /* non-iBCS2 extensions.. */
708 err |= __put_user(mask, &sc->oldmask);
709 err |= __put_user(env->cr[2], &sc->cr2);
710 return err;
711 }
712
713 /*
714 * Determine which stack to use..
715 */
716
717 static inline abi_ulong
718 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
719 {
720 unsigned long esp;
721
722 /* Default to using normal stack */
723 esp = env->regs[R_ESP];
724 /* This is the X/Open sanctioned signal stack switching. */
725 if (ka->sa_flags & TARGET_SA_ONSTACK) {
726 if (sas_ss_flags(esp) == 0)
727 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
728 }
729
730 /* This is the legacy signal stack switching. */
731 else
732 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
733 !(ka->sa_flags & TARGET_SA_RESTORER) &&
734 ka->sa_restorer) {
735 esp = (unsigned long) ka->sa_restorer;
736 }
737 return (esp - frame_size) & -8ul;
738 }
739
740 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
741 static void setup_frame(int sig, struct target_sigaction *ka,
742 target_sigset_t *set, CPUX86State *env)
743 {
744 abi_ulong frame_addr;
745 struct sigframe *frame;
746 int i, err = 0;
747
748 frame_addr = get_sigframe(ka, env, sizeof(*frame));
749
750 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
751 goto give_sigsegv;
752
753 err |= __put_user(current_exec_domain_sig(sig),
754 &frame->sig);
755 if (err)
756 goto give_sigsegv;
757
758 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
759 frame_addr + offsetof(struct sigframe, fpstate));
760 if (err)
761 goto give_sigsegv;
762
763 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
764 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
765 goto give_sigsegv;
766 }
767
768 /* Set up to return from userspace. If provided, use a stub
769 already in userspace. */
770 if (ka->sa_flags & TARGET_SA_RESTORER) {
771 err |= __put_user(ka->sa_restorer, &frame->pretcode);
772 } else {
773 uint16_t val16;
774 abi_ulong retcode_addr;
775 retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
776 err |= __put_user(retcode_addr, &frame->pretcode);
777 /* This is popl %eax ; movl $,%eax ; int $0x80 */
778 val16 = 0xb858;
779 err |= __put_user(val16, (uint16_t *)(frame->retcode+0));
780 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
781 val16 = 0x80cd;
782 err |= __put_user(val16, (uint16_t *)(frame->retcode+6));
783 }
784
785 if (err)
786 goto give_sigsegv;
787
788 /* Set up registers for signal handler */
789 env->regs[R_ESP] = frame_addr;
790 env->eip = ka->_sa_handler;
791
792 cpu_x86_load_seg(env, R_DS, __USER_DS);
793 cpu_x86_load_seg(env, R_ES, __USER_DS);
794 cpu_x86_load_seg(env, R_SS, __USER_DS);
795 cpu_x86_load_seg(env, R_CS, __USER_CS);
796 env->eflags &= ~TF_MASK;
797
798 unlock_user_struct(frame, frame_addr, 1);
799
800 return;
801
802 give_sigsegv:
803 unlock_user_struct(frame, frame_addr, 1);
804 if (sig == TARGET_SIGSEGV)
805 ka->_sa_handler = TARGET_SIG_DFL;
806 force_sig(TARGET_SIGSEGV /* , current */);
807 }
808
809 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
810 static void setup_rt_frame(int sig, struct target_sigaction *ka,
811 target_siginfo_t *info,
812 target_sigset_t *set, CPUX86State *env)
813 {
814 abi_ulong frame_addr, addr;
815 struct rt_sigframe *frame;
816 int i, err = 0;
817
818 frame_addr = get_sigframe(ka, env, sizeof(*frame));
819
820 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
821 goto give_sigsegv;
822
823 err |= __put_user(current_exec_domain_sig(sig),
824 &frame->sig);
825 addr = frame_addr + offsetof(struct rt_sigframe, info);
826 err |= __put_user(addr, &frame->pinfo);
827 addr = frame_addr + offsetof(struct rt_sigframe, uc);
828 err |= __put_user(addr, &frame->puc);
829 err |= copy_siginfo_to_user(&frame->info, info);
830 if (err)
831 goto give_sigsegv;
832
833 /* Create the ucontext. */
834 err |= __put_user(0, &frame->uc.tuc_flags);
835 err |= __put_user(0, &frame->uc.tuc_link);
836 err |= __put_user(target_sigaltstack_used.ss_sp,
837 &frame->uc.tuc_stack.ss_sp);
838 err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
839 &frame->uc.tuc_stack.ss_flags);
840 err |= __put_user(target_sigaltstack_used.ss_size,
841 &frame->uc.tuc_stack.ss_size);
842 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
843 env, set->sig[0],
844 frame_addr + offsetof(struct rt_sigframe, fpstate));
845 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
846 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
847 goto give_sigsegv;
848 }
849
850 /* Set up to return from userspace. If provided, use a stub
851 already in userspace. */
852 if (ka->sa_flags & TARGET_SA_RESTORER) {
853 err |= __put_user(ka->sa_restorer, &frame->pretcode);
854 } else {
855 uint16_t val16;
856 addr = frame_addr + offsetof(struct rt_sigframe, retcode);
857 err |= __put_user(addr, &frame->pretcode);
858 /* This is movl $,%eax ; int $0x80 */
859 err |= __put_user(0xb8, (char *)(frame->retcode+0));
860 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
861 val16 = 0x80cd;
862 err |= __put_user(val16, (uint16_t *)(frame->retcode+5));
863 }
864
865 if (err)
866 goto give_sigsegv;
867
868 /* Set up registers for signal handler */
869 env->regs[R_ESP] = frame_addr;
870 env->eip = ka->_sa_handler;
871
872 cpu_x86_load_seg(env, R_DS, __USER_DS);
873 cpu_x86_load_seg(env, R_ES, __USER_DS);
874 cpu_x86_load_seg(env, R_SS, __USER_DS);
875 cpu_x86_load_seg(env, R_CS, __USER_CS);
876 env->eflags &= ~TF_MASK;
877
878 unlock_user_struct(frame, frame_addr, 1);
879
880 return;
881
882 give_sigsegv:
883 unlock_user_struct(frame, frame_addr, 1);
884 if (sig == TARGET_SIGSEGV)
885 ka->_sa_handler = TARGET_SIG_DFL;
886 force_sig(TARGET_SIGSEGV /* , current */);
887 }
888
889 static int
890 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
891 {
892 unsigned int err = 0;
893 abi_ulong fpstate_addr;
894 unsigned int tmpflags;
895
896 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
897 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
898 cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
899 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
900
901 env->regs[R_EDI] = tswapl(sc->edi);
902 env->regs[R_ESI] = tswapl(sc->esi);
903 env->regs[R_EBP] = tswapl(sc->ebp);
904 env->regs[R_ESP] = tswapl(sc->esp);
905 env->regs[R_EBX] = tswapl(sc->ebx);
906 env->regs[R_EDX] = tswapl(sc->edx);
907 env->regs[R_ECX] = tswapl(sc->ecx);
908 env->eip = tswapl(sc->eip);
909
910 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
911 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
912
913 tmpflags = tswapl(sc->eflags);
914 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
915 // regs->orig_eax = -1; /* disable syscall checks */
916
917 fpstate_addr = tswapl(sc->fpstate);
918 if (fpstate_addr != 0) {
919 if (!access_ok(VERIFY_READ, fpstate_addr,
920 sizeof(struct target_fpstate)))
921 goto badframe;
922 cpu_x86_frstor(env, fpstate_addr, 1);
923 }
924
925 *peax = tswapl(sc->eax);
926 return err;
927 badframe:
928 return 1;
929 }
930
931 long do_sigreturn(CPUX86State *env)
932 {
933 struct sigframe *frame;
934 abi_ulong frame_addr = env->regs[R_ESP] - 8;
935 target_sigset_t target_set;
936 sigset_t set;
937 int eax, i;
938
939 #if defined(DEBUG_SIGNAL)
940 fprintf(stderr, "do_sigreturn\n");
941 #endif
942 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
943 goto badframe;
944 /* set blocked signals */
945 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
946 goto badframe;
947 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
948 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
949 goto badframe;
950 }
951
952 target_to_host_sigset_internal(&set, &target_set);
953 sigprocmask(SIG_SETMASK, &set, NULL);
954
955 /* restore registers */
956 if (restore_sigcontext(env, &frame->sc, &eax))
957 goto badframe;
958 unlock_user_struct(frame, frame_addr, 0);
959 return eax;
960
961 badframe:
962 unlock_user_struct(frame, frame_addr, 0);
963 force_sig(TARGET_SIGSEGV);
964 return 0;
965 }
966
967 long do_rt_sigreturn(CPUX86State *env)
968 {
969 abi_ulong frame_addr;
970 struct rt_sigframe *frame;
971 sigset_t set;
972 int eax;
973
974 frame_addr = env->regs[R_ESP] - 4;
975 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
976 goto badframe;
977 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
978 sigprocmask(SIG_SETMASK, &set, NULL);
979
980 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
981 goto badframe;
982
983 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0,
984 get_sp_from_cpustate(env)) == -EFAULT)
985 goto badframe;
986
987 unlock_user_struct(frame, frame_addr, 0);
988 return eax;
989
990 badframe:
991 unlock_user_struct(frame, frame_addr, 0);
992 force_sig(TARGET_SIGSEGV);
993 return 0;
994 }
995
996 #elif defined(TARGET_ARM)
997
998 struct target_sigcontext {
999 abi_ulong trap_no;
1000 abi_ulong error_code;
1001 abi_ulong oldmask;
1002 abi_ulong arm_r0;
1003 abi_ulong arm_r1;
1004 abi_ulong arm_r2;
1005 abi_ulong arm_r3;
1006 abi_ulong arm_r4;
1007 abi_ulong arm_r5;
1008 abi_ulong arm_r6;
1009 abi_ulong arm_r7;
1010 abi_ulong arm_r8;
1011 abi_ulong arm_r9;
1012 abi_ulong arm_r10;
1013 abi_ulong arm_fp;
1014 abi_ulong arm_ip;
1015 abi_ulong arm_sp;
1016 abi_ulong arm_lr;
1017 abi_ulong arm_pc;
1018 abi_ulong arm_cpsr;
1019 abi_ulong fault_address;
1020 };
1021
1022 struct target_ucontext_v1 {
1023 abi_ulong tuc_flags;
1024 abi_ulong tuc_link;
1025 target_stack_t tuc_stack;
1026 struct target_sigcontext tuc_mcontext;
1027 target_sigset_t tuc_sigmask; /* mask last for extensibility */
1028 };
1029
1030 struct target_ucontext_v2 {
1031 abi_ulong tuc_flags;
1032 abi_ulong tuc_link;
1033 target_stack_t tuc_stack;
1034 struct target_sigcontext tuc_mcontext;
1035 target_sigset_t tuc_sigmask; /* mask last for extensibility */
1036 char __unused[128 - sizeof(sigset_t)];
1037 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1038 };
1039
1040 struct sigframe_v1
1041 {
1042 struct target_sigcontext sc;
1043 abi_ulong extramask[TARGET_NSIG_WORDS-1];
1044 abi_ulong retcode;
1045 };
1046
1047 struct sigframe_v2
1048 {
1049 struct target_ucontext_v2 uc;
1050 abi_ulong retcode;
1051 };
1052
1053 struct rt_sigframe_v1
1054 {
1055 abi_ulong pinfo;
1056 abi_ulong puc;
1057 struct target_siginfo info;
1058 struct target_ucontext_v1 uc;
1059 abi_ulong retcode;
1060 };
1061
1062 struct rt_sigframe_v2
1063 {
1064 struct target_siginfo info;
1065 struct target_ucontext_v2 uc;
1066 abi_ulong retcode;
1067 };
1068
1069 #define TARGET_CONFIG_CPU_32 1
1070
1071 /*
1072 * For ARM syscalls, we encode the syscall number into the instruction.
1073 */
1074 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1075 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1076
1077 /*
1078 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1079 * need two 16-bit instructions.
1080 */
1081 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1082 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1083
1084 static const abi_ulong retcodes[4] = {
1085 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
1086 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
1087 };
1088
1089
1090 #define __get_user_error(x,p,e) __get_user(x, p)
1091
1092 static inline int valid_user_regs(CPUState *regs)
1093 {
1094 return 1;
1095 }
1096
1097 static void
1098 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1099 CPUState *env, abi_ulong mask)
1100 {
1101 __put_user(env->regs[0], &sc->arm_r0);
1102 __put_user(env->regs[1], &sc->arm_r1);
1103 __put_user(env->regs[2], &sc->arm_r2);
1104 __put_user(env->regs[3], &sc->arm_r3);
1105 __put_user(env->regs[4], &sc->arm_r4);
1106 __put_user(env->regs[5], &sc->arm_r5);
1107 __put_user(env->regs[6], &sc->arm_r6);
1108 __put_user(env->regs[7], &sc->arm_r7);
1109 __put_user(env->regs[8], &sc->arm_r8);
1110 __put_user(env->regs[9], &sc->arm_r9);
1111 __put_user(env->regs[10], &sc->arm_r10);
1112 __put_user(env->regs[11], &sc->arm_fp);
1113 __put_user(env->regs[12], &sc->arm_ip);
1114 __put_user(env->regs[13], &sc->arm_sp);
1115 __put_user(env->regs[14], &sc->arm_lr);
1116 __put_user(env->regs[15], &sc->arm_pc);
1117 #ifdef TARGET_CONFIG_CPU_32
1118 __put_user(cpsr_read(env), &sc->arm_cpsr);
1119 #endif
1120
1121 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1122 __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1123 __put_user(/* current->thread.address */ 0, &sc->fault_address);
1124 __put_user(mask, &sc->oldmask);
1125 }
1126
1127 static inline abi_ulong
1128 get_sigframe(struct target_sigaction *ka, CPUState *regs, int framesize)
1129 {
1130 unsigned long sp = regs->regs[13];
1131
1132 /*
1133 * This is the X/Open sanctioned signal stack switching.
1134 */
1135 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
1136 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1137 /*
1138 * ATPCS B01 mandates 8-byte alignment
1139 */
1140 return (sp - framesize) & ~7;
1141 }
1142
1143 static int
1144 setup_return(CPUState *env, struct target_sigaction *ka,
1145 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
1146 {
1147 abi_ulong handler = ka->_sa_handler;
1148 abi_ulong retcode;
1149 int thumb = handler & 1;
1150
1151 if (ka->sa_flags & TARGET_SA_RESTORER) {
1152 retcode = ka->sa_restorer;
1153 } else {
1154 unsigned int idx = thumb;
1155
1156 if (ka->sa_flags & TARGET_SA_SIGINFO)
1157 idx += 2;
1158
1159 if (__put_user(retcodes[idx], rc))
1160 return 1;
1161 #if 0
1162 flush_icache_range((abi_ulong)rc,
1163 (abi_ulong)(rc + 1));
1164 #endif
1165 retcode = rc_addr + thumb;
1166 }
1167
1168 env->regs[0] = usig;
1169 env->regs[13] = frame_addr;
1170 env->regs[14] = retcode;
1171 env->regs[15] = handler & (thumb ? ~1 : ~3);
1172 env->thumb = thumb;
1173
1174 #if 0
1175 #ifdef TARGET_CONFIG_CPU_32
1176 env->cpsr = cpsr;
1177 #endif
1178 #endif
1179
1180 return 0;
1181 }
1182
1183 static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1184 target_sigset_t *set, CPUState *env)
1185 {
1186 struct target_sigaltstack stack;
1187 int i;
1188
1189 /* Clear all the bits of the ucontext we don't use. */
1190 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1191
1192 memset(&stack, 0, sizeof(stack));
1193 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1194 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1195 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1196 memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1197
1198 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1199 /* FIXME: Save coprocessor signal frame. */
1200 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1201 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1202 }
1203 }
1204
1205 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1206 static void setup_frame_v1(int usig, struct target_sigaction *ka,
1207 target_sigset_t *set, CPUState *regs)
1208 {
1209 struct sigframe_v1 *frame;
1210 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1211 int i;
1212
1213 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1214 return;
1215
1216 setup_sigcontext(&frame->sc, regs, set->sig[0]);
1217
1218 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1219 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1220 goto end;
1221 }
1222
1223 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1224 frame_addr + offsetof(struct sigframe_v1, retcode));
1225
1226 end:
1227 unlock_user_struct(frame, frame_addr, 1);
1228 }
1229
1230 static void setup_frame_v2(int usig, struct target_sigaction *ka,
1231 target_sigset_t *set, CPUState *regs)
1232 {
1233 struct sigframe_v2 *frame;
1234 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1235
1236 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1237 return;
1238
1239 setup_sigframe_v2(&frame->uc, set, regs);
1240
1241 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1242 frame_addr + offsetof(struct sigframe_v2, retcode));
1243
1244 unlock_user_struct(frame, frame_addr, 1);
1245 }
1246
1247 static void setup_frame(int usig, struct target_sigaction *ka,
1248 target_sigset_t *set, CPUState *regs)
1249 {
1250 if (get_osversion() >= 0x020612) {
1251 setup_frame_v2(usig, ka, set, regs);
1252 } else {
1253 setup_frame_v1(usig, ka, set, regs);
1254 }
1255 }
1256
1257 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1258 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
1259 target_siginfo_t *info,
1260 target_sigset_t *set, CPUState *env)
1261 {
1262 struct rt_sigframe_v1 *frame;
1263 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1264 struct target_sigaltstack stack;
1265 int i;
1266 abi_ulong info_addr, uc_addr;
1267
1268 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1269 return /* 1 */;
1270
1271 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
1272 __put_user(info_addr, &frame->pinfo);
1273 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
1274 __put_user(uc_addr, &frame->puc);
1275 copy_siginfo_to_user(&frame->info, info);
1276
1277 /* Clear all the bits of the ucontext we don't use. */
1278 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
1279
1280 memset(&stack, 0, sizeof(stack));
1281 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1282 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1283 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1284 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
1285
1286 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
1287 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1288 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
1289 goto end;
1290 }
1291
1292 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1293 frame_addr + offsetof(struct rt_sigframe_v1, retcode));
1294
1295 env->regs[1] = info_addr;
1296 env->regs[2] = uc_addr;
1297
1298 end:
1299 unlock_user_struct(frame, frame_addr, 1);
1300 }
1301
1302 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
1303 target_siginfo_t *info,
1304 target_sigset_t *set, CPUState *env)
1305 {
1306 struct rt_sigframe_v2 *frame;
1307 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1308 abi_ulong info_addr, uc_addr;
1309
1310 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1311 return /* 1 */;
1312
1313 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1314 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
1315 copy_siginfo_to_user(&frame->info, info);
1316
1317 setup_sigframe_v2(&frame->uc, set, env);
1318
1319 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1320 frame_addr + offsetof(struct rt_sigframe_v2, retcode));
1321
1322 env->regs[1] = info_addr;
1323 env->regs[2] = uc_addr;
1324
1325 unlock_user_struct(frame, frame_addr, 1);
1326 }
1327
1328 static void setup_rt_frame(int usig, struct target_sigaction *ka,
1329 target_siginfo_t *info,
1330 target_sigset_t *set, CPUState *env)
1331 {
1332 if (get_osversion() >= 0x020612) {
1333 setup_rt_frame_v2(usig, ka, info, set, env);
1334 } else {
1335 setup_rt_frame_v1(usig, ka, info, set, env);
1336 }
1337 }
1338
1339 static int
1340 restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1341 {
1342 int err = 0;
1343 uint32_t cpsr;
1344
1345 __get_user_error(env->regs[0], &sc->arm_r0, err);
1346 __get_user_error(env->regs[1], &sc->arm_r1, err);
1347 __get_user_error(env->regs[2], &sc->arm_r2, err);
1348 __get_user_error(env->regs[3], &sc->arm_r3, err);
1349 __get_user_error(env->regs[4], &sc->arm_r4, err);
1350 __get_user_error(env->regs[5], &sc->arm_r5, err);
1351 __get_user_error(env->regs[6], &sc->arm_r6, err);
1352 __get_user_error(env->regs[7], &sc->arm_r7, err);
1353 __get_user_error(env->regs[8], &sc->arm_r8, err);
1354 __get_user_error(env->regs[9], &sc->arm_r9, err);
1355 __get_user_error(env->regs[10], &sc->arm_r10, err);
1356 __get_user_error(env->regs[11], &sc->arm_fp, err);
1357 __get_user_error(env->regs[12], &sc->arm_ip, err);
1358 __get_user_error(env->regs[13], &sc->arm_sp, err);
1359 __get_user_error(env->regs[14], &sc->arm_lr, err);
1360 __get_user_error(env->regs[15], &sc->arm_pc, err);
1361 #ifdef TARGET_CONFIG_CPU_32
1362 __get_user_error(cpsr, &sc->arm_cpsr, err);
1363 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
1364 #endif
1365
1366 err |= !valid_user_regs(env);
1367
1368 return err;
1369 }
1370
1371 long do_sigreturn_v1(CPUState *env)
1372 {
1373 abi_ulong frame_addr;
1374 struct sigframe_v1 *frame;
1375 target_sigset_t set;
1376 sigset_t host_set;
1377 int i;
1378
1379 /*
1380 * Since we stacked the signal on a 64-bit boundary,
1381 * then 'sp' should be word aligned here. If it's
1382 * not, then the user is trying to mess with us.
1383 */
1384 if (env->regs[13] & 7)
1385 goto badframe;
1386
1387 frame_addr = env->regs[13];
1388 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1389 goto badframe;
1390
1391 if (__get_user(set.sig[0], &frame->sc.oldmask))
1392 goto badframe;
1393 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1394 if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1395 goto badframe;
1396 }
1397
1398 target_to_host_sigset_internal(&host_set, &set);
1399 sigprocmask(SIG_SETMASK, &host_set, NULL);
1400
1401 if (restore_sigcontext(env, &frame->sc))
1402 goto badframe;
1403
1404 #if 0
1405 /* Send SIGTRAP if we're single-stepping */
1406 if (ptrace_cancel_bpt(current))
1407 send_sig(SIGTRAP, current, 1);
1408 #endif
1409 unlock_user_struct(frame, frame_addr, 0);
1410 return env->regs[0];
1411
1412 badframe:
1413 unlock_user_struct(frame, frame_addr, 0);
1414 force_sig(SIGSEGV /* , current */);
1415 return 0;
1416 }
1417
1418 static int do_sigframe_return_v2(CPUState *env, target_ulong frame_addr,
1419 struct target_ucontext_v2 *uc)
1420 {
1421 sigset_t host_set;
1422
1423 target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1424 sigprocmask(SIG_SETMASK, &host_set, NULL);
1425
1426 if (restore_sigcontext(env, &uc->tuc_mcontext))
1427 return 1;
1428
1429 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1430 return 1;
1431
1432 #if 0
1433 /* Send SIGTRAP if we're single-stepping */
1434 if (ptrace_cancel_bpt(current))
1435 send_sig(SIGTRAP, current, 1);
1436 #endif
1437
1438 return 0;
1439 }
1440
1441 long do_sigreturn_v2(CPUState *env)
1442 {
1443 abi_ulong frame_addr;
1444 struct sigframe_v2 *frame;
1445
1446 /*
1447 * Since we stacked the signal on a 64-bit boundary,
1448 * then 'sp' should be word aligned here. If it's
1449 * not, then the user is trying to mess with us.
1450 */
1451 if (env->regs[13] & 7)
1452 goto badframe;
1453
1454 frame_addr = env->regs[13];
1455 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1456 goto badframe;
1457
1458 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1459 goto badframe;
1460
1461 unlock_user_struct(frame, frame_addr, 0);
1462 return env->regs[0];
1463
1464 badframe:
1465 unlock_user_struct(frame, frame_addr, 0);
1466 force_sig(SIGSEGV /* , current */);
1467 return 0;
1468 }
1469
1470 long do_sigreturn(CPUState *env)
1471 {
1472 if (get_osversion() >= 0x020612) {
1473 return do_sigreturn_v2(env);
1474 } else {
1475 return do_sigreturn_v1(env);
1476 }
1477 }
1478
1479 long do_rt_sigreturn_v1(CPUState *env)
1480 {
1481 abi_ulong frame_addr;
1482 struct rt_sigframe_v1 *frame;
1483 sigset_t host_set;
1484
1485 /*
1486 * Since we stacked the signal on a 64-bit boundary,
1487 * then 'sp' should be word aligned here. If it's
1488 * not, then the user is trying to mess with us.
1489 */
1490 if (env->regs[13] & 7)
1491 goto badframe;
1492
1493 frame_addr = env->regs[13];
1494 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1495 goto badframe;
1496
1497 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1498 sigprocmask(SIG_SETMASK, &host_set, NULL);
1499
1500 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1501 goto badframe;
1502
1503 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1504 goto badframe;
1505
1506 #if 0
1507 /* Send SIGTRAP if we're single-stepping */
1508 if (ptrace_cancel_bpt(current))
1509 send_sig(SIGTRAP, current, 1);
1510 #endif
1511 unlock_user_struct(frame, frame_addr, 0);
1512 return env->regs[0];
1513
1514 badframe:
1515 unlock_user_struct(frame, frame_addr, 0);
1516 force_sig(SIGSEGV /* , current */);
1517 return 0;
1518 }
1519
1520 long do_rt_sigreturn_v2(CPUState *env)
1521 {
1522 abi_ulong frame_addr;
1523 struct rt_sigframe_v2 *frame;
1524
1525 /*
1526 * Since we stacked the signal on a 64-bit boundary,
1527 * then 'sp' should be word aligned here. If it's
1528 * not, then the user is trying to mess with us.
1529 */
1530 if (env->regs[13] & 7)
1531 goto badframe;
1532
1533 frame_addr = env->regs[13];
1534 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1535 goto badframe;
1536
1537 if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1538 goto badframe;
1539
1540 unlock_user_struct(frame, frame_addr, 0);
1541 return env->regs[0];
1542
1543 badframe:
1544 unlock_user_struct(frame, frame_addr, 0);
1545 force_sig(SIGSEGV /* , current */);
1546 return 0;
1547 }
1548
1549 long do_rt_sigreturn(CPUState *env)
1550 {
1551 if (get_osversion() >= 0x020612) {
1552 return do_rt_sigreturn_v2(env);
1553 } else {
1554 return do_rt_sigreturn_v1(env);
1555 }
1556 }
1557
1558 #elif defined(TARGET_SPARC)
1559
1560 #define __SUNOS_MAXWIN 31
1561
1562 /* This is what SunOS does, so shall I. */
1563 struct target_sigcontext {
1564 abi_ulong sigc_onstack; /* state to restore */
1565
1566 abi_ulong sigc_mask; /* sigmask to restore */
1567 abi_ulong sigc_sp; /* stack pointer */
1568 abi_ulong sigc_pc; /* program counter */
1569 abi_ulong sigc_npc; /* next program counter */
1570 abi_ulong sigc_psr; /* for condition codes etc */
1571 abi_ulong sigc_g1; /* User uses these two registers */
1572 abi_ulong sigc_o0; /* within the trampoline code. */
1573
1574 /* Now comes information regarding the users window set
1575 * at the time of the signal.
1576 */
1577 abi_ulong sigc_oswins; /* outstanding windows */
1578
1579 /* stack ptrs for each regwin buf */
1580 char *sigc_spbuf[__SUNOS_MAXWIN];
1581
1582 /* Windows to restore after signal */
1583 struct {
1584 abi_ulong locals[8];
1585 abi_ulong ins[8];
1586 } sigc_wbuf[__SUNOS_MAXWIN];
1587 };
1588 /* A Sparc stack frame */
1589 struct sparc_stackf {
1590 abi_ulong locals[8];
1591 abi_ulong ins[6];
1592 struct sparc_stackf *fp;
1593 abi_ulong callers_pc;
1594 char *structptr;
1595 abi_ulong xargs[6];
1596 abi_ulong xxargs[1];
1597 };
1598
1599 typedef struct {
1600 struct {
1601 abi_ulong psr;
1602 abi_ulong pc;
1603 abi_ulong npc;
1604 abi_ulong y;
1605 abi_ulong u_regs[16]; /* globals and ins */
1606 } si_regs;
1607 int si_mask;
1608 } __siginfo_t;
1609
1610 typedef struct {
1611 unsigned long si_float_regs [32];
1612 unsigned long si_fsr;
1613 unsigned long si_fpqdepth;
1614 struct {
1615 unsigned long *insn_addr;
1616 unsigned long insn;
1617 } si_fpqueue [16];
1618 } qemu_siginfo_fpu_t;
1619
1620
1621 struct target_signal_frame {
1622 struct sparc_stackf ss;
1623 __siginfo_t info;
1624 abi_ulong fpu_save;
1625 abi_ulong insns[2] __attribute__ ((aligned (8)));
1626 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
1627 abi_ulong extra_size; /* Should be 0 */
1628 qemu_siginfo_fpu_t fpu_state;
1629 };
1630 struct target_rt_signal_frame {
1631 struct sparc_stackf ss;
1632 siginfo_t info;
1633 abi_ulong regs[20];
1634 sigset_t mask;
1635 abi_ulong fpu_save;
1636 unsigned int insns[2];
1637 stack_t stack;
1638 unsigned int extra_size; /* Should be 0 */
1639 qemu_siginfo_fpu_t fpu_state;
1640 };
1641
1642 #define UREG_O0 16
1643 #define UREG_O6 22
1644 #define UREG_I0 0
1645 #define UREG_I1 1
1646 #define UREG_I2 2
1647 #define UREG_I3 3
1648 #define UREG_I4 4
1649 #define UREG_I5 5
1650 #define UREG_I6 6
1651 #define UREG_I7 7
1652 #define UREG_L0 8
1653 #define UREG_FP UREG_I6
1654 #define UREG_SP UREG_O6
1655
1656 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
1657 CPUState *env, unsigned long framesize)
1658 {
1659 abi_ulong sp;
1660
1661 sp = env->regwptr[UREG_FP];
1662
1663 /* This is the X/Open sanctioned signal stack switching. */
1664 if (sa->sa_flags & TARGET_SA_ONSTACK) {
1665 if (!on_sig_stack(sp)
1666 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
1667 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1668 }
1669 return sp - framesize;
1670 }
1671
1672 static int
1673 setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask)
1674 {
1675 int err = 0, i;
1676
1677 err |= __put_user(env->psr, &si->si_regs.psr);
1678 err |= __put_user(env->pc, &si->si_regs.pc);
1679 err |= __put_user(env->npc, &si->si_regs.npc);
1680 err |= __put_user(env->y, &si->si_regs.y);
1681 for (i=0; i < 8; i++) {
1682 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1683 }
1684 for (i=0; i < 8; i++) {
1685 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1686 }
1687 err |= __put_user(mask, &si->si_mask);
1688 return err;
1689 }
1690
1691 #if 0
1692 static int
1693 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1694 CPUState *env, unsigned long mask)
1695 {
1696 int err = 0;
1697
1698 err |= __put_user(mask, &sc->sigc_mask);
1699 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1700 err |= __put_user(env->pc, &sc->sigc_pc);
1701 err |= __put_user(env->npc, &sc->sigc_npc);
1702 err |= __put_user(env->psr, &sc->sigc_psr);
1703 err |= __put_user(env->gregs[1], &sc->sigc_g1);
1704 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1705
1706 return err;
1707 }
1708 #endif
1709 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1710
1711 static void setup_frame(int sig, struct target_sigaction *ka,
1712 target_sigset_t *set, CPUState *env)
1713 {
1714 abi_ulong sf_addr;
1715 struct target_signal_frame *sf;
1716 int sigframe_size, err, i;
1717
1718 /* 1. Make sure everything is clean */
1719 //synchronize_user_stack();
1720
1721 sigframe_size = NF_ALIGNEDSZ;
1722 sf_addr = get_sigframe(ka, env, sigframe_size);
1723
1724 sf = lock_user(VERIFY_WRITE, sf_addr,
1725 sizeof(struct target_signal_frame), 0);
1726 if (!sf)
1727 goto sigsegv;
1728
1729 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1730 #if 0
1731 if (invalid_frame_pointer(sf, sigframe_size))
1732 goto sigill_and_return;
1733 #endif
1734 /* 2. Save the current process state */
1735 err = setup___siginfo(&sf->info, env, set->sig[0]);
1736 err |= __put_user(0, &sf->extra_size);
1737
1738 //err |= save_fpu_state(regs, &sf->fpu_state);
1739 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1740
1741 err |= __put_user(set->sig[0], &sf->info.si_mask);
1742 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1743 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1744 }
1745
1746 for (i = 0; i < 8; i++) {
1747 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1748 }
1749 for (i = 0; i < 8; i++) {
1750 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1751 }
1752 if (err)
1753 goto sigsegv;
1754
1755 /* 3. signal handler back-trampoline and parameters */
1756 env->regwptr[UREG_FP] = sf_addr;
1757 env->regwptr[UREG_I0] = sig;
1758 env->regwptr[UREG_I1] = sf_addr +
1759 offsetof(struct target_signal_frame, info);
1760 env->regwptr[UREG_I2] = sf_addr +
1761 offsetof(struct target_signal_frame, info);
1762
1763 /* 4. signal handler */
1764 env->pc = ka->_sa_handler;
1765 env->npc = (env->pc + 4);
1766 /* 5. return to kernel instructions */
1767 if (ka->sa_restorer)
1768 env->regwptr[UREG_I7] = ka->sa_restorer;
1769 else {
1770 uint32_t val32;
1771
1772 env->regwptr[UREG_I7] = sf_addr +
1773 offsetof(struct target_signal_frame, insns) - 2 * 4;
1774
1775 /* mov __NR_sigreturn, %g1 */
1776 val32 = 0x821020d8;
1777 err |= __put_user(val32, &sf->insns[0]);
1778
1779 /* t 0x10 */
1780 val32 = 0x91d02010;
1781 err |= __put_user(val32, &sf->insns[1]);
1782 if (err)
1783 goto sigsegv;
1784
1785 /* Flush instruction space. */
1786 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1787 // tb_flush(env);
1788 }
1789 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
1790 return;
1791 #if 0
1792 sigill_and_return:
1793 force_sig(TARGET_SIGILL);
1794 #endif
1795 sigsegv:
1796 //fprintf(stderr, "force_sig\n");
1797 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
1798 force_sig(TARGET_SIGSEGV);
1799 }
1800 static inline int
1801 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
1802 {
1803 int err;
1804 #if 0
1805 #ifdef CONFIG_SMP
1806 if (current->flags & PF_USEDFPU)
1807 regs->psr &= ~PSR_EF;
1808 #else
1809 if (current == last_task_used_math) {
1810 last_task_used_math = 0;
1811 regs->psr &= ~PSR_EF;
1812 }
1813 #endif
1814 current->used_math = 1;
1815 current->flags &= ~PF_USEDFPU;
1816 #endif
1817 #if 0
1818 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1819 return -EFAULT;
1820 #endif
1821
1822 #if 0
1823 /* XXX: incorrect */
1824 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1825 (sizeof(unsigned long) * 32));
1826 #endif
1827 err |= __get_user(env->fsr, &fpu->si_fsr);
1828 #if 0
1829 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1830 if (current->thread.fpqdepth != 0)
1831 err |= __copy_from_user(&current->thread.fpqueue[0],
1832 &fpu->si_fpqueue[0],
1833 ((sizeof(unsigned long) +
1834 (sizeof(unsigned long *)))*16));
1835 #endif
1836 return err;
1837 }
1838
1839
1840 static void setup_rt_frame(int sig, struct target_sigaction *ka,
1841 target_siginfo_t *info,
1842 target_sigset_t *set, CPUState *env)
1843 {
1844 fprintf(stderr, "setup_rt_frame: not implemented\n");
1845 }
1846
1847 long do_sigreturn(CPUState *env)
1848 {
1849 abi_ulong sf_addr;
1850 struct target_signal_frame *sf;
1851 uint32_t up_psr, pc, npc;
1852 target_sigset_t set;
1853 sigset_t host_set;
1854 abi_ulong fpu_save_addr;
1855 int err, i;
1856
1857 sf_addr = env->regwptr[UREG_FP];
1858 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
1859 goto segv_and_exit;
1860 #if 0
1861 fprintf(stderr, "sigreturn\n");
1862 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1863 #endif
1864 //cpu_dump_state(env, stderr, fprintf, 0);
1865
1866 /* 1. Make sure we are not getting garbage from the user */
1867
1868 if (sf_addr & 3)
1869 goto segv_and_exit;
1870
1871 err = __get_user(pc, &sf->info.si_regs.pc);
1872 err |= __get_user(npc, &sf->info.si_regs.npc);
1873
1874 if ((pc | npc) & 3)
1875 goto segv_and_exit;
1876
1877 /* 2. Restore the state */
1878 err |= __get_user(up_psr, &sf->info.si_regs.psr);
1879
1880 /* User can only change condition codes and FPU enabling in %psr. */
1881 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1882 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1883
1884 env->pc = pc;
1885 env->npc = npc;
1886 err |= __get_user(env->y, &sf->info.si_regs.y);
1887 for (i=0; i < 8; i++) {
1888 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1889 }
1890 for (i=0; i < 8; i++) {
1891 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1892 }
1893
1894 err |= __get_user(fpu_save_addr, &sf->fpu_save);
1895
1896 //if (fpu_save)
1897 // err |= restore_fpu_state(env, fpu_save);
1898
1899 /* This is pretty much atomic, no amount locking would prevent
1900 * the races which exist anyways.
1901 */
1902 err |= __get_user(set.sig[0], &sf->info.si_mask);
1903 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1904 err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1905 }
1906
1907 target_to_host_sigset_internal(&host_set, &set);
1908 sigprocmask(SIG_SETMASK, &host_set, NULL);
1909
1910 if (err)
1911 goto segv_and_exit;
1912 unlock_user_struct(sf, sf_addr, 0);
1913 return env->regwptr[0];
1914
1915 segv_and_exit:
1916 unlock_user_struct(sf, sf_addr, 0);
1917 force_sig(TARGET_SIGSEGV);
1918 }
1919
1920 long do_rt_sigreturn(CPUState *env)
1921 {
1922 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1923 return -TARGET_ENOSYS;
1924 }
1925
1926 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
1927 #define MC_TSTATE 0
1928 #define MC_PC 1
1929 #define MC_NPC 2
1930 #define MC_Y 3
1931 #define MC_G1 4
1932 #define MC_G2 5
1933 #define MC_G3 6
1934 #define MC_G4 7
1935 #define MC_G5 8
1936 #define MC_G6 9
1937 #define MC_G7 10
1938 #define MC_O0 11
1939 #define MC_O1 12
1940 #define MC_O2 13
1941 #define MC_O3 14
1942 #define MC_O4 15
1943 #define MC_O5 16
1944 #define MC_O6 17
1945 #define MC_O7 18
1946 #define MC_NGREG 19
1947
1948 typedef abi_ulong target_mc_greg_t;
1949 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
1950
1951 struct target_mc_fq {
1952 abi_ulong *mcfq_addr;
1953 uint32_t mcfq_insn;
1954 };
1955
1956 struct target_mc_fpu {
1957 union {
1958 uint32_t sregs[32];
1959 uint64_t dregs[32];
1960 //uint128_t qregs[16];
1961 } mcfpu_fregs;
1962 abi_ulong mcfpu_fsr;
1963 abi_ulong mcfpu_fprs;
1964 abi_ulong mcfpu_gsr;
1965 struct target_mc_fq *mcfpu_fq;
1966 unsigned char mcfpu_qcnt;
1967 unsigned char mcfpu_qentsz;
1968 unsigned char mcfpu_enab;
1969 };
1970 typedef struct target_mc_fpu target_mc_fpu_t;
1971
1972 typedef struct {
1973 target_mc_gregset_t mc_gregs;
1974 target_mc_greg_t mc_fp;
1975 target_mc_greg_t mc_i7;
1976 target_mc_fpu_t mc_fpregs;
1977 } target_mcontext_t;
1978
1979 struct target_ucontext {
1980 struct target_ucontext *uc_link;
1981 abi_ulong uc_flags;
1982 target_sigset_t uc_sigmask;
1983 target_mcontext_t uc_mcontext;
1984 };
1985
1986 /* A V9 register window */
1987 struct target_reg_window {
1988 abi_ulong locals[8];
1989 abi_ulong ins[8];
1990 };
1991
1992 #define TARGET_STACK_BIAS 2047
1993
1994 /* {set, get}context() needed for 64-bit SparcLinux userland. */
1995 void sparc64_set_context(CPUSPARCState *env)
1996 {
1997 abi_ulong ucp_addr;
1998 struct target_ucontext *ucp;
1999 target_mc_gregset_t *grp;
2000 abi_ulong pc, npc, tstate;
2001 abi_ulong fp, i7, w_addr;
2002 unsigned char fenab;
2003 int err;
2004 unsigned int i;
2005
2006 ucp_addr = env->regwptr[UREG_I0];
2007 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2008 goto do_sigsegv;
2009 grp = &ucp->uc_mcontext.mc_gregs;
2010 err = __get_user(pc, &((*grp)[MC_PC]));
2011 err |= __get_user(npc, &((*grp)[MC_NPC]));
2012 if (err || ((pc | npc) & 3))
2013 goto do_sigsegv;
2014 if (env->regwptr[UREG_I1]) {
2015 target_sigset_t target_set;
2016 sigset_t set;
2017
2018 if (TARGET_NSIG_WORDS == 1) {
2019 if (__get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0]))
2020 goto do_sigsegv;
2021 } else {
2022 abi_ulong *src, *dst;
2023 src = ucp->uc_sigmask.sig;
2024 dst = target_set.sig;
2025 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2026 i++, dst++, src++)
2027 err |= __get_user(*dst, src);
2028 if (err)
2029 goto do_sigsegv;
2030 }
2031 target_to_host_sigset_internal(&set, &target_set);
2032 sigprocmask(SIG_SETMASK, &set, NULL);
2033 }
2034 env->pc = pc;
2035 env->npc = npc;
2036 err |= __get_user(env->y, &((*grp)[MC_Y]));
2037 err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
2038 env->asi = (tstate >> 24) & 0xff;
2039 PUT_CCR(env, tstate >> 32);
2040 PUT_CWP64(env, tstate & 0x1f);
2041 err |= __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2042 err |= __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2043 err |= __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2044 err |= __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2045 err |= __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2046 err |= __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2047 err |= __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2048 err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2049 err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2050 err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2051 err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2052 err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2053 err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2054 err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2055 err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2056
2057 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));
2058 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));
2059
2060 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2061 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2062 abi_ulong) != 0)
2063 goto do_sigsegv;
2064 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2065 abi_ulong) != 0)
2066 goto do_sigsegv;
2067 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
2068 err |= __get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
2069 {
2070 uint32_t *src, *dst;
2071 src = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2072 dst = env->fpr;
2073 /* XXX: check that the CPU storage is the same as user context */
2074 for (i = 0; i < 64; i++, dst++, src++)
2075 err |= __get_user(*dst, src);
2076 }
2077 err |= __get_user(env->fsr,
2078 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
2079 err |= __get_user(env->gsr,
2080 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
2081 if (err)
2082 goto do_sigsegv;
2083 unlock_user_struct(ucp, ucp_addr, 0);
2084 return;
2085 do_sigsegv:
2086 unlock_user_struct(ucp, ucp_addr, 0);
2087 force_sig(SIGSEGV);
2088 }
2089
2090 void sparc64_get_context(CPUSPARCState *env)
2091 {
2092 abi_ulong ucp_addr;
2093 struct target_ucontext *ucp;
2094 target_mc_gregset_t *grp;
2095 target_mcontext_t *mcp;
2096 abi_ulong fp, i7, w_addr;
2097 int err;
2098 unsigned int i;
2099 target_sigset_t target_set;
2100 sigset_t set;
2101
2102 ucp_addr = env->regwptr[UREG_I0];
2103 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2104 goto do_sigsegv;
2105
2106 mcp = &ucp->uc_mcontext;
2107 grp = &mcp->mc_gregs;
2108
2109 /* Skip over the trap instruction, first. */
2110 env->pc = env->npc;
2111 env->npc += 4;
2112
2113 err = 0;
2114
2115 sigprocmask(0, NULL, &set);
2116 host_to_target_sigset_internal(&target_set, &set);
2117 if (TARGET_NSIG_WORDS == 1) {
2118 err |= __put_user(target_set.sig[0],
2119 (abi_ulong *)&ucp->uc_sigmask);
2120 } else {
2121 abi_ulong *src, *dst;
2122 src = target_set.sig;
2123 dst = ucp->uc_sigmask.sig;
2124 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2125 i++, dst++, src++)
2126 err |= __put_user(*src, dst);
2127 if (err)
2128 goto do_sigsegv;
2129 }
2130
2131 /* XXX: tstate must be saved properly */
2132 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2133 err |= __put_user(env->pc, &((*grp)[MC_PC]));
2134 err |= __put_user(env->npc, &((*grp)[MC_NPC]));
2135 err |= __put_user(env->y, &((*grp)[MC_Y]));
2136 err |= __put_user(env->gregs[1], &((*grp)[MC_G1]));
2137 err |= __put_user(env->gregs[2], &((*grp)[MC_G2]));
2138 err |= __put_user(env->gregs[3], &((*grp)[MC_G3]));
2139 err |= __put_user(env->gregs[4], &((*grp)[MC_G4]));
2140 err |= __put_user(env->gregs[5], &((*grp)[MC_G5]));
2141 err |= __put_user(env->gregs[6], &((*grp)[MC_G6]));
2142 err |= __put_user(env->gregs[7], &((*grp)[MC_G7]));
2143 err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2144 err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2145 err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2146 err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2147 err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2148 err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2149 err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2150 err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2151
2152 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2153 fp = i7 = 0;
2154 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2155 abi_ulong) != 0)
2156 goto do_sigsegv;
2157 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2158 abi_ulong) != 0)
2159 goto do_sigsegv;
2160 err |= __put_user(fp, &(mcp->mc_fp));
2161 err |= __put_user(i7, &(mcp->mc_i7));
2162
2163 {
2164 uint32_t *src, *dst;
2165 src = env->fpr;
2166 dst = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2167 /* XXX: check that the CPU storage is the same as user context */
2168 for (i = 0; i < 64; i++, dst++, src++)
2169 err |= __put_user(*src, dst);
2170 }
2171 err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2172 err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2173 err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
2174
2175 if (err)
2176 goto do_sigsegv;
2177 unlock_user_struct(ucp, ucp_addr, 1);
2178 return;
2179 do_sigsegv:
2180 unlock_user_struct(ucp, ucp_addr, 1);
2181 force_sig(SIGSEGV);
2182 }
2183 #endif
2184 #elif defined(TARGET_ABI_MIPSN64)
2185
2186 # warning signal handling not implemented
2187
2188 static void setup_frame(int sig, struct target_sigaction *ka,
2189 target_sigset_t *set, CPUState *env)
2190 {
2191 fprintf(stderr, "setup_frame: not implemented\n");
2192 }
2193
2194 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2195 target_siginfo_t *info,
2196 target_sigset_t *set, CPUState *env)
2197 {
2198 fprintf(stderr, "setup_rt_frame: not implemented\n");
2199 }
2200
2201 long do_sigreturn(CPUState *env)
2202 {
2203 fprintf(stderr, "do_sigreturn: not implemented\n");
2204 return -TARGET_ENOSYS;
2205 }
2206
2207 long do_rt_sigreturn(CPUState *env)
2208 {
2209 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2210 return -TARGET_ENOSYS;
2211 }
2212
2213 #elif defined(TARGET_ABI_MIPSN32)
2214
2215 # warning signal handling not implemented
2216
2217 static void setup_frame(int sig, struct target_sigaction *ka,
2218 target_sigset_t *set, CPUState *env)
2219 {
2220 fprintf(stderr, "setup_frame: not implemented\n");
2221 }
2222
2223 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2224 target_siginfo_t *info,
2225 target_sigset_t *set, CPUState *env)
2226 {
2227 fprintf(stderr, "setup_rt_frame: not implemented\n");
2228 }
2229
2230 long do_sigreturn(CPUState *env)
2231 {
2232 fprintf(stderr, "do_sigreturn: not implemented\n");
2233 return -TARGET_ENOSYS;
2234 }
2235
2236 long do_rt_sigreturn(CPUState *env)
2237 {
2238 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2239 return -TARGET_ENOSYS;
2240 }
2241
2242 #elif defined(TARGET_ABI_MIPSO32)
2243
2244 struct target_sigcontext {
2245 uint32_t sc_regmask; /* Unused */
2246 uint32_t sc_status;
2247 uint64_t sc_pc;
2248 uint64_t sc_regs[32];
2249 uint64_t sc_fpregs[32];
2250 uint32_t sc_ownedfp; /* Unused */
2251 uint32_t sc_fpc_csr;
2252 uint32_t sc_fpc_eir; /* Unused */
2253 uint32_t sc_used_math;
2254 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
2255 uint64_t sc_mdhi;
2256 uint64_t sc_mdlo;
2257 target_ulong sc_hi1; /* Was sc_cause */
2258 target_ulong sc_lo1; /* Was sc_badvaddr */
2259 target_ulong sc_hi2; /* Was sc_sigset[4] */
2260 target_ulong sc_lo2;
2261 target_ulong sc_hi3;
2262 target_ulong sc_lo3;
2263 };
2264
2265 struct sigframe {
2266 uint32_t sf_ass[4]; /* argument save space for o32 */
2267 uint32_t sf_code[2]; /* signal trampoline */
2268 struct target_sigcontext sf_sc;
2269 target_sigset_t sf_mask;
2270 };
2271
2272 /* Install trampoline to jump back from signal handler */
2273 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
2274 {
2275 int err;
2276
2277 /*
2278 * Set up the return code ...
2279 *
2280 * li v0, __NR__foo_sigreturn
2281 * syscall
2282 */
2283
2284 err = __put_user(0x24020000 + syscall, tramp + 0);
2285 err |= __put_user(0x0000000c , tramp + 1);
2286 /* flush_cache_sigtramp((unsigned long) tramp); */
2287 return err;
2288 }
2289
2290 static inline int
2291 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2292 {
2293 int err = 0;
2294
2295 err |= __put_user(regs->active_tc.PC, &sc->sc_pc);
2296
2297 #define save_gp_reg(i) do { \
2298 err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
2299 } while(0)
2300 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
2301 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2302 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2303 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2304 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2305 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2306 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2307 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2308 save_gp_reg(31);
2309 #undef save_gp_reg
2310
2311 err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2312 err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2313
2314 /* Not used yet, but might be useful if we ever have DSP suppport */
2315 #if 0
2316 if (cpu_has_dsp) {
2317 err |= __put_user(mfhi1(), &sc->sc_hi1);
2318 err |= __put_user(mflo1(), &sc->sc_lo1);
2319 err |= __put_user(mfhi2(), &sc->sc_hi2);
2320 err |= __put_user(mflo2(), &sc->sc_lo2);
2321 err |= __put_user(mfhi3(), &sc->sc_hi3);
2322 err |= __put_user(mflo3(), &sc->sc_lo3);
2323 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2324 }
2325 /* same with 64 bit */
2326 #ifdef CONFIG_64BIT
2327 err |= __put_user(regs->hi, &sc->sc_hi[0]);
2328 err |= __put_user(regs->lo, &sc->sc_lo[0]);
2329 if (cpu_has_dsp) {
2330 err |= __put_user(mfhi1(), &sc->sc_hi[1]);
2331 err |= __put_user(mflo1(), &sc->sc_lo[1]);
2332 err |= __put_user(mfhi2(), &sc->sc_hi[2]);
2333 err |= __put_user(mflo2(), &sc->sc_lo[2]);
2334 err |= __put_user(mfhi3(), &sc->sc_hi[3]);
2335 err |= __put_user(mflo3(), &sc->sc_lo[3]);
2336 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2337 }
2338 #endif
2339 #endif
2340
2341 #if 0
2342 err |= __put_user(!!used_math(), &sc->sc_used_math);
2343
2344 if (!used_math())
2345 goto out;
2346
2347 /*
2348 * Save FPU state to signal context. Signal handler will "inherit"
2349 * current FPU state.
2350 */
2351 preempt_disable();
2352
2353 if (!is_fpu_owner()) {
2354 own_fpu();
2355 restore_fp(current);
2356 }
2357 err |= save_fp_context(sc);
2358
2359 preempt_enable();
2360 out:
2361 #endif
2362 return err;
2363 }
2364
2365 static inline int
2366 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2367 {
2368 int err = 0;
2369
2370 err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
2371
2372 err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2373 err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2374
2375 #define restore_gp_reg(i) do { \
2376 err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
2377 } while(0)
2378 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2379 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2380 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2381 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2382 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2383 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2384 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2385 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2386 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2387 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2388 restore_gp_reg(31);
2389 #undef restore_gp_reg
2390
2391 #if 0
2392 if (cpu_has_dsp) {
2393 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
2394 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
2395 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
2396 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
2397 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
2398 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
2399 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2400 }
2401 #ifdef CONFIG_64BIT
2402 err |= __get_user(regs->hi, &sc->sc_hi[0]);
2403 err |= __get_user(regs->lo, &sc->sc_lo[0]);
2404 if (cpu_has_dsp) {
2405 err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
2406 err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
2407 err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
2408 err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
2409 err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
2410 err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
2411 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2412 }
2413 #endif
2414
2415 err |= __get_user(used_math, &sc->sc_used_math);
2416 conditional_used_math(used_math);
2417
2418 preempt_disable();
2419
2420 if (used_math()) {
2421 /* restore fpu context if we have used it before */
2422 own_fpu();
2423 err |= restore_fp_context(sc);
2424 } else {
2425 /* signal handler may have used FPU. Give it up. */
2426 lose_fpu();
2427 }
2428
2429 preempt_enable();
2430 #endif
2431 return err;
2432 }
2433 /*
2434 * Determine which stack to use..
2435 */
2436 static inline abi_ulong
2437 get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
2438 {
2439 unsigned long sp;
2440
2441 /* Default to using normal stack */
2442 sp = regs->active_tc.gpr[29];
2443
2444 /*
2445 * FPU emulator may have it's own trampoline active just
2446 * above the user stack, 16-bytes before the next lowest
2447 * 16 byte boundary. Try to avoid trashing it.
2448 */
2449 sp -= 32;
2450
2451 /* This is the X/Open sanctioned signal stack switching. */
2452 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
2453 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2454 }
2455
2456 return (sp - frame_size) & ~7;
2457 }
2458
2459 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2460 static void setup_frame(int sig, struct target_sigaction * ka,
2461 target_sigset_t *set, CPUState *regs)
2462 {
2463 struct sigframe *frame;
2464 abi_ulong frame_addr;
2465 int i;
2466
2467 frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2468 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2469 goto give_sigsegv;
2470
2471 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2472
2473 if(setup_sigcontext(regs, &frame->sf_sc))
2474 goto give_sigsegv;
2475
2476 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2477 if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2478 goto give_sigsegv;
2479 }
2480
2481 /*
2482 * Arguments to signal handler:
2483 *
2484 * a0 = signal number
2485 * a1 = 0 (should be cause)
2486 * a2 = pointer to struct sigcontext
2487 *
2488 * $25 and PC point to the signal handler, $29 points to the
2489 * struct sigframe.
2490 */
2491 regs->active_tc.gpr[ 4] = sig;
2492 regs->active_tc.gpr[ 5] = 0;
2493 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2494 regs->active_tc.gpr[29] = frame_addr;
2495 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
2496 /* The original kernel code sets CP0_EPC to the handler
2497 * since it returns to userland using eret
2498 * we cannot do this here, and we must set PC directly */
2499 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
2500 unlock_user_struct(frame, frame_addr, 1);
2501 return;
2502
2503 give_sigsegv:
2504 unlock_user_struct(frame, frame_addr, 1);
2505 force_sig(TARGET_SIGSEGV/*, current*/);
2506 return;
2507 }
2508
2509 long do_sigreturn(CPUState *regs)
2510 {
2511 struct sigframe *frame;
2512 abi_ulong frame_addr;
2513 sigset_t blocked;
2514 target_sigset_t target_set;
2515 int i;
2516
2517 #if defined(DEBUG_SIGNAL)
2518 fprintf(stderr, "do_sigreturn\n");
2519 #endif
2520 frame_addr = regs->active_tc.gpr[29];
2521 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2522 goto badframe;
2523
2524 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2525 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
2526 goto badframe;
2527 }
2528
2529 target_to_host_sigset_internal(&blocked, &target_set);
2530 sigprocmask(SIG_SETMASK, &blocked, NULL);
2531
2532 if (restore_sigcontext(regs, &frame->sf_sc))
2533 goto badframe;
2534
2535 #if 0
2536 /*
2537 * Don't let your children do this ...
2538 */
2539 __asm__ __volatile__(
2540 "move\t$29, %0\n\t"
2541 "j\tsyscall_exit"
2542 :/* no outputs */
2543 :"r" (&regs));
2544 /* Unreached */
2545 #endif
2546
2547 regs->active_tc.PC = regs->CP0_EPC;
2548 /* I am not sure this is right, but it seems to work
2549 * maybe a problem with nested signals ? */
2550 regs->CP0_EPC = 0;
2551 return 0;
2552
2553 badframe:
2554 force_sig(TARGET_SIGSEGV/*, current*/);
2555 return 0;
2556 }
2557
2558 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2559 target_siginfo_t *info,
2560 target_sigset_t *set, CPUState *env)
2561 {
2562 fprintf(stderr, "setup_rt_frame: not implemented\n");
2563 }
2564
2565 long do_rt_sigreturn(CPUState *env)
2566 {
2567 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2568 return -TARGET_ENOSYS;
2569 }
2570
2571 #elif defined(TARGET_SH4)
2572
2573 /*
2574 * code and data structures from linux kernel:
2575 * include/asm-sh/sigcontext.h
2576 * arch/sh/kernel/signal.c
2577 */
2578
2579 struct target_sigcontext {
2580 target_ulong oldmask;
2581
2582 /* CPU registers */
2583 target_ulong sc_gregs[16];
2584 target_ulong sc_pc;
2585 target_ulong sc_pr;
2586 target_ulong sc_sr;
2587 target_ulong sc_gbr;
2588 target_ulong sc_mach;
2589 target_ulong sc_macl;
2590
2591 /* FPU registers */
2592 target_ulong sc_fpregs[16];
2593 target_ulong sc_xfpregs[16];
2594 unsigned int sc_fpscr;
2595 unsigned int sc_fpul;
2596 unsigned int sc_ownedfp;
2597 };
2598
2599 struct target_sigframe
2600 {
2601 struct target_sigcontext sc;
2602 target_ulong extramask[TARGET_NSIG_WORDS-1];
2603 uint16_t retcode[3];
2604 };
2605
2606
2607 struct target_ucontext {
2608 target_ulong uc_flags;
2609 struct target_ucontext *uc_link;
2610 target_stack_t uc_stack;
2611 struct target_sigcontext uc_mcontext;
2612 target_sigset_t uc_sigmask; /* mask last for extensibility */
2613 };
2614
2615 struct target_rt_sigframe
2616 {
2617 struct target_siginfo info;
2618 struct target_ucontext uc;
2619 uint16_t retcode[3];
2620 };
2621
2622
2623 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2624 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
2625
2626 static abi_ulong get_sigframe(struct target_sigaction *ka,
2627 unsigned long sp, size_t frame_size)
2628 {
2629 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
2630 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2631 }
2632
2633 return (sp - frame_size) & -8ul;
2634 }
2635
2636 static int setup_sigcontext(struct target_sigcontext *sc,
2637 CPUState *regs, unsigned long mask)
2638 {
2639 int err = 0;
2640
2641 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
2642 COPY(gregs[0]); COPY(gregs[1]);
2643 COPY(gregs[2]); COPY(gregs[3]);
2644 COPY(gregs[4]); COPY(gregs[5]);
2645 COPY(gregs[6]); COPY(gregs[7]);
2646 COPY(gregs[8]); COPY(gregs[9]);
2647 COPY(gregs[10]); COPY(gregs[11]);
2648 COPY(gregs[12]); COPY(gregs[13]);
2649 COPY(gregs[14]); COPY(gregs[15]);
2650 COPY(gbr); COPY(mach);
2651 COPY(macl); COPY(pr);
2652 COPY(sr); COPY(pc);
2653 #undef COPY
2654
2655 /* todo: save FPU registers here */
2656
2657 /* non-iBCS2 extensions.. */
2658 err |= __put_user(mask, &sc->oldmask);
2659
2660 return err;
2661 }
2662
2663 static int restore_sigcontext(struct CPUState *regs,
2664 struct target_sigcontext *sc)
2665 {
2666 unsigned int err = 0;
2667
2668 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
2669 COPY(gregs[1]);
2670 COPY(gregs[2]); COPY(gregs[3]);
2671 COPY(gregs[4]); COPY(gregs[5]);
2672 COPY(gregs[6]); COPY(gregs[7]);
2673 COPY(gregs[8]); COPY(gregs[9]);
2674 COPY(gregs[10]); COPY(gregs[11]);
2675 COPY(gregs[12]); COPY(gregs[13]);
2676 COPY(gregs[14]); COPY(gregs[15]);
2677 COPY(gbr); COPY(mach);
2678 COPY(macl); COPY(pr);
2679 COPY(sr); COPY(pc);
2680 #undef COPY
2681
2682 /* todo: restore FPU registers here */
2683
2684 regs->tra = -1; /* disable syscall checks */
2685 return err;
2686 }
2687
2688 static void setup_frame(int sig, struct target_sigaction *ka,
2689 target_sigset_t *set, CPUState *regs)
2690 {
2691 struct target_sigframe *frame;
2692 abi_ulong frame_addr;
2693 int i;
2694 int err = 0;
2695 int signal;
2696
2697 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
2698 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2699 goto give_sigsegv;
2700
2701 signal = current_exec_domain_sig(sig);
2702
2703 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
2704
2705 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
2706 err |= __put_user(set->sig[i + 1], &frame->extramask[i]);
2707 }
2708
2709 /* Set up to return from userspace. If provided, use a stub
2710 already in userspace. */
2711 if (ka->sa_flags & TARGET_SA_RESTORER) {
2712 regs->pr = (unsigned long) ka->sa_restorer;
2713 } else {
2714 /* Generate return code (system call to sigreturn) */
2715 err |= __put_user(MOVW(2), &frame->retcode[0]);
2716 err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
2717 err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
2718 regs->pr = (unsigned long) frame->retcode;
2719 }
2720
2721 if (err)
2722 goto give_sigsegv;
2723
2724 /* Set up registers for signal handler */
2725 regs->gregs[15] = (unsigned long) frame;
2726 regs->gregs[4] = signal; /* Arg for signal handler */
2727 regs->gregs[5] = 0;
2728 regs->gregs[6] = (unsigned long) &frame->sc;
2729 regs->pc = (unsigned long) ka->_sa_handler;
2730
2731 unlock_user_struct(frame, frame_addr, 1);
2732 return;
2733
2734 give_sigsegv:
2735 unlock_user_struct(frame, frame_addr, 1);
2736 force_sig(SIGSEGV);
2737 }
2738
2739 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2740 target_siginfo_t *info,
2741 target_sigset_t *set, CPUState *regs)
2742 {
2743 struct target_rt_sigframe *frame;
2744 abi_ulong frame_addr;
2745 int i;
2746 int err = 0;
2747 int signal;
2748
2749 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
2750 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2751 goto give_sigsegv;
2752
2753 signal = current_exec_domain_sig(sig);
2754
2755 err |= copy_siginfo_to_user(&frame->info, info);
2756
2757 /* Create the ucontext. */
2758 err |= __put_user(0, &frame->uc.uc_flags);
2759 err |= __put_user(0, (unsigned long *)&frame->uc.uc_link);
2760 err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp,
2761 &frame->uc.uc_stack.ss_sp);
2762 err |= __put_user(sas_ss_flags(regs->gregs[15]),
2763 &frame->uc.uc_stack.ss_flags);
2764 err |= __put_user(target_sigaltstack_used.ss_size,
2765 &frame->uc.uc_stack.ss_size);
2766 err |= setup_sigcontext(&frame->uc.uc_mcontext,
2767 regs, set->sig[0]);
2768 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2769 err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]);
2770 }
2771
2772 /* Set up to return from userspace. If provided, use a stub
2773 already in userspace. */
2774 if (ka->sa_flags & TARGET_SA_RESTORER) {
2775 regs->pr = (unsigned long) ka->sa_restorer;
2776 } else {
2777 /* Generate return code (system call to sigreturn) */
2778 err |= __put_user(MOVW(2), &frame->retcode[0]);
2779 err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
2780 err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
2781 regs->pr = (unsigned long) frame->retcode;
2782 }
2783
2784 if (err)
2785 goto give_sigsegv;
2786
2787 /* Set up registers for signal handler */
2788 regs->gregs[15] = (unsigned long) frame;
2789 regs->gregs[4] = signal; /* Arg for signal handler */
2790 regs->gregs[5] = (unsigned long) &frame->info;
2791 regs->gregs[6] = (unsigned long) &frame->uc;
2792 regs->pc = (unsigned long) ka->_sa_handler;
2793
2794 unlock_user_struct(frame, frame_addr, 1);
2795 return;
2796
2797 give_sigsegv:
2798 unlock_user_struct(frame, frame_addr, 1);
2799 force_sig(SIGSEGV);
2800 }
2801
2802 long do_sigreturn(CPUState *regs)
2803 {
2804 struct target_sigframe *frame;
2805 abi_ulong frame_addr;
2806 sigset_t blocked;
2807 target_sigset_t target_set;
2808 int i;
2809 int err = 0;
2810
2811 #if defined(DEBUG_SIGNAL)
2812 fprintf(stderr, "do_sigreturn\n");
2813 #endif
2814 frame_addr = regs->gregs[15];
2815 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2816 goto badframe;
2817
2818 err |= __get_user(target_set.sig[0], &frame->sc.oldmask);
2819 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2820 err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1]));
2821 }
2822
2823 if (err)
2824 goto badframe;
2825
2826 target_to_host_sigset_internal(&blocked, &target_set);
2827 sigprocmask(SIG_SETMASK, &blocked, NULL);
2828
2829 if (restore_sigcontext(regs, &frame->sc))
2830 goto badframe;
2831
2832 unlock_user_struct(frame, frame_addr, 0);
2833 return regs->gregs[0];
2834
2835 badframe:
2836 unlock_user_struct(frame, frame_addr, 0);
2837 force_sig(TARGET_SIGSEGV);
2838 return 0;
2839 }
2840
2841 long do_rt_sigreturn(CPUState *regs)
2842 {
2843 struct target_rt_sigframe *frame;
2844 abi_ulong frame_addr;
2845 sigset_t blocked;
2846
2847 #if defined(DEBUG_SIGNAL)
2848 fprintf(stderr, "do_rt_sigreturn\n");
2849 #endif
2850 frame_addr = regs->gregs[15];
2851 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2852 goto badframe;
2853
2854 target_to_host_sigset(&blocked, &frame->uc.uc_sigmask);
2855 sigprocmask(SIG_SETMASK, &blocked, NULL);
2856
2857 if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
2858 goto badframe;
2859
2860 if (do_sigaltstack(frame_addr +
2861 offsetof(struct target_rt_sigframe, uc.uc_stack),
2862 0, get_sp_from_cpustate(regs)) == -EFAULT)
2863 goto badframe;
2864
2865 unlock_user_struct(frame, frame_addr, 0);
2866 return regs->gregs[0];
2867
2868 badframe:
2869 unlock_user_struct(frame, frame_addr, 0);
2870 force_sig(TARGET_SIGSEGV);
2871 return 0;
2872 }
2873 #elif defined(TARGET_CRIS)
2874
2875 struct target_sigcontext {
2876 struct target_pt_regs regs; /* needs to be first */
2877 uint32_t oldmask;
2878 uint32_t usp; /* usp before stacking this gunk on it */
2879 };
2880
2881 /* Signal frames. */
2882 struct target_signal_frame {
2883 struct target_sigcontext sc;
2884 uint32_t extramask[TARGET_NSIG_WORDS - 1];
2885 uint8_t retcode[8]; /* Trampoline code. */
2886 };
2887
2888 struct rt_signal_frame {
2889 struct siginfo *pinfo;
2890 void *puc;
2891 struct siginfo info;
2892 struct ucontext uc;
2893 uint8_t retcode[8]; /* Trampoline code. */
2894 };
2895
2896 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
2897 {
2898 __put_user(env->regs[0], &sc->regs.r0);
2899 __put_user(env->regs[1], &sc->regs.r1);
2900 __put_user(env->regs[2], &sc->regs.r2);
2901 __put_user(env->regs[3], &sc->regs.r3);
2902 __put_user(env->regs[4], &sc->regs.r4);
2903 __put_user(env->regs[5], &sc->regs.r5);
2904 __put_user(env->regs[6], &sc->regs.r6);
2905 __put_user(env->regs[7], &sc->regs.r7);
2906 __put_user(env->regs[8], &sc->regs.r8);
2907 __put_user(env->regs[9], &sc->regs.r9);
2908 __put_user(env->regs[10], &sc->regs.r10);
2909 __put_user(env->regs[11], &sc->regs.r11);
2910 __put_user(env->regs[12], &sc->regs.r12);
2911 __put_user(env->regs[13], &sc->regs.r13);
2912 __put_user(env->regs[14], &sc->usp);
2913 __put_user(env->regs[15], &sc->regs.acr);
2914 __put_user(env->pregs[PR_MOF], &sc->regs.mof);
2915 __put_user(env->pregs[PR_SRP], &sc->regs.srp);
2916 __put_user(env->pc, &sc->regs.erp);
2917 }
2918
2919 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
2920 {
2921 __get_user(env->regs[0], &sc->regs.r0);
2922 __get_user(env->regs[1], &sc->regs.r1);
2923 __get_user(env->regs[2], &sc->regs.r2);
2924 __get_user(env->regs[3], &sc->regs.r3);
2925 __get_user(env->regs[4], &sc->regs.r4);
2926 __get_user(env->regs[5], &sc->regs.r5);
2927 __get_user(env->regs[6], &sc->regs.r6);
2928 __get_user(env->regs[7], &sc->regs.r7);
2929 __get_user(env->regs[8], &sc->regs.r8);
2930 __get_user(env->regs[9], &sc->regs.r9);
2931 __get_user(env->regs[10], &sc->regs.r10);
2932 __get_user(env->regs[11], &sc->regs.r11);
2933 __get_user(env->regs[12], &sc->regs.r12);
2934 __get_user(env->regs[13], &sc->regs.r13);
2935 __get_user(env->regs[14], &sc->usp);
2936 __get_user(env->regs[15], &sc->regs.acr);
2937 __get_user(env->pregs[PR_MOF], &sc->regs.mof);
2938 __get_user(env->pregs[PR_SRP], &sc->regs.srp);
2939 __get_user(env->pc, &sc->regs.erp);
2940 }
2941
2942 static abi_ulong get_sigframe(CPUState *env, int framesize)
2943 {
2944 abi_ulong sp;
2945 /* Align the stack downwards to 4. */
2946 sp = (env->regs[R_SP] & ~3);
2947 return sp - framesize;
2948 }
2949
2950 static void setup_frame(int sig, struct target_sigaction *ka,
2951 target_sigset_t *set, CPUState *env)
2952 {
2953 struct target_signal_frame *frame;
2954 abi_ulong frame_addr;
2955 int err = 0;
2956 int i;
2957
2958 frame_addr = get_sigframe(env, sizeof *frame);
2959 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2960 goto badframe;
2961
2962 /*
2963 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
2964 * use this trampoline anymore but it sets it up for GDB.
2965 * In QEMU, using the trampoline simplifies things a bit so we use it.
2966 *
2967 * This is movu.w __NR_sigreturn, r9; break 13;
2968 */
2969 err |= __put_user(0x9c5f, frame->retcode+0);
2970 err |= __put_user(TARGET_NR_sigreturn,
2971 frame->retcode+2);
2972 err |= __put_user(0xe93d, frame->retcode+4);
2973
2974 /* Save the mask. */
2975 err |= __put_user(set->sig[0], &frame->sc.oldmask);
2976 if (err)
2977 goto badframe;
2978
2979 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2980 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
2981 goto badframe;
2982 }
2983
2984 setup_sigcontext(&frame->sc, env);
2985
2986 /* Move the stack and setup the arguments for the handler. */
2987 env->regs[R_SP] = (uint32_t) (unsigned long) frame;
2988 env->regs[10] = sig;
2989 env->pc = (unsigned long) ka->_sa_handler;
2990 /* Link SRP so the guest returns through the trampoline. */
2991 env->pregs[PR_SRP] = (uint32_t) (unsigned long) &frame->retcode[0];
2992
2993 unlock_user_struct(frame, frame_addr, 1);
2994 return;
2995 badframe:
2996 unlock_user_struct(frame, frame_addr, 1);
2997 force_sig(TARGET_SIGSEGV);
2998 }
2999
3000 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3001 target_siginfo_t *info,
3002 target_sigset_t *set, CPUState *env)
3003 {
3004 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3005 }
3006
3007 long do_sigreturn(CPUState *env)
3008 {
3009 struct target_signal_frame *frame;
3010 abi_ulong frame_addr;
3011 target_sigset_t target_set;
3012 sigset_t set;
3013 int i;
3014
3015 frame_addr = env->regs[R_SP];
3016 /* Make sure the guest isn't playing games. */
3017 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3018 goto badframe;
3019
3020 /* Restore blocked signals */
3021 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3022 goto badframe;
3023 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3024 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3025 goto badframe;
3026 }
3027 target_to_host_sigset_internal(&set, &target_set);
3028 sigprocmask(SIG_SETMASK, &set, NULL);
3029
3030 restore_sigcontext(&frame->sc, env);
3031 unlock_user_struct(frame, frame_addr, 0);
3032 return env->regs[10];
3033 badframe:
3034 unlock_user_struct(frame, frame_addr, 0);
3035 force_sig(TARGET_SIGSEGV);
3036 }
3037
3038 long do_rt_sigreturn(CPUState *env)
3039 {
3040 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3041 return -TARGET_ENOSYS;
3042 }
3043
3044 #else
3045
3046 static void setup_frame(int sig, struct target_sigaction *ka,
3047 target_sigset_t *set, CPUState *env)
3048 {
3049 fprintf(stderr, "setup_frame: not implemented\n");
3050 }
3051
3052 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3053 target_siginfo_t *info,
3054 target_sigset_t *set, CPUState *env)
3055 {
3056 fprintf(stderr, "setup_rt_frame: not implemented\n");
3057 }
3058
3059 long do_sigreturn(CPUState *env)
3060 {
3061 fprintf(stderr, "do_sigreturn: not implemented\n");
3062 return -TARGET_ENOSYS;
3063 }
3064
3065 long do_rt_sigreturn(CPUState *env)
3066 {
3067 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
3068 return -TARGET_ENOSYS;
3069 }
3070
3071 #endif
3072
3073 void process_pending_signals(CPUState *cpu_env)
3074 {
3075 int sig;
3076 abi_ulong handler;
3077 sigset_t set, old_set;
3078 target_sigset_t target_old_set;
3079 struct emulated_sigtable *k;
3080 struct target_sigaction *sa;
3081 struct sigqueue *q;
3082 TaskState *ts = cpu_env->opaque;
3083
3084 if (!ts->signal_pending)
3085 return;
3086
3087 /* FIXME: This is not threadsafe. */
3088 k = ts->sigtab;
3089 for(sig = 1; sig <= TARGET_NSIG; sig++) {
3090 if (k->pending)
3091 goto handle_signal;
3092 k++;
3093 }
3094 /* if no signal is pending, just return */
3095 ts->signal_pending = 0;
3096 return;
3097
3098 handle_signal:
3099 #ifdef DEBUG_SIGNAL
3100 fprintf(stderr, "qemu: process signal %d\n", sig);
3101 #endif
3102 /* dequeue signal */
3103 q = k->first;
3104 k->first = q->next;
3105 if (!k->first)
3106 k->pending = 0;
3107
3108 sig = gdb_handlesig (cpu_env, sig);
3109 if (!sig) {
3110 fprintf (stderr, "Lost signal\n");
3111 abort();
3112 }
3113
3114 sa = &sigact_table[sig - 1];
3115 handler = sa->_sa_handler;
3116 if (handler == TARGET_SIG_DFL) {
3117 /* default handler : ignore some signal. The other are fatal */
3118 if (sig != TARGET_SIGCHLD &&
3119 sig != TARGET_SIGURG &&
3120 sig != TARGET_SIGWINCH) {
3121 force_sig(sig);
3122 }
3123 } else if (handler == TARGET_SIG_IGN) {
3124 /* ignore sig */
3125 } else if (handler == TARGET_SIG_ERR) {
3126 force_sig(sig);
3127 } else {
3128 /* compute the blocked signals during the handler execution */
3129 target_to_host_sigset(&set, &sa->sa_mask);
3130 /* SA_NODEFER indicates that the current signal should not be
3131 blocked during the handler */
3132 if (!(sa->sa_flags & TARGET_SA_NODEFER))
3133 sigaddset(&set, target_to_host_signal(sig));
3134
3135 /* block signals in the handler using Linux */
3136 sigprocmask(SIG_BLOCK, &set, &old_set);
3137 /* save the previous blocked signal state to restore it at the
3138 end of the signal execution (see do_sigreturn) */
3139 host_to_target_sigset_internal(&target_old_set, &old_set);
3140
3141 /* if the CPU is in VM86 mode, we restore the 32 bit values */
3142 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
3143 {
3144 CPUX86State *env = cpu_env;
3145 if (env->eflags & VM_MASK)
3146 save_v86_state(env);
3147 }
3148 #endif
3149 /* prepare the stack frame of the virtual CPU */
3150 if (sa->sa_flags & TARGET_SA_SIGINFO)
3151 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
3152 else
3153 setup_frame(sig, sa, &target_old_set, cpu_env);
3154 if (sa->sa_flags & TARGET_SA_RESETHAND)
3155 sa->_sa_handler = TARGET_SIG_DFL;
3156 }
3157 if (q != &k->info)
3158 free_sigqueue(cpu_env, q);
3159 }
Samsung s3c2440 and arm920t support for the mini2440 dev board