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